What is Fastapi Mcp Langgraph Template

The fastapi-mcp-langgraph-template is a modern template designed for agentic orchestration, enabling rapid iteration and scalable deployment using customizable, community-supported tools like MCP and LangGraph.

Use cases

Use cases include building AI-driven applications, creating data pipelines, developing web services that require real-time data processing, and implementing monitoring solutions for various applications.

How to use

To use the fastapi-mcp-langgraph-template, you can follow the quick start guide available in the documentation, which includes setup instructions and examples for development and deployment.

Key features

Key features include a robust technology stack, planned features for monitoring and observability, authentication and authorization, and a customizable architecture that supports various integrations.

Where to use

This template is suitable for developing applications in fields such as AI, data analysis, and web services where agentic orchestration and scalable deployment are required.

FastAPI MCP LangGraph Template

A modern template for agentic orchestration — built for rapid iteration and scalable deployment using highly customizable, community-supported tools like MCP, LangGraph, and more.

Visit the Github:

[!NOTE]
Read the docs with demo videos here. This repo will not contain demo videos.

• FastAPI MCP LangGraph Template
  • Core Features
    • Technology Stack and Features
    • Planned Features
  • Architecture
    • Inspector
    • Template Setup
    • Reverse Proxy
    • Planned Features Diagrams
      • Monitoring and Observability
      • Authentication and Authorization
  • Quick Start
  • Development
    • VSCode Devcontainer
    • Without VSCode Devcontainer
  • Debugging
  • Refactored Markdown Files
    • MCP
    • LangGraph
    • Supabase
    • Langfuse
    • Grafana Stack

Core Features

is an open protocol that standardizes how apps provide context to LLMs.

• Seamlessly integrates LLM with growing list of community integrations found here
• No LLM provider lock in

for Customizable Agentic Orchestration

• Native streaming for UX in complex Agentic Workflows
• Native persisted chat history and state management

Technology Stack and Features

• for Python backend API
• for Python SQL database interactions (ORM + Validation).
  • Wrapper of
• for LLM Observability and LLM Metrics
• for Data Validation and Settings Management.
• for DB RBAC
  • Relational DB
  • Vector Store
• Reverse Proxy
• for development and production.

Planned Features

• for scraping Metrics
• for visualizing Metrics
• SaaS for Authentication and Authorization with OIDC & JWT via OAuth 2.0
• CI/CD via Github Actions
  • :dollar: Deploy live demo to
  • Provision with IaC
  • Push built images to ECR and Dockerhub

Architecture

This section outlines the architecture of the services, their interactions, and planned features.

Inspector

Inspector communicates via SSE protocol with each MCP Server, while each server adheres to MCP specification.

graph LR

  subgraph localhost
    A[Inspector]
    B[DBHub Server]
    C[Youtube Server]
    D[Custom Server]
  end

  subgraph Supabase Cloud
    E[Supabase DB]
  end

  subgraph Google Cloud
    F[Youtube API]
  end

  A<-->|Protocol|B
  A<-->|Protocol|C
  A<-->|Protocol|D
  B<-->E
  C<-->F

Template Setup

The current template does not connect to all MCP servers. Additionally, the API server communicates with the database using a SQL ORM.

graph LR

  subgraph localhost
    A[API Server]
    B[DBHub Server]
    C[Youtube Server]
    D[Custom Server]
  end

  subgraph Supabase Cloud
    E[Supabase DB]
  end

  A<-->|Protocol|D
  A<-->E

Reverse Proxy

Can be extended for other services like Frontend and/or certain backend services self-hosted instead of on cloud (e.g., Langfuse).

graph LR
  A[Web Browser]

  subgraph localhost
    B[Nginx Reverse Proxy]
    C[API Server]
  end

  A-->B
  B-->C

Planned Features Diagrams

Monitoring and Observability

graph LR

  subgraph localhost
    A[API Server]
  end

  subgraph Grafana Cloud
    B[Grafana]
  end

  subgraph Langfuse Cloud
    C[Langfuse]
  end

  A -->|Metrics & Logs| B
  A -->|Traces & Events| C

Authentication and Authorization

Auth0 Source

Quick Start

Setup to run the repository in both production and development environments.

Build community youtube MCP image with:

./community/youtube/build.sh

:::tip

Instead of cloning or submoduling the repository locally, then building the image, this script builds the Docker image inside a temporary Docker-in-Docker container. This approach avoids polluting your local environment with throwaway files by cleaning up everything once the container exits.

:::

Then build the other images with:

docker compose -f compose-dev.yaml build

Copy environment file:

cp .env.sample .env

Add your following API keys and value to the respective file: ./envs/backend.env, ./envs/youtube.env and .env.

OPENAI_API_KEY=sk-proj-...
POSTGRES_DSN=postgresql://postgres...

LANGFUSE_PUBLIC_KEY=pk-lf-...
LANGFUSE_SECRET_KEY=sk-lf-...
LANGFUSE_HOST=https://cloud.langfuse.com

ENVIRONMENT=production

YOUTUBE_API_KEY=...

Set environment variables in shell: (compatible with bash and zsh)

set -a; for env_file in ./envs/*; do source $env_file; done; set +a

Start production containers:

docker compose up -d

  api:
    image: api:prod
    build:
      dockerfile: ./backend/api/Dockerfile
    # highlight-next-line
    entrypoint: bash -c "sleep infinity"
    env_file:
      - ./envs/backend.env

code --no-sandbox .

docker compose -f compose-dev.yaml up -d

docker compose -f compose-dev.yaml exec nginx sh -c "nginx -s reload"