This article explains how to transform a FastAPI service into an MCP‑compatible tool, enabling AI agents to automatically orchestrate multi‑step test data creation, covering installation, project structure, code annotations, tool configuration, and practical integration with the Cursor platform.
Learn how FastAPI handles various response types—including default JSON, custom status codes and headers, HTMLResponse, FileResponse, StreamingResponse, and user‑defined response classes—while covering best practices, common pitfalls, and code examples for building robust APIs.
This guide explains FastAPI’s full application lifecycle—including startup initialization, middleware handling, request processing steps, background tasks, and graceful shutdown—so developers can design, debug, and deploy robust asynchronous APIs efficiently.
Server‑Sent Events (SSE) provide a simple, one‑way server push mechanism over HTTP, ideal for real‑time updates such as dashboards, notifications, and data streams; this guide explains SSE fundamentals, compares alternatives, and walks through integrating SSE into FastAPI using the sse‑starlette library with full code examples.
This article explains the limitations of the original Stdio and HTTP SSE communication modes for MCP, introduces the Streamable HTTP protocol that resolves those issues, and provides a step‑by‑step Python implementation of both a Streamable HTTP MCP server and a matching client, complete with environment setup, FastAPI code, JSON‑RPC handling, and tool‑calling examples.
This article provides a thorough overview of Python's role in web development, covering core components, major frameworks like Django, Flask, and FastAPI, ecosystem tools, real-world case studies, learning paths, and future trends for building modern backend applications.
FastAPI’s BackgroundTasks feature lets you register functions that run after a response is sent, enabling non‑blocking operations such as sending emails, logging, or cleaning resources, with simple code examples, parameter details, and insights into its Starlette‑based implementation and limitations.
Learn how to efficiently package, build, and run large AI models in Docker containers—from preparing the model and API code, creating Dockerfiles, building and testing images, to scaling in production with Kubernetes and GPU support—complete with step‑by‑step commands and best‑practice tips.
This guide walks you through setting up a FastAPI testing environment, creating a project structure, writing both unit and integration tests using pytest, httpx, and FastAPI's TestClient, and running the tests to ensure reliable, maintainable applications.
This guide walks through creating a FastAPI application that both publishes and consumes messages via RabbitMQ, detailing the setup of a Pika client, asynchronous consumer, message handling, API routes, and deployment with uvicorn, complete with code snippets and testing instructions.
This article introduces Pydantic (v2), explains its core validation, parsing, and serialization features, compares it with plain dataclasses, demonstrates basic to advanced usage—including optional fields, default factories, nested models, custom validators, and alias handling—while warning about version differences and AI‑generated code pitfalls.
This guide explains how FastAPI uses Pydantic models to define, validate, and parse JSON and form request bodies, set default values and custom rules, handle nested structures, and return response models, providing a type‑safe, efficient way to build backend APIs.
This tutorial walks you through installing FastAPI, setting up a project structure, creating routes that serve Jinja2‑rendered HTML pages, adding static files, building forms, and mastering essential Jinja2 syntax such as variables, conditionals, loops, template inheritance, filters, macros, and security considerations.
Learn how to design robust exception handling for FastAPI applications by combining Look‑Before‑You‑Leap and EAFP strategies, creating custom exception classes, organizing handlers, and integrating them into your API to improve maintainability, clarity, and error response consistency.
This article demonstrates how to employ Frida's RPC forwarding to intercept and bypass encryption in a mobile app, providing step‑by‑step environment setup, hook scripts, and a FastAPI service that enables Python‑based crawling of protected API endpoints.
This guide explains why environment variables are essential for FastAPI projects and provides step‑by‑step instructions for both a simple .env + python‑dotenv setup and a modern pydantic‑settings approach, including Docker integration and security best practices.
This guide walks through setting up RabbitMQ via Docker, configuring Celery with FastAPI, defining asynchronous tasks, launching workers, testing endpoints, and monitoring execution with Flower, providing a complete, step‑by‑step solution for background processing in Python web applications.
This tutorial explains how to build scalable, maintainable FastAPI APIs by modularizing routers, implementing path‑based version control, centralizing dependency injection, applying role‑based access control, using custom middleware, and nesting routers for complex applications.
This article explains how FastAPI leverages Dependency Injection to improve code reusability, modularity, and testability, covering basic examples, sub‑dependency handling, database session management with SQLAlchemy, and building a full‑featured user management API with authentication.
Learn how to set up Redis with Docker, integrate it into a FastAPI app using a custom caching decorator, and apply Redis for caching API responses, rate limiting, task queues, and distributed locks, complete with practical code examples and deployment tips.
This tutorial shows how to use the UV tool to create a Python monorepo with separate API, core, and common library projects, manage dependencies with individual pyproject.toml files, and share reusable modules across FastAPI and other services.
Learn how to implement stateless JWT authentication and role‑based authorization in FastAPI, covering token structure, installation of PyJWT, creating login and protected endpoints, custom dependencies, and testing via Swagger UI, while highlighting security benefits and best practices for robust backend APIs.
This guide explains why the Anthropic MCP protocol is essential for AI‑agent integration and walks you through building a FastAPI server, adding the fastapi‑mcp extension, and configuring the MCP endpoint so your application can communicate seamlessly with AI agents.
Learn how to dramatically improve FastAPI application speed by implementing asynchronous endpoints, database connection pooling, Redis caching, query optimization, Gzip compression, background tasks, performance monitoring, CDN static file serving, and faster JSON serialization with ujson, each illustrated with practical code examples.
Learn how to leverage Pydantic in FastAPI to handle optional fields, validate nested data structures, enforce complex business rules with model validators, forbid extra fields, work with polymorphic models, and validate query and path parameters, all illustrated with clear Python code examples.
This tutorial explains how to add request rate limiting to a FastAPI application using the SlowAPI library, covering both IP‑based limits and custom token‑based strategies, with installation steps, code examples, and best‑practice recommendations.
This article compares two primary FastAPI project structure strategies—file‑type based and module‑function based—explaining why a well‑organized architecture improves scalability, maintainability, and team collaboration, and provides concrete directory layouts and best‑practice guidelines for building robust backend applications.
This article explains how to apply SOLID principles and common design patterns such as DAO, service layer, and dependency inversion to FastAPI, demonstrating code examples that separate responsibilities, improve testability, and create a clean, maintainable backend architecture.
This guide walks you through setting up a local DeepSeek large language model, covering environment preparation, model acquisition, dependency installation, FastAPI service creation, Docker containerization, optional front‑end interface, performance tuning, and common troubleshooting steps.
This article demonstrates how to build a web‑based voice chatbot by integrating Whisper speech‑to‑text, llama.cpp LLM inference, and WebSocket communication, detailing both the frontend JavaScript implementation and the Python FastAPI backend, along with Docker deployment and example code.
This tutorial walks through creating a LangChain tool‑calling agent that combines a real‑time web search tool, a Qdrant vector store for local knowledge retrieval, and a custom Bazi fortune‑telling service, all wrapped in a FastAPI application for interactive use.
This article introduces LangServe, explains its key features for LLM deployment, walks through environment setup, shows how to build a FastAPI‑based REST API with code examples, demonstrates testing via Postman and remote client calls, and summarizes its benefits for AI model serving.
This article presents six hands‑on Python generative‑AI projects—ranging from a Llama 2 chatbot built with Streamlit and Replicate to natural‑language‑to‑SQL conversion using LlamaIndex and SQLAlchemy—complete with environment setup, required code snippets, deployment tips and resource links for further exploration.
This tutorial demonstrates building a FastAPI‑powered “Moyu Office” page that dynamically shows today’s date, weekday, and the remaining days until the weekend and major Chinese holidays, using Jinja2 templates, the zhdate library for lunar‑solar conversion, and deployment behind Nginx.
This article compares FastAPI and Flask, highlighting FastAPI's speed, developer experience, and standards support, while providing practical migration guidance, code examples, configuration tips, async handling, dependency injection, testing, deployment, and documentation differences for Python web developers.
This article explains how to craft system prompts that give an AI agent a distinct personality and emotional behavior, shows how to implement an emotion‑detection chain, compares ChatPromptTemplate.from_messages with from_template, and integrates the agent into a FastAPI service with full code examples.
This tutorial walks through installing FastAPI and related packages, creating a basic FastAPI app, adding chat, PDF, and text endpoints, integrating LangChain tools for AI responses, implementing a WebSocket echo service, and running the server with uvicorn, all illustrated with code snippets and screenshots.
This article compares Flask and FastAPI, explains their core differences in speed, developer experience, and standards, and provides step‑by‑step migration instructions, code examples, configuration tips, and deployment strategies for building modern Python web APIs.
This guide explains how to build a Retrieval‑Augmented Generation (RAG) system using JD Cloud documentation as a knowledge base, storing document embeddings in ClickHouse, leveraging LangChain for vector retrieval, and exposing query and answer services via FastAPI and a Gradio UI.
This guide walks through creating a Retrieval‑Augmented Generation pipeline that harvests JD Cloud documentation, stores vector embeddings in ClickHouse, and serves queries via FastAPI, LangChain, a Qwen LLM, and a Gradio front‑end.
This article introduces five essential Python libraries—MLflow, Streamlit, FastAPI, XGBoost, and ELI5—that every junior or intermediate machine‑learning engineer and data scientist should master to streamline experiment tracking, build interactive web apps, deploy models efficiently, achieve fast accurate predictions, and improve model interpretability.
This guide shows how to create a tiny gzip‑compressed file, serve it with FastAPI, and exploit automatic decompression in Python's requests library to force a crawler to consume massive memory, effectively turning compression into a denial‑of‑service weapon.
The guide walks through installing and quantizing the open‑source ChatGLM3‑6B model and the m3e‑base embedder on a MacBook, wrapping them with a FastAPI OpenAI‑compatible service, routing requests through a One‑API gateway, storing metadata in MongoDB and vectors in PostgreSQL pgvector, deploying FastGPT for RAG, ingesting data, and demonstrating 5‑7 second response times, while outlining future improvements.
The article explains how to enhance the open‑source AutoDev coding assistant by configuring your own large language model, customizing IDE behavior, defining custom prompts and actions, and adjusting request/response handling via FastAPI, offering step‑by‑step JSON examples and guidance for advanced developers.
This article presents a curated collection of Python web frameworks, explains what a web framework is, outlines their purposes, and provides a ranked overview of each framework's official site, advantages, and disadvantages to help developers choose the most suitable option for their projects.
This article explores the various Python frameworks and tools—Django, Django REST Framework, Flask, Requests, Swagger/OpenAPI, Marshmallow, Pydantic, Starlette, and Uvicorn—that inspired FastAPI, highlighting the features each contributed such as automatic documentation, micro‑framework flexibility, type‑hinted validation, and high‑performance async support.
This guide explains how to add, manage, and persist asynchronous scheduled jobs in a FastAPI application using APScheduler's AsyncIOScheduler with SQLite storage, covering task types, code examples, limitations, and alternative solutions such as arq, fastapi‑utils, and Celery.
This article presents a detailed survey of over thirty Python web frameworks, describing their official sites, main features, advantages, and drawbacks, and offers guidance on selecting popular options such as Django, Flask, FastAPI, and many others for various development needs.
This article explains how to employ Frida RPC to intercept and forward encrypted mobile app requests, demonstrates the required environment, provides hook scripts for encryption and decryption, and shows how to wrap them in a FastAPI service for automated crawling.
After two weeks of research, this guide presents a ranked list of 37 Python web frameworks—detailing their official sites, strengths, weaknesses, and visual overviews—to help developers choose the most supported and suitable framework for their projects.
FastAPI is a high‑performance, easy‑to‑learn Python web framework that lets you build robust APIs quickly, offering features like speed, concise code, automatic validation, and OpenAPI compatibility, with simple installation via pip and interactive documentation out of the box.
This article explains how Ctrip tackled the long, costly ML model development‑to‑deployment pipeline by adopting and extending MLflow for full lifecycle management, covering model persistence, tracking, serving, custom pyfunc models, Dockerized deployment, scaling, and performance monitoring.
This tutorial shows how to create a single‑page web app that displays the current date, weekday, and the number of days remaining until major holidays and the weekend, using FastAPI for the backend, Jinja2 for templating, and the zhdate library for lunar calendar conversion.
This article reviews eight Python frameworks—Django REST, Flask‑Restful, Falcon, Connexion, FastAPI, Hug, Eve, and Cornice—explaining their features, ideal project sizes, and how they simplify and accelerate the creation of robust APIs.
This article introduces eight Python frameworks—Django REST, Flask‑Restful, Falcon, Connexion, FastAPI, Hug, Eve, and Cornice—that help developers build APIs quickly and efficiently, highlighting each framework’s strengths, suitable project sizes, and key features.
This article introduces FakeAPI, a FastAPI‑based mock data service that lets front‑end developers quickly generate realistic JSON payloads, explains its endpoints, payload formats, repeat feature, and shows how to deploy it locally using Docker.
This article explains how to control request frequency in Python using the ratelimiter library for synchronous and asynchronous code, and introduces SlowAPI as a flexible solution for FastAPI and Flask, helping backend developers reduce server load and protect APIs from abuse.
This article walks through using FastAPI middleware for request timing, redirection, host whitelisting, and CORS, demonstrates background tasks and custom response codes, and explains various deployment options including Uvicorn, Gunicorn, Docker, and Nginx, providing complete code examples.
This article completes a FastAPI series by detailing middleware usage, request redirection, trusted host and CORS settings, background task handling, custom HTTP status responses, and multiple deployment options—including Uvicorn, Gunicorn, Docker, and Nginx—accompanied by full code examples.
This tutorial walks through deploying FastAPI in production, covering router inclusion as blueprints, handling multiple HTTP methods, integrating SQLAlchemy for database operations, applying Pydantic data validation, and implementing robust exception handling for a reliable backend service.
This article introduces FastAPI, a modern high‑performance Python web framework, walks through installation, basic routing, async handling, query and path parameters, data modeling with Pydantic, template rendering with Jinja2, and compares its speed to Flask, providing complete code examples and screenshots.
