django-native-mcp
Provides a Django-native framework for exposing tools defined in Django apps as MCP endpoints, including autodiscovery, management commands, and Streamable HTTP/stdio serving.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
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-mcpAdd the application and its configuration:
# settings.py
INSTALLED_APPS = [
# ...
"django_native_mcp",
]
DJANGO_NATIVE_MCP = {
"APP": "config.mcp:app",
}For a public Streamable HTTP host, configure the SDK host and DNS rebinding allowlists explicitly:
DJANGO_NATIVE_MCP = {
"APP": "config.mcp:app",
"HOST": "0.0.0.0",
"TRANSPORT_SECURITY_SETTINGS": {
"ENABLE_DNS_REBINDING_PROTECTION": True,
"ALLOWED_HOSTS": ["mysite.com"],
"ALLOWED_ORIGINS": ["https://mysite.com"],
},
}The optional settings preserve the official SDK defaults when omitted.
Streamable HTTP MCP is protected by bearer tokens by default. The package provides an
MCPToken model in the Django admin; its generated 40-character key is sent as
Authorization: Bearer <key>. Tokens support last_used tracking and optional expiration.
Set DJANGO_NATIVE_MCP["DEFAULT_AUTHENTICATION_CLASSES"] to a list of dotted backend paths to
replace the default django_native_mcp.authentication.MCPTokenBackend. Set it to None or []
to make the HTTP MCP endpoint public.
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 stdioTools 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.
Django permissions
Both decorators accept an optional iterable of Django permission names:
@shared_tool(permissions=["orders.view_order", "orders.change_order"])
async def update_order(order_id: int) -> dict: ...
@app.tool(permissions=["auth.view_user"])
async def count_users() -> int: ...Every listed permission is required. Before executing the tool, the server calls
await user.ahas_perms(permissions) on the user authenticated for the current HTTP request.
Django's configured AUTHENTICATION_BACKENDS determine permission access, including user
permissions, group permissions, and active superuser behavior. MCP authentication backends
authenticate tokens; Django authorization backends evaluate permissions.
Omitting permissions, passing None, or passing an empty iterable preserves unrestricted
tool access after transport authentication. Permission names are copied into an immutable tuple
at registration. The decorators return the original functions and preserve their schemas.
A protected tool returns an MCP tool error with Permission denied. when the user is absent,
anonymous, or lacks any required permission; its body does not execute. Making HTTP public
does not bypass this check. Stdio, mcp_call, and the in-process test client have no authenticated
HTTP user and cannot execute protected tools. Direct Python calls to the original decorated
function do not pass through MCP authorization. Tool listing remains common to all users.
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 HTTPThe 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
Publishing to PyPI
The existing .github/workflows/release.yml builds and checks distributions, then publishes
through PyPI Trusted Publishing when a GitHub Release is published. Configure a Trusted
Publisher for PyPI project django-native-mcp, GitHub owner xelaxela13, repository
django-native-mcp, workflow release.yml, and GitHub environment pypi.
For version 0.1.3, commit the verified release changes and create the tag v0.1.3 on that
commit. Publish a GitHub Release for that tag using the notes in CHANGELOG.md. The tag must
contain version = "0.1.3" in pyproject.toml. Publication is a separate action; building the
package locally does not publish it.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Build and run AI workflows, agents, data tables and 1000+ API integrations from any MCP client.
Host any HTTP API as a standard MCP server; auto-distribute to 12+ mainstream agent platforms.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA Django MCP server that exposes tools and resources to AI agents using simple decorators, with auto-discovery, type safety, and custom authentication.32 PyPI1MIT
- AlicenseNot gradedqualityFmaintenanceIntegrates 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.833 PyPI72MIT
- AlicenseNot gradedqualityDmaintenanceExposes Django REST Framework APIs as MCP tools for AI agents via the Model Context Protocol, with automatic discovery and security.1MIT
- AlicenseNot gradedqualityDmaintenanceAutomatically exposes Django REST Framework endpoints as MCP tools with zero configuration, supporting multiple transports and authentication.MIT