Oxbrook MCP server
Commit Oct 27, 2026A fast Python REST framework with a Rust core that exposes routes to AI agents via the Model Context Protocol.
Also known as ishangavidusha/oxbrook
- Stars
- 0
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Oct 27, 2026
- License
- MIT
What is Oxbrook MCP?
Oxbrook is a fast Python REST framework with a Rust core that exposes routes to AI agents via the Model Context Protocol.
Summary generated from the project's README
About Oxbrook MCP server
Exposing REST API routes to AI agents via the Model Context Protocol is what Oxbrook enables for developers building high-performance web services. This framework uses a Rust core to handle request parsing, routing, and validation, which allows it to reject invalid requests before a Python worker is even woken up. It is designed for users who need high throughput and native support for agentic workflows.
Developers can integrate this into their local or remote environments by installing it via pip. By setting tool=True on a specific route, that endpoint is automatically exposed at the /mcp path, inheriting the name, description, and schemas from the existing handler. This setup ensures that agent-callable tools are guarded by the same authentication mechanisms used for standard HTTP, WebSockets, and agent tool calls.
Oxbrook is built for Python 3.14 and supports both standard and free-threaded builds on Linux, macOS, and Windows. It includes built-in features like Pydantic body parsing, Redis-backed durable streams, and OpenTelemetry tracing to support production-ready applications.
What you can do with it
- 1Expose API routes to agentsA developer can turn a standard web endpoint into an AI-accessible tool by adding a single parameter.
- 2Secure agentic tool callsYou can ensure that AI agents follow the same security protocols as human users by applying standard authentication.
- 3Build high-performance web servicesEngineers can deploy services that handle massive request volumes by offloading routing and validation to Rust.
- 4Implement durable messaging streamsDevelopers can create reliable message topics that persist even if processes restart by using Redis.
Written from the project's README. Every use case is checked against a quote from it.
Automated checks
Ran Nov 16, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableishangavidusha/oxbrook is public and reachablegithub.com/ishangavidusha/oxbrook ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-10-27github.com/ishangavidusha/oxbrook ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubQuickstart
pip install oxbrook
# main.py
from oxbrook import App, Request
app = App()
@app.get("/")
async def hello(_: Request):
return {"hello": "world"}
oxbrook run main:app --reload
Or start from a project with an app, tests and instructions for coding assistants already in place:
oxbrook new my-api
Highlights
- Fast. Requests are parsed, routed and validated in Rust, and handlers run on several asyncio loops at once on free-threaded Python.
- Familiar. Typed path and query parameters, pydantic bodies, routers, middleware, dependencies and OpenAPI 3.1, the way FastAPI taught them.
- Streams built in. Topics with fan-out and backpressure, delivered over Server-Sent Events and WebSockets, durable on Redis when they must be.
- Agent-native.
tool=Trueexposes a route to AI agents over the Model Context Protocol, guarded exactly as it is over HTTP. - Production pieces included. Authentication, health probes, Prometheus metrics, OpenTelemetry tracing, rate limits, compression and graceful shutdown, without plugins.
What it does
REST
- A radix-tree router per HTTP method; path and query parameters typed by the handler's annotations and coerced in Rust. A request that cannot succeed is answered before a Python worker is woken.
- Pydantic request and response bodies, forms and multipart uploads parsed in Rust, request bodies larger than memory with backpressure, static files.
- Routers, middleware, exception handlers, dependency injection with teardown, lifespans, signed cookie sessions, CORS, response compression.
- PostgreSQL, MongoDB and Firebase as tested patterns, with a transaction per request.
- Health probes, Prometheus metrics, OpenTelemetry tracing (opt-in, free when off), rate limits, typed settings from the environment, work after the response.
- OpenAPI 3.1 from the same route metadata the router uses.
Authentication
- One
auth=declaration — API keys, bearer tokens, JWT, OpenID Connect providers, Basic, sessions or a scheme of your own — enforced before the body is read, on HTTP, WebSockets and agent tool calls alike. - Logging people in through Google, Microsoft, GitHub or any OpenID Connect provider.
Serving
- HTTP/1.1 and HTTP/2, HTTPS.
- Bounded concurrency with
503rather than an unbounded backlog, request timeouts, handlers cancelled when their client leaves. - Graceful shutdown on
SIGTERM, and anoxbrookcommand with reload for development.
Streams
- Named topics with fan-out and four backpressure policies. Subscribers on every worker loop in the process receive every message, which free-threaded CPython makes possible.
SSE(...)and@app.websocket(...)hand a topic to a client.App(redis_url=...)makes a topic durable: persisted, replayable, shared across processes, with consumer groups for work that must not be lost.
Agents
tool=Trueon a route also exposes it over the Model Context Protocol at/mcp, with its name, description and schemas taken from the handler that already exists.- Opt-in, so a route is not agent-callable until someone decides it should be.
Performance
| hello world, free-threaded 3.14 | req/s |
|---|---|
| oxbrook | 181,397 |
| granian, raw ASGI | 135,846 |
| granian + FastAPI | 29,674 |
| uvicorn + FastAPI | 12,411 |
Apple Silicon, 10 cores, 64 connections. A CPU-bound handler gains 3.15x on four worker loops on the free-threaded build, against 1.03x on the GIL build.
Hello world measures dispatch, not a framework. The performance page has the method, the machine, what each feature costs, and what has not been measured.
How it works
A tokio thread parses a request, matches it against a radix tree, coerces its parameters, and pushes a plain Rust struct onto a worker's bounded queue without touching the interpreter. It writes one byte to a socketpair only if no wakeup is already in flight, so a burst of requests collapses into a single wakeup, and each worker's asyncio loop schedules every queued handler in one callback. See internals.
With a coding assistant
Oxbrook looks like FastAPI but differs in ways an assistant will not guess.
Point it at llms.txt,
or the whole documentation in one file,
llms-full.txt.
Every documentation page has a Markdown copy, and a project made by
oxbrook new carries an AGENTS.md that points there.
Status
Alpha. Every feature is covered by the test suites on both CPython 3.14
builds, but the API is not settled. While the version is 0.x, a minor
release may change the API and a patch release does not; every change that
breaks code is listed in the
changelog.
This is a personal project, not a supported product.
Requires CPython 3.14, free-threaded (python3.14t) or standard, on Linux,
macOS or Windows. Wheels are published for both builds: x86-64 and ARM on
Linux and macOS, and x86-64 on Windows. Anywhere else pip builds from source,
which needs a Rust toolchain. Windows is supported so that the framework can be
tried and developed against on the machine in front of you; what is measured,
and what the performance page reports, is Linux and macOS.
Contributing
Building from source, running the suites and the project's conventions are in CONTRIBUTING.md.
License
MIT.
Oxbrook MCP questions
How do I expose a route to an AI agent?
You can use the tool=True parameter on a route to expose it over the Model Context Protocol at /mcp.
What authentication methods are supported?
Oxbrook supports API keys, bearer tokens, JWT, OpenID Connect, Basic auth, sessions, and custom schemes.
Is Oxbrook suitable for production?
The framework includes production-ready features like Prometheus metrics, OpenTelemetry tracing, and rate limits, but it is currently in Alpha status.