RustAPI

FastAPI-style Python Web Framework backed by a Rust (Tokio / Hyper) Engine — with embedded Rust Database Streaming, JWT & Argon2 Primitives, Tier 3 Rust-Native Routes, and a built-in MCP Server.

📦 Key Open-Source Features Included

⚡ Framework Standing & Multi-Framework Benchmarks

rustapi delivers 100% FastAPI developer experience (DX) while running on a high-performance Rust (Tokio/Hyper) core engine.

┌───────────────────────────────────────────────────────────┐
│                    Python Layer (DX)                      │
│ FastAPI Syntax • Pydantic Models • Routers • SSE • Docs   │
└─────────────────────────────┬─────────────────────────────┘
                              │  PyO3 C-Bindings
┌─────────────────────────────▼─────────────────────────────┐
│                    Rust Tokio/Hyper Core                  │
│ Async Multi-Thread IO • Tokio Workers • sqlx DB • SSE      │
└───────────────────────────────────────────────────────────┘

📊 Empirical Benchmark Results (oha Load Generator, $c=32$)

Measured under identical business logic and schemas across Python and Node.js frameworks:

Detailed report & reproducible scripts: performance-reports/rustapi_vs_fastapi_vs_nodejs.md

🏛️ The 3-Tier Execution Model

1. Tier 1 (FastAPI Drop-in): Standard Python @app.get(), async def, Pydantic models, and dependencies.
2. Tier 2 (Hybrid Rust Acceleration): Standard Python handlers utilizing native Rust power primitives (db.query_json() SQLite/PostgreSQL streaming, rustapi.encode_jwt(), rustapi.hash_password(), MiniJinja templates).
3. Tier 3 (Pure Rust Native Fast-Path): Zero-GIL C-speed routes registered with app.add_native_route("/health", ...) clocking 96,000+ req/sec at 0.57ms p95 latency.

🔄 Lifespan Context Manager (ML Models, DB Pools, Resource Cleanup)

RustAPI supports the modern FastAPI @asynccontextmanager lifespan protocol across both ASGI and native Tokio app.run():

from contextlib import asynccontextmanager
from rustapi import FastAPI

ml_models = {}

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Startup: Load ML model or connect to database before handling requests
    print("Loading application resources...")
    ml_models["hero_model"] = "Loaded Model Instance"
    yield
    # Shutdown: Clean up resources and release memory on server exit
    print("Cleaning up resources...")
    ml_models.clear()

app = FastAPI(lifespan=lifespan)

@app.get("/")
async def read_root():
    return {"model": ml_models.get("hero_model")}

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8000)

⚡ 5 Proven Ways to Maximize Performance

1. Pre-load Heavy Resources in lifespan: Load models and connection pools once during startup rather than in request handlers.
2. Zero-Copy SQL with db.query_json(): Stream database query results directly to client sockets without allocating Python dictionary objects.
3. Declare response_model for Compiled Serialization: RustAPI compiles Pydantic TypeAdapter instances once, boosting serialization by up to 64.5%.
4. Offload Health Checks to Tier 3 Native Routes: Use app.add_native_route("/health", ...) for ultra-high-frequency endpoints (96,000+ req/s).
5. Scale Multi-Process Workers: Set workers=os.cpu_count() in app.run() for multi-core parallelism.

📚 Documentation Reference

Detailed documentation is available in the docs/ directory and project reference:

• 📖 Getting Started & Core Routing
• 🔒 Security, Authentication & JWT Guide
• 📚 Complete API & Migration Guide

🛠️ Local Development & Testing

Build from source with maturin:

# Clone the repository
git clone https://github.com/rajboopathiking/rustapi.git
cd rustapi

# Build release wheel with Maturin
pip install maturin
maturin develop --release

# Run full test suite
pytest tests/ -v

PYPI Package

pip install pyrustapi

📄 License

Distributed under the MIT License.