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

🚀 Maximum Native Rust Architecture Benchmarks (PyRustAPI vs FastAPI Uvicorn, $c=50$)

Under high-concurrency production load with the maximum native Rust acceleration active:

Detailed report: performance-reports/maximum_rust_architecture_benchmark.md & guide: docs/md/maximum_rust_architecture.md

🏛️ The Maximum Native Rust 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, SIMD cosine_similarity).
3. Tier 3 (Pure Rust Native Fast-Paths & Wire Streaming): Zero-GIL routes registered via @app.get(path, sql=...), @app.get(path, sse=...), or app.add_native_route("/health", ...) clocking up to 96,000+ req/sec with sub-millisecond latencies.
4. Token-Bucket Shield & In-Memory TTL Cache: Sub-50µs 429 DDoS mitigation and sub-100µs RAM cache hits handled completely in Rust.
5. Zero-Copy Disk Streaming: High-throughput file uploads (await file.save_to(path)) streamed directly to disk at flat 15MB memory.

🔄 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:

• ⚡ Maximum Native Rust Architecture & Performance Guide
• 📖 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.