FastAPI: High-Performance Python Framework for APIs

Polyglot Architecture is becoming essential in 2026. Relying on a single "Golden Stack" can create a comfort trap. When your architecture is confined to one language, it limits scalability and fosters silos. In my recent experience integrating Generative AI with Enterprise .NET, the challenge extended beyond coding; it involved managing a diverse system where various languages address distinct concerns. Embracing a "Language Agnostic" approach is a significant architectural advantage. Here’s how I’m framing systems this year: 1. The Deterministic Core (C#/.NET): This layer is dedicated to business logic, transaction management, and high-throughput services. Type safety is not merely a preference; it serves as a defense against system regression. 2. The Experimental Edge (Python): Avoid forcing LLM orchestration into a rigid stack. Utilize Python for RAG pipelines and model fine-tuning, where the ecosystem evolves faster than the enterprise release cycle. 3. Infrastructure Fluidity: Acknowledge the reality of data gravity. Designing for GCP-to-AWS portability, such as using managed MySQL instances with clear egress strategies, helps maintain optimized cost-per-token and latency. #DotNet #AIPlatform #DistributedSystems #SoftwareEngineering

Flask vs FastAPI, Which one should you choose in 2025? A lot of developers ask: Flask or FastAPI? Short answer: it depends on your use case Flask — Simple & Flexible Lightweight and minimal Full control over architecture Great for small to medium project. You build most things yourself (auth, validation, async, docs) Best when: You want simplicity You are prototyping or building custom logic You don’t need high concurrency FastAPI — Built for Performance Super fast (ASGI + async) Automatic API docs (Swagger / Redoc) Built-in data validation with Pydantic Perfect for microservices & AI backends Best when: You are building APIs You need scalability & speed You’re working with ML / automation / agents My Take Flask is like manual transmission — more control, more effort. FastAPI is like automatic transmission — optimized, fast, and production-ready out of the box. For modern backend + AI workflows, FastAPI is usually the better choice. But Flask is still amazing when you want full customization. What do you prefer — Flask or FastAPI? Drop your thoughts below 👇 Let’s learn from each other. #Python #BackendDevelopment #FastAPI #Flask #WebDevelopment #AIBackend #Automation #SoftwareEngineering

Super excited to release the K8s Agent Orchestration Framework (KAOS) to help manage distributed agentic systems at scale 🚀 Try it out, add an issue and give it a star ⭐️ https://lnkd.in/e-tuuHTf The KAOS Framework addresses some of the pains of taking multi-agent / multi-tool / multi-model systems to hundreds or thousands of services! It started as an experiment to build agentic copilots, and has progressed as a fun endevour building distributed systems for A2A, MCP Servers, and model inference! The initial release comes with a few key features including: 1) Golang control plane to manage Agentic CRDs; 2) Python data plane that implements a2a, memory, tool / model mgmt; 3) React UI for CRUD+debugging, and; 4) CI/CD setup with KIND/pytest/ginko/etc. I have to say I am impressed on the level of abstraction that is possible to reach with agentic copilots when covering domains with higher level of experience - a blog post will follow on this topic specifically! For the meantime do check out the repo, docs and examples to try it out - as of today the most valuable thing is ideas and feedback, so do submit an issue with any thoughts! Docs: https://lnkd.in/e2F65hZz Repo: https://lnkd.in/e-tuuHTf — If you liked this post you can join 70,000+ practitioners for weekly tutorials, resources, OSS frameworks, and MLOps events across the machine learning ecosystem: https://lnkd.in/eRBQzVcA #ML #MachineLearning #ArtificialIntelligence #AI #MLOps #AIOps #DataOps #augmentedintelligence #deeplearning #privacy #kubernetes #datascience #python #bigdata

𝟱𝟬𝟬 𝘂𝘀𝗲𝗿𝘀 𝗵𝗶𝘁 𝗺𝘆 𝗮𝗶 𝗯𝗮𝗰𝗸𝗲𝗻𝗱 𝗮𝘁 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝘁𝗶𝗺𝗲 𝗮𝗻𝗱 𝗶𝘁 𝗰𝗿𝗮𝘀𝗵𝗲𝗱. Recently, I launched an AI-driven automation tool to handle real-time tasks for multiple users. The first day was chaotic: 500+ users hit the system at once, AI responses slowed, and some data got corrupted. 𝗪𝗛𝗔𝗧 𝗪𝗘𝗡𝗧 𝗪𝗥𝗢𝗡𝗚: . High concurrency exposed race conditions . Standard ORM saves were not thread-safe . No caching → every request hit the database 𝗛𝗢𝗪 𝗜 𝗙𝗜𝗫𝗘𝗗 𝗜𝗧: . Row-level locking → 0 race conditions . Redis caching → latency under 200ms .Optimized Django backend → seamless handling of hundreds of simultaneous requests 𝗥𝗘𝗦𝗨𝗟𝗧: ✅ AI tasks automated in 1.8 seconds ✅ Data integrity 100% ✅ System now scales effortlessly 𝗧𝗔𝗞𝗘𝗔𝗪𝗔𝗬𝗦 𝗙𝗢𝗥 𝗔𝗟𝗟 𝗗𝗘𝗩𝗘𝗟𝗢𝗣𝗘𝗥𝗦: . Don’t just write code. Ask: “What breaks if users grow 10× overnight?” . Real expertise = keeping systems alive under pressure #BackendEngineering #PythonDeveloper #Scalability #SystemDesign #Python #Django #AI

A weekend deep dive into local RAG architectures The best way to truly understand a technology is to build with it. I spent the last few days exploring the mechanics of Retrieval Augmented Generation. I wanted to move beyond the high level APIs and see exactly how the components interact when running entirely on local hardware. The project was a personal experiment to solve a common problem. I have thousands of messy engineering notes and code snippets. I wanted to see if a small, local language model could effectively organize them without relying on the cloud. I built Engram to test this idea. It captures raw text and uses a local Llama 3.1 model to categorize and tag it. It then stores everything in a vector database, allowing me to search for concepts rather than just keywords. It was a fascinating learning experience. I gained a much deeper appreciation for the nuance of prompt engineering and the importance of data structure in vector retrieval. I also learned how to architect an agent that pauses to ask for clarification when an input is too vague. I built it using a stack I wanted to explore further. - Frontend: React 19 and Vite - Backend: FastAPI - AI: Ollama - Database: ChromaDB I have open sourced the code for reference. I would love to hear your thoughts on local retrieval architectures or if you have experimented with similar offline setups. Repository: https://lnkd.in/gkmjxRVQ #LocalLLM #Ollama #Python #React #OpenSource #RAG

The "In-Process AI" Sneak Peek 🛑 Stop sending your data across the network just to get an embedding. I’ve been heads-down on StreamKernel v0.1.0, and the shift to a multi-module architecture has opened up some powerful new capabilities. 🧠 The hardest part of real-time RAG isn’t the AI—it’s the plumbing. Most pipelines pay a heavy tax moving data across process boundaries, jumping between JVMs, Python runtimes, sidecars, and external APIs. We’re taking a different approach: bringing the AI directly into the execution kernel. ✅ In-Process Inference: Hugging Face models running natively in the JVM via DJL ✅ Predictor Pooling: A native predictor pool that lets Java 21 Virtual Threads scale inference safely ✅ Fail-Closed Security: OPA evaluated before inference—if policy fails, the record never touches the model and is routed directly to DLQ This isn’t about replacing distributed engines like Flink—it’s about eliminating unnecessary hops when low-latency, high-throughput AI enrichment needs to live inside the stream processor. The result is a RAG feeder that can saturate vector databases like MongoDB Atlas as fast as the network can deliver raw text. No flashy benchmarks yet—just clean, modular architecture built for real systems. Full demo and details coming soon. GitHub Repo: https://lnkd.in/erb46R6f #Java21 #MachineLearning #RAG #SoftwareArchitecture #BuildingInPublic #StreamProcessing

𝗛𝗼𝘄 𝘄𝗲 𝘀𝗰𝗮𝗹𝗲𝗱 𝗜𝗱𝗲𝗻𝘁𝗶𝘁𝘆 𝗩𝗲𝗿𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗹𝗼𝘀𝗶𝗻𝗴 𝗮𝗰𝗰𝘂𝗿𝗮𝗰𝘆 🚀 We built a 𝗱𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘃𝗲𝗿𝗶𝗳𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗲𝗻𝗴𝗶𝗻𝗲 using 𝗙𝗮𝘀𝘁𝗔𝗣𝗜, 𝗖𝗲𝗹𝗲𝗿𝘆 and 𝗥𝗲𝗱𝗶𝘀, where Redis acts as a traffic controller to manage load, cache results, and prevent duplicate work during peak time. The hardest part was handling blurry or rotated document images from mobile. Our solution: try standard OCR first, and if it fails, let a 𝗩𝗶𝘀𝗶𝗼𝗻-𝗟𝗮𝗻𝗴𝘂𝗮𝗴𝗲 𝗠𝗼𝗱𝗲𝗹 (𝗤𝘄𝗲𝗻𝟯-𝘃𝗹) read the document contextually. This approach helped us maintain high accuracy even at scale, without slowing things down. Because building reliable AI is less about one perfect model and more about strong system design. Co-Dev: Yash Tiwari #AIEngineering #SystemDesign #Scalability #Python #Redis #OCR #ComputerVision

The objective: Build a system that automatically transforms OpenAPI specifications into MCP (Model Context Protocol) servers, enabling AI agents to interact with legacy APIs. I implemented a multi-agent pizza ordering system with real external MCP server integration. Here's how I tackled it: Phase 1: OpenAPI to MCP Generator - Built an automated converter that ingests OpenAPI specs and generates fully compliant MCP servers with tool decorators. No manual rewriting required. Phase 2: Pizza Ordering Agent - Developed an AI agent using LangGraph + Groq that processes natural language orders ("I want a large pepperoni pizza") and interacts with the generated MCP server. Phase 3: Scheduling Agent with Real MCP Servers - Integrated three production MCP servers: @modelcontextprotocol/server-filesystem for order receipts @modelcontextprotocol/server-memory for knowledge graph storage @cocal/google-calendar-mcp for real Google Calendar event creation Agent-to-Agent Communication - Implemented seamless handoff between Pizza Agent and Scheduling Agent using LangGraph shared state. Windows Compatibility - Solved subprocess issues with npx.cmd path detection, PowerShell execution policies, and environment variable passing to child processes. Check out the GitHub repo below : https://lnkd.in/ehRcF6CD Tech Stack: #LangChain #LangGraph #Groq #MCP #FastAPI #Python #NodeJS #GoogleCalendarAPI #MultiAgentSystems Key takeaway - The future of AI integration is not about rewriting legacy systems. It is about building protocol bridges that let AI agents communicate with existing infrastructure. MCP is that bridge. #AI #GenerativeAI #LLM #AgentAI #ModelContextProtocol #Anthropic #OpenAPI #PipelineEngineering #TechChallenge

Huge update for Kiro CLI! Version 1.24.0 brings massive improvements to autonomous agent capabilities. If you are using AI agents for complex coding tasks, context management and navigation precision are critical. This release delivers major upgrades in both areas: 🧠 Instant Code Intelligence The agent now features out-of-the-box understanding for 18 languages (including Python, Rust, TypeScript, and Java) without needing any LSP configuration. With the new /code overview command, agents can generate a complete picture of a workspace in seconds, navigate definitions, and search symbols immediately. 🎯 Precise Refactoring with AST Say goodbye to regex errors. The new pattern-search and pattern-rewrite tools allow the agent to modify code using syntax-tree patterns. This ensures structural accuracy and eliminates false matches on string literals or comments. 📚 Progressive Context Loading Introducing Skills: a new resource type for large documentation sets. Agents now load only metadata at startup and fetch full content on demand, preventing context window overload while keeping necessary info accessible. 📉 Conversation Compaction Run long sessions smoothly with the /compact command. This feature summarizes conversation history to free up context space while preserving key information—automatically triggering when the window overflows. 🛠 Dev Experience Upgrades • Custom Diff Tools: Configure external tools like delta or difftastic for structural diffs and syntax highlighting. • Remote Auth: Seamless Google or GitHub sign-in for remote machines via SSH or containers. • Granular Permissions: Use regex patterns to control exactly which URLs the web_fetch tool can access. https://lnkd.in/gKgbwe2t #AI #DevTools #AutonomousAgents #KiroCLI #Coding #SoftwareEngineering

𝗟𝗮𝗻𝗴𝗚𝗿𝗮𝗽𝗵: 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗦𝘁𝗮𝘁𝗲𝗳𝘂𝗹, 𝗖𝘆𝗰𝗹𝗶𝗰𝗮𝗹 𝗔𝗴𝗲𝗻𝘁𝘀 𝘄𝗶𝘁𝗵 𝗚𝗿𝗮𝗽𝗵𝘀 LangGraph (from LangChain) is a powerful framework for creating 𝘀𝘁𝗮𝘁𝗲𝗳𝘂𝗹, 𝗺𝘂𝗹𝘁𝗶-𝘀𝘁𝗲𝗽 𝗟𝗟𝗠 𝗮𝗴𝗲𝗻𝘁𝘀 𝘂𝘀𝗶𝗻𝗴 𝗴𝗿𝗮𝗽𝗵 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲𝘀. It shines when you need cycles (loops), branching, persistence, or human oversight — things linear chains struggle with. At its core, LangGraph models workflows as 𝗴𝗿𝗮𝗽𝗵𝘀 with three main building blocks: 𝗦𝘁𝗮𝘁𝗲 - A shared data structure (like a dict or typed schema) that holds the current "memory" of the agent. - Passed between nodes, updated along the way (e.g., conversation history, variables, tool results). - Enables persistence and continuity across steps. 𝗡𝗼𝗱𝗲𝘀 - Functions that do the work: call an LLM, use a tool, process data, or make decisions. - Each node takes the current state as input and returns updates to the state. - Can be simple Python functions or full LLM chains. 𝗘𝗱𝗴𝗲𝘀 - Define the flow: connect nodes and control what happens next. - 𝗡𝗼𝗿𝗺𝗮𝗹 𝗲𝗱𝗴𝗲𝘀: Fixed "go from A to B". - 𝗖𝗼𝗻𝗱𝗶𝘁𝗶𝗼𝗻𝗮𝗹 𝗲𝗱𝗴𝗲𝘀: Branch dynamically based on state (e.g., "if tool needed → tools node, else → end"). 𝗖𝗼𝗿𝗲 𝗙𝗲𝗮𝘁𝘂𝗿𝗲𝘀 𝗖𝘆𝗰𝗹𝗲𝘀 & 𝗕𝗿𝗮𝗻𝗰𝗵𝗶𝗻𝗴 - Graphs can loop (cycles) for iteration — e.g., agent thinks → calls tool → thinks again until done. - Conditional edges enable smart branching for dynamic decisions. 𝗣𝗲𝗿𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝗲 & 𝗦𝘁𝗮𝘁𝗲 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 - Built-in checkpointers save state at every step (to databases like SQLite/Postgres). - Resume interrupted runs, enable "time travel" debugging, or maintain long-term memory across sessions. 𝗛𝘂𝗺𝗮𝗻-𝗶𝗻-𝘁𝗵𝗲-𝗟𝗼𝗼𝗽 - Pause execution at any node (interrupt_before/after). - Wait for human approval, edits, or input while preserving full state. - Perfect for oversight in sensitive tasks. LangGraph turns complex agent logic into clear, debuggable graphs — ideal for reliable, production-ready LLM apps. #LangGraph #LangChain #LLMAgents #AICraft #Tech #GenerativeAI