Ship Production Apps in Days, Not Months

There are millions of Python packages and millions of ways to build an app.

You can spend weeks wiring together auth libraries, job queues, webhook handlers, LLM providers, banking APIs—thousands of lines of glue code before you write a single line of business logic.

We think that's backwards.

After years of building SaaS products and rewriting the same infrastructure patterns, we extracted everything into three focused packages and open-sourced them.

One goal: developer experience.

pip install svc-infra ai-infra fin-infra

Let me show you what's inside — and how to get something real running in a few minutes.

Who This Is For

• Backend engineers who are tired of rebuilding auth, billing, jobs, and webhooks.


• AI engineers and agents who want reliable, non‑hallucinated infrastructure primitives.


• Fintech builders who just want Plaid, portfolios, and cashflow analytics to "just work".

If you reach for FastAPI, LangGraph, or Plaid more than once a year, this stack is for you.

From Zero to API in 5 Minutes

Here is the kind of thing you can have running before your coffee cools down:

from svc_infra.api.fastapi.ease import easy_service_app

from svc_infra.api.fastapi.auth import add_auth_users

from svc_infra.api.fastapi.db.sql.add import add_sql_db

from svc_infra.jobs.easy import easy_jobs



app = easy_service_app(name="MyAPI", release="1.0.0")

add_sql_db(app)

add_auth_users(app)

queue, scheduler = easy_jobs()



@app.post("/api/process")

async def process(user=Depends(current_active_user)):

    queue.enqueue("heavy_task", {"user_id": user.id})

    return {"status": "queued"}

You get a real API with auth, database, and background jobs — no glue code, no YAML explosion.

The Problem

Every project starts the same way:

1. ✅ Set up FastAPI


2. ⏳ Add authentication (JWT? Sessions? OAuth? MFA?)


3. ⏳ Wire up a database with migrations


4. ⏳ Need background jobs? Set up Redis, write a worker, handle retries


5. ⏳ Want webhooks? Implement HMAC signing, retries, delivery tracking


6. ⏳ Add AI features? Integrate OpenAI, then Anthropic, then Google...


7. ⏳ Fintech app? Figure out Plaid, handle bank account syncing

By the time you've written all the infrastructure, you've lost momentum. The actual product idea sits waiting.

And here's the thing: AI agents have the same problem.

With tools like Cursor, Copilot, and Devin writing code autonomously, we noticed something: agents are great at business logic but struggle with infrastructure. They hallucinate auth flows, mess up webhook signatures, reinvent caching patterns with subtle bugs.

Both humans and AI need standardized, battle-tested infrastructure.

Package 1: svc-infra (Backend Infrastructure)

Everything you need to ship a SaaS backend, wired in one function call.

Quick Start

from svc_infra.api.fastapi.ease import easy_service_app

from svc_infra.api.fastapi.auth import add_auth_users

from svc_infra.api.fastapi.db.sql.add import add_sql_db

from svc_infra.jobs.easy import easy_jobs



# Create app with batteries included

app = easy_service_app(name="MyAPI", release="1.0.0")



# Add infrastructure

add_sql_db(app)               # PostgreSQL with migrations

add_auth_users(app)           # Full auth system

queue, scheduler = easy_jobs() # Background jobs



# Your business logic - that's it!

@app.post("/api/process")

async def process(user=Depends(current_active_user)):

    queue.enqueue("heavy_task", {"user_id": user.id})

    return {"status": "queued"}

That's a production-ready API with auth, database, and background jobs.

What's Included

Real Example: Auth System

Here's what add_auth_users(app) gives you:

# Automatic routes registered:

# POST /auth/register

# POST /auth/login

# POST /auth/logout

# POST /auth/forgot-password

# POST /auth/reset-password

# POST /auth/verify

# GET  /auth/me

# POST /auth/mfa/setup

# POST /auth/mfa/verify

# Plus OAuth routes for each provider...

With one function call, you get:

• JWT tokens with refresh


• Session cookies


• OAuth/OIDC (Google, GitHub, etc.)


• MFA/TOTP


• Password policies and breach checking


• Account lockout


• Key rotation support

Customizable when you need it:

add_auth_users(

    app,

    jwt_lifetime_seconds=3600,

    enable_mfa=True,

    oauth_providers=["google", "github"],

    password_min_length=12,

    require_email_verification=True,

)

GitHub: github.com/nfraxio/svc-infra

Package 2: ai-infra (AI/LLM Infrastructure)

One interface for LLMs, agents, RAG, and MCP—across 10+ providers.

Quick Start

from ai_infra import LLM, Agent, Retriever



# Chat with any provider

llm = LLM()  # Uses OPENAI_API_KEY by default

response = llm.chat("Explain quantum computing")



# Switch providers with one line

llm = LLM(provider="anthropic", model="claude-sonnet-4-20250514")

response = llm.chat("Same question, different model")

Build an Agent with Tools

from ai_infra import Agent



def get_weather(city: str) -> str:

    """Get current weather for a city."""

    return f"72°F and sunny in {city}"



def search_docs(query: str) -> str:

    """Search internal documentation."""

    return db.search(query)



agent = Agent(tools=[get_weather, search_docs])

result = agent.run("What's the weather in Tokyo and how do I configure auth?")

# Agent automatically calls both tools and synthesizes the answer

RAG in 5 Lines

from ai_infra import Retriever



retriever = Retriever()

retriever.add_file("company_docs.pdf")

retriever.add_file("product_manual.md")



results = retriever.search("How do I reset my password?")

Multiple backends supported:

# Development

retriever = Retriever(backend="memory")



# Local persistence

retriever = Retriever(backend="sqlite", path="./vectors.db")



# Production

retriever = Retriever(backend="postgres", connection_string="...")

retriever = Retriever(backend="pinecone", index_name="my-index")

MCP (Model Context Protocol) Support

Full MCP client with interceptors:

from ai_infra import MCPClient

from ai_infra.mcp import RetryInterceptor, CachingInterceptor



async with MCPClient(

    "http://localhost:8080",

    interceptors=[

        RetryInterceptor(max_retries=3),

        CachingInterceptor(ttl=300),

    ]

) as client:

    tools = await client.list_tools()

    result = await client.call_tool("search", {"query": "test"})

Create MCP servers from plain functions:

from ai_infra import mcp_from_functions



def search_docs(query: str) -> str:

    """Search documentation."""

    return db.search(query)



def get_user(user_id: str) -> dict:

    """Get user details."""

    return {"id": user_id, "name": "John"}



mcp = mcp_from_functions(

    name="my-mcp",

    functions=[search_docs, get_user]

)

mcp.run(transport="stdio")

Supported Providers

GitHub: github.com/nfraxio/ai-infra

Package 3: fin-infra (Financial Infrastructure)

Production-ready financial data for fintech apps.

Quick Start

from fin_infra.banking import easy_banking

from fin_infra.investments import easy_investments

from fin_infra.markets import easy_market



# Connect bank accounts via Plaid

banking = easy_banking(provider="plaid")

accounts = await banking.get_accounts(access_token)

transactions = await banking.get_transactions(account_id)



# Investment holdings with real P/L

investments = easy_investments(provider="plaid")

holdings = await investments.get_holdings(access_token)

for h in holdings:

    print(f"{h.symbol}: {h.quantity} shares, P/L: ${h.unrealized_gain}")



# Market data

market = easy_market()

quote = market.quote("AAPL")

print(f"AAPL: ${quote.price}")

Financial Calculations

from fin_infra.cashflows import npv, irr, loan_payment



# Net Present Value

cashflows = [-100000, 30000, 30000, 30000, 30000]

value = npv(rate=0.08, cashflows=cashflows)



# Internal Rate of Return

rate = irr(cashflows)



# Loan payments

monthly = loan_payment(principal=250000, rate=0.065, years=30)

What's Included

• 
  Banking: Plaid/Teller integration, accounts, transactions


• 
  Investments: Holdings with cost basis, real P/L, asset allocation


• 
  Market Data: Stocks, crypto, forex quotes and history


• 
  Credit: Credit scores and monitoring


• 
  Analytics: Cash flow, savings rate, spending insights


• 
  Calculations: NPV, IRR, loan amortization

GitHub: github.com/nfraxio/fin-infra

The Philosophy

1. Developer Experience is Everything

There are a million ways to build an app. We obsessed over making infrastructure disappear so you can ship in days, not months—in 10 lines, not 1000.

2. Sensible Defaults, Full Flexibility

Every function works out of the box with zero configuration. But everything is customizable:

# Just works

app = easy_service_app(name="MyAPI")



# Customized

app = easy_service_app(

    name="MyAPI",

    enable_cors=True,

    cors_origins=["https://myapp.com"],

    enable_metrics=True,

    metrics_path="/custom-metrics",

)

3. Composable, Not Monolithic

Use svc-infra alone for a SaaS. Add ai-infra for AI features. Add fin-infra for fintech. They work together but don't require each other.

4. Production-Tested

We run these in production. Not a weekend project—actual error handling, retries, observability, battle-tested patterns.

What's Next

These three packages are just the beginning.

We're expanding to cover more domains—healthcare, e-commerce, IoT, whatever developers need.

We're going multi-language. The goal is the same across any language or framework: developer experience, simplicity, full flexibility, production readiness.

TypeScript, Go, Rust—all coming. Ship production-ready apps fast, in any language.

Get Started

pip install svc-infra ai-infra fin-infra

All MIT licensed. Full docs in each repo.

Links:

• 
  nfrax - Documentation and integration


• 
  nfrax-docs-mcp - MCP for IDE integration


• 
  svc-infra - Backend infrastructure


• 
  ai-infra - AI/LLM infrastructure


• 
  fin-infra - Financial infrastructure

Questions?

Drop a comment below! Happy to discuss:

• Architecture decisions we made


• Tradeoffs and why


• How specific features work


• What you'd like to see added

We built this because we got tired of rewriting the same patterns. Hoping it saves you time too.

⭐ Star us on GitHub if this is useful!