Skip to main content
Glama
xelaxela13

django-native-mcp

by xelaxela13

django-native-mcp

A small Django-native MCP application and tool registration framework inspired by Celery. It delegates protocol handling, schemas, validation, serialization, stdio, and Streamable HTTP to the official mcp Python SDK.

This is not another wrapper around FastMCP, the dependencies are only native Python SDK

Installation

pip install django-native-mcp

Add the application and its configuration:

# settings.py

INSTALLED_APPS = [
    # ...
    "django_native_mcp",
]

DJANGO_NATIVE_MCP = {
    "APP": "config.mcp:app",
}

Create the application:

# config/mcp.py

from django_native_mcp import MCP

app = MCP("backend")
app.autodiscover_tools()

Declare tools explicitly in installed Django apps:

# orders/mcp.py

from django_native_mcp import shared_tool

from .models import Order


@shared_tool
async def get_order(order_id: int) -> dict:
    """Get an order."""
    order = await Order.objects.aget(pk=order_id)
    return {"id": order.pk, "status": order.status}

The registered name is orders.get_order, using the Django application label.

python manage.py mcp_list
python manage.py mcp_inspect orders.get_order
python manage.py mcp_call orders.get_order '{"order_id": 1}'
python manage.py mcp_serve --transport stdio

Tools must use async def. The framework does not add implicit threads or sync_to_async.

Related MCP server: django-mcp

Direct application tools

from django_native_mcp import MCP

app = MCP("backend")


@app.tool(name="system.health")
async def health() -> dict:
    return {"ok": True}

@app.tool binds immediately to one application. @shared_tool remains application-independent until autodiscovery binds it.

Streamable HTTP with Django

The official SDK ASGI app can be served alone:

application = app.asgi_app()

Or route /mcp to MCP and everything else to Django:

# config/asgi.py

import os

from django.core.asgi import get_asgi_application

from django_native_mcp.asgi import MCPApplication

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
django_application = get_asgi_application()

# Import the MCP app only after Django's application registry is ready.
from config.mcp import app as mcp_app

application = MCPApplication(
    django=django_application,
    mcp=mcp_app,
    mcp_path="/mcp",
)

The dispatcher forwards ASGI lifespan to the official MCP application, so its transport lifecycle is started and stopped by the outer ASGI server.

Testing

Use the thin wrapper around the official in-process client:

from django_native_mcp.testing import MCPTestClient


async with MCPTestClient(app) as client:
    result = await client.call_tool("orders.get_order", {"order_id": 1})

End-to-end example

The example/ directory contains a runnable Django project using the built-in auth User, a Streamable HTTP MCP endpoint, and a standalone OpenAI Responses API client that discovers and calls the Django tool through MCP.

Architecture

Django apps / mcp.py
        ↓
shared_tool → ToolDefinition → ToolRegistry → MCP
                                              ↓
                                      official MCPServer
                                      ↙              ↘
                                   stdio       Streamable HTTP

The registry is process-local and becomes read-only when its official server is created. Each worker builds the same registry from source during startup.

Non-goals

This package is not an MCP protocol implementation, ORM-to-MCP generator, REST/DRF adapter, Celery replacement, background queue, or AI-agent framework. It does not automatically expose Django models and does not infer permissions from them.

License

MIT

A
license - permissive license
Not graded
quality - not tested
A
maintenance

Maintenance

Maintainers
Response time
0dRelease cycle
3Releases (12mo)
Commit activity

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    A Django MCP server that exposes tools and resources to AI agents using simple decorators, with auto-discovery, type safety, and custom authentication.
    MIT
  • A
    license
    Not graded
    quality
    F
    maintenance
    Integrates MCP tool hosting into Django applications, enabling easy definition and serving of MCP tools, resources, and prompts via ASGI with support for URL path parameters and logging.
    72
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    A Model Context Protocol (MCP) server for developing Django applications. It exposes Django project information through MCP tools, enabling AI assistants to better understand and interact with Django codebases.
    109
    MIT
  • A
    license
    Not graded
    quality
    C
    maintenance
    Exposes Django REST Framework APIs as MCP tools for AI agents via the Model Context Protocol, with automatic discovery and security.
    1
    MIT

View all related MCP servers

Related MCP Connectors

  • An MCP server that let you interact with Cycloid.io Internal Development Portal and Platform

  • Your DRF API as MCP tools — 1,800 endpoints become 16 dispatchers, permissioned by Django.

  • Official Sevalla MCP — full PaaS API access through just 2 tools.

View all MCP Connectors

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/xelaxela13/django-native-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server