Jesper Dramsch’s Post

🚀 Day 62 – What is FastAPI? | My Learning Journey in AI & ML Today I explored FastAPI, one of the fastest-growing frameworks for building APIs in Python—and honestly, it lives up to its name! ⚡ 🔹 What is FastAPI? FastAPI is a modern, high-performance web framework used to build APIs quickly using Python. It’s designed for speed, simplicity, and scalability. 🔹 Why FastAPI is powerful? ✔️ Super fast (built on ASGI & Starlette) ✔️ Automatic API documentation (Swagger UI) ✔️ Easy to learn & use ✔️ Built-in data validation using Pydantic ✔️ Perfect for ML model deployment 🔹 Where is it used? 👉 Deploying Machine Learning models 👉 Building backend services 👉 Creating REST APIs 👉 Real-time applications 🔹 Simple Example: from fastapi import FastAPI app = FastAPI() @app.get("/") def home(): return {"message": "Hello, FastAPI!"} 💡 My Key Takeaway: FastAPI makes it incredibly easy to convert ML models into production-ready APIs with minimal code. 📌 Next Step: I’ll be building and deploying my own ML API using FastAPI soon! #Day62 #FastAPI #Python #MachineLearning #AI #BackendDevelopment #APIs #LearningJourney

🚨 Every $0 AI stack tutorial shows you LangGraph, Ollama, and ChromaDB. But almost none of them explain how to actually expose your agent to the outside world. I hit this wall immediately while building my async RAG pipeline designed to process and extract data from Pubmed articles. My orchestrator is Python. My UI is Chainlit. But something needs to sit cleanly between them. That's when I realized: FastAPI + Pydantic is the missing layer nobody draws in the architecture diagrams. 🧩 Here is why they are becoming non-negotiable for my stack: 🛡️ Pydantic: Strictly validates inputs before they ever reach the LLM, preventing hallucinations at the source. ⚡ FastAPI: Turns the Python agent into a robust, async REST API in about 20 lines of code. I am currently integrating both to bridge the gap between my backend processing and the user interface. To the AI and Data Engineers out there who have built this before: what is the #1 trap I should avoid when setting up FastAPI for LLM agents? 👇 #FastAPI #Pydantic #DataEngineering #Bioinformatics #BuildInPublic

Here’s the easiest way to fix context window limits: Stop putting documents in the prompt… Put them in a REPL instead. Instead of building complex RAG pipelines and other hacks to work around context limits, load the document as a variable in a persistent Python environment. This is the core idea behind Recursive Language Models (RLMs) as an orchestration technique. The model never sees the full document. It only gets metadata: • Size • Structure • Available functions • How to access it Then the model writes code to explore it. Each step runs inside a persistent REPL. Variables survive across iterations. So the model builds results progressively: • Filtered subsets • Intermediate buffers • Partial summaries • Structured outputs When deeper reasoning is needed, it spawns a sub-call: llm_query(prompt, chunk) Only that chunk goes to a worker model. The result returns to the REPL. The main context stays clean. Only small execution results get appended to history. This keeps the context window a constant size. Here's the takeaway: Traditional RAG → you engineer the context REPL loop → the model engineers its own context This is context engineering on autopilot. Load the large state into memory. Let the model inspect it. Keep the prompt minimal. Cleaner context. Lower cost. Better reasoning over large data. I broke down the full RLM mechanism in a recent newsletter. Check it out here: https://lnkd.in/dj5PWtSW

We benchmarked LLMs on their ability to analyze code files across 25 files in TypeScript, Python, Rust, Go, Markdown, and HTML on parameters like Search, Graph, Semantics, Integration, Security Mapping, Business Context, and JSON handling. Models can top leaderboards like SWE-Bench Pro while failing at basic creative and practical tasks. Optimizing for the test is not the same as optimizing for the work. Results: #claude-sonnet-4.6 ranked #1 with a weighted score of 121.2 at $1.66, the only Pareto Optimal pick among premium models. #claude-opus-4.6 scored 117.0 but at $8.00, sonnet-4.6 beats it cheaper. #glm-5v-turbo emerged as the best budget Pareto Optimal pick at just $0.28 with a score of 113.0. #gpt-5.4-nano is the most cost-efficient Pareto Optimal option at $0.04 with a score of 103.3. Notably, glm-5.1 despite ranking #1 on SWE-Bench Pro scored only 106.7 here at $0.60, beaten by cheaper alternatives. Models like Gemini 3.1 Pro Preview and GPT-4o-mini ranked near the bottom despite their popularity. The leaderboard confirms that benchmark performance rarely translates to real-world task quality. If you would like to reduce your AI agents cost including your AI copilots, please get in touch with us.

PSA: Check your AI-generated requirements files before they nuke production. I've noticed a pattern — when you ask an AI to write a requirements.txt or environment.yml, it almost always reaches for >=: flask>=2.3.0 sqlalchemy>=2.0.0 pydantic>=2.5.0 Looks reasonable, right? It's not. Here's what actually happens six months later when you deploy to a fresh server: 1. Pydantic 2.x → 3.x ships a breaking change. Your entire validation layer silently starts rejecting payloads that worked yesterday. No error on install. Just 500s at runtime. 2. SQLAlchemy quietly drops a deprecated API. Your ORM queries that ran fine for a year now throw AttributeError deep in a call stack. Good luck debugging that at 2 AM. 3. Flask upgrades and one of its pinned sub-dependencies conflicts with yours. Now pip install itself fails and your CI/CD pipeline is just... red. Indefinitely. On code you never changed. 4. NumPy 2.0 lands. Half the scientific Python ecosystem isn't compatible yet. Your data pipeline that "just works" no longer does — on a Monday morning, naturally. The fix is boring: pip freeze > requirements.txt Pin with ==. Every time. In production, reproducibility isn't a nice-to-have — it's the whole game. If an AI generates your dependency file, treat it like any other code review. The convenience of >= is a deferred incident report. #Python #DevOps #SoftwareEngineering #AI #LessonsLearned

Just built my first RAG (Retrieval-Augmented Generation) Application! 🚀 The idea is simple upload any PDF and chat with it using AI. Ask questions, get answers all from your own document. 🛠️ Tech Stack: → FastAPI (Backend) → Mistral AI (LLM + Embeddings) → ChromaDB (Vector Store) → LangChain (RAG Pipeline) → HTML/CSS/JS (Frontend) ⚙️ How it works: 1. Upload your PDF 2. It gets split into chunks & converted to embeddings 3. Stored in ChromaDB vector store 4. You ask a question → relevant chunks are retrieved → Mistral AI generates the answer Built this from scratch while learning GenAI still building. 🔥 Agents & Deployment coming very soon! 🔗 GitHub: [https://lnkd.in/gNhZ2pJN] #GenAI #RAG #LangChain #FastAPI #MachineLearning #Python #BuildInPublic

📣 Every LLM framework eventually adds async support. SynapseKit started there. There's a difference between async-retrofitted and async-native. Most frameworks started synchronous, bolted async on later, and shipped the seams - hidden event loop management, sync wrappers that infect the core, bugs that only surface under concurrent load. SynapseKit was designed async-first from the first commit. Every public API is async/await. No exceptions. No hidden sync layers underneath. If you understand Python and async, you understand SynapseKit. What that means in practice: → Stream tokens from any of 33 providers identically- not a special mode, the default → Run parallel graph nodes via real asyncio.gather - not simulated concurrency → No event loop surprises under load → Sync wrappers exist for scripts and notebooks - they call into the async layer, they don't replace it And the dependency story: 2 hard dependencies. numpy and rank-bm25. That's it. Everything else - LLM providers, vector stores, document loaders, tools - is behind an optional install extra. You pay only for what you use. No transitive conflicts. No 267-package installs. No surprise breakage when a framework you didn't know you depended on ships a breaking change. pip install synapsekit[openai] # 2 deps + openai pip install synapsekit[all] # everything Async-native. Minimal. Transparent. #Python #AsyncPython #LLM #RAG #OpenSource #AI #MLEngineering #SynapseKit

If your CI pipeline is slow, start by looking at how your test suite is being split. 𝗽𝘆𝘁𝗲𝘀𝘁-𝘀𝗽𝗹𝗶𝘁 is a pytest plugin that does one thing well: it splits your test suite into equally timed sub-suites, not equally sized ones. Most naive approaches split by test count. 𝗽𝘆𝘁𝗲𝘀𝘁-𝘀𝗽𝗹𝗶𝘁 stores actual execution times in a .test_durations file and uses that data to balance wall-clock time across groups. Run --store-durations once, commit the file, and your CI groups will finish at roughly the same time. New or renamed tests are handled gracefully by falling back to average durations. No need to re-run --store-durations after every change. 🔗 Link to repo: github(.)com/jerry-git/pytest-split --- ♻️ Found this useful? Share it with another builder. ➕ For daily practical AI and Python posts, follow Banias Baabe.

Something I built today that genuinely excited me 🧵 I gave Claude the ability to publish blog posts on my behalf. Not by clicking buttons. Not by copy-pasting. By actually building the infrastructure that makes it possible. Here's what I built: A Python FastAPI MCP server that connects Claude AI directly to my Dev.to account — with three tools: get my profile, create a draft, and publish a post. I type in Claude.ai chat: "Publish this article to Dev.to" And it does. For real. The stack: → Python + FastAPI for the server → Model Context Protocol (MCP) for AI-tool communication → Dev.to API for publishing → ngrok to expose it publicly The part that hit different — debugging the entire handshake between Claude.ai and my server live. Every 400 error taught me something about how AI agents actually communicate with tools under the hood. This is what agentic AI looks like in practice. Not a demo. Not a tutorial. Built from scratch, debugged end to end, working in production. Code dropping tomorrow on GitHub P.S. The first post Claude published on my behalf  is already live link in the comment👇 What are you building with MCP? #AgenticAI #MCP #FastAPI #Python #LangGraph #AIEngineer

Building Bayesian APIs with FastAPI 🚀 I’ve been experimenting with exposing Bayesian statistical methods through a REST API using FastAPI. Here’s a sneak peek at how I’m serving Hamiltonian Monte Carlo (HMC) sampling and Bayesian linear regression endpoints: from fastapi import FastAPI import numpy as np app = FastAPI() @app.post("/hmc") def run_hmc(n_samples: int = 1000): samples = hmc(n_samples=n_samples) return {"mean": float(np.mean(samples)), "std": float(np.std(samples))} @app.post("/bayesian_regression") def bayesian_regression(): X = np.random.randn(100, 2) true_beta = np.array([2.0, -1.0]) y = X @ true_beta + np.random.randn(100) samples = hmc_regression(X, y) return { "beta_mean": samples.mean(axis=0).tolist(), "beta_std": samples.std(axis=0).tolist() } Why this matters: Scalability: FastAPI makes it easy to deploy Bayesian models as microservices, enabling real-time inference. Accessibility: REST APIs democratize advanced statistical methods for teams without deep Python expertise. Performance: FastAPI’s async support ensures low latency, even for computationally intensive tasks like HMC. Use cases: A/B testing with Bayesian updates Uncertainty-aware predictions in production Collaborative modeling via APIs Thoughts? Have you built APIs for statistical models? What tools do you use? Disclaimer: This is a personal project and not financial or professional advice. #FastAPI #Bayesian #DataScience #MachineLearning #Python #APIs #HMC