🛶 Open source • PT-BR

A thin layer over the LLM SDKs

A thin PT-BR layer over the LLM SDKs, with native observability in 1 line in your .env. Swap provider/model/api_key without changing the rest of your code. Templates {{ }}, structured output, vision, audio, tools, MCP, RAG, async, retry + fallback and cost in the response.

Read the docs

$pip install "jangada-ai[all,rag,mcp]"

🤖 Feed it to Claude Code, Cursor, Codex & other AIs to integrate faster: llms.txt · llms-full.txt

swap_provider.py

from jangada_ai import LLM

# swap the provider in one line — the rest of your code stays the same
llm = LLM("anthropic", model="claude-sonnet-4-5", api_key=...)
llm = LLM("openai",    model="gpt-5",            api_key=...)

resp = llm.complete("Summarize {{ topic }} in one sentence.", topic="rafts")
print(resp.text, resp.cost)

Same API, any provider

Anthropic

OpenAI

Groq

Gemini

Mistral

OpenRouter

AWS Bedrock

Azure OpenAI

Vertex AI

Everything you need, normalized

Each SDK's complexity stays isolated in an adapter. Outside it, only normalized types flow.

Structured output

Responses validated into Pydantic models, the same across every provider.

Vision

Images as input — bounding boxes and document extraction.

Audio

Transcription via OpenAI, Groq and Gemini with the same call.

Documents

pdf, docx, csv and xlsx become text — no vision needed.

Tools

Function calling from a function, Pydantic model or dict.

MCP

Model Context Protocol: tools, resources, prompts and a built-in agent.

Agents & A2A

Agent/Squad with async tools, multi-turn chat, streaming and an A2A server.

RAG

chunk, embed and hybrid search (BM25 + vector) with pgvector/Mongo.

Step-back prompting

Generates a broader question to retrieve background context in RAG.

Guardrails

Keeps the LLM on-topic and blocks utterances — blocklist + judge classifier.

Retry + fallback

Retries and falls back to another provider when the error allows.

Cost in the response

Every Completion already comes with usage and an approximate computed cost. Prices refresh themselves at runtime (1-day cache) — no need to update the lib.

Response cache

Exact (LRU/TTL) and semantic (by similarity) — saves tokens and latency.

Async

Full sync/async parity — every method has its a* version.

Straight to the point

Structured output with Pydantic and multi-provider fallback — no boilerplate.

Structured output (Pydantic)

extraction.py

from pydantic import BaseModel
from jangada_ai import LLM

class Invoice(BaseModel):
    supplier: str
    total: float

llm = LLM("openai", model="gpt-5")
resp = llm.parse("Extract the data.", schema=Invoice, files=["invoice.pdf"])
invoice = resp.parsed  # parse() returns a Completion; the Pydantic object lives in .parsed
print(invoice.supplier, invoice.total)

Multi-provider fallback

fallback.py

from jangada_ai import LLM

# primary + error-based fallback chain (rate limit, timeout, 5xx, 404)
llm = LLM("anthropic", model="claude-sonnet-4-5").with_fallback(
    LLM("openai", model="gpt-5"),
    LLM("groq",   model="llama-4-scout"),
)

# primary failed? automatic failover, no change to the call
resp = llm.complete("Explain rafts in 1 sentence.")

SaaS platform

Observability: see every trace

Set 2 variables in your .env and jangada sends every call on its own — no code instrumentation. Track traces, latency, tokens, cost and which capabilities (tools, MCP, A2A, RAG, vision…) each call used, with filters, export and analytics. Login and token; your data doesn't live in the client's cloud.

Open the dashboard

complete · gpt-5412ms$0.0021

tools

parse · claude-sonnet-4-5688ms$0.0044

structured output

embed · gemini-embedding-001120ms$0.0001

RAGembeddings

Docs via MCP

Jangada's docs right inside your editor

A hosted MCP server hands your AI assistant the ENTIRE Jangada documentation — so it writes code with the current, correct API, without inventing functions, signatures or parameters. It's Jangada itself acting as an MCP server.

Endpoint (HTTP)https://mcp.jangada.dev.br/mcp/

How to connect

Claude Code (in the terminal)

terminal

claude mcp add jangada-mcp \
  --transport http https://mcp.jangada.dev.br/mcp/

Cursor — in ~/.cursor/mcp.json

mcp.json

{
  "mcpServers": {
    "jangada-mcp": {
      "url": "https://mcp.jangada.dev.br/mcp/"
    }
  }
}

Claude Desktop and others — in the MCP config

claude_desktop_config.json

{
  "mcpServers": {
    "jangada-mcp": {
      "url": "https://mcp.jangada.dev.br/mcp/"
    }
  }
}

Works with any client that supports MCP over HTTP — Claude Code, Claude Desktop, Cursor, Windsurf, Zed and more.

What the assistant gains

Four tools: docs index, list pages, read a page (PT/EN) and keyword search across the whole documentation.

Then just ask: "check the jangada docs and implement …" — the assistant reads the official documentation before writing the code.

Install only what you'll use

The core is lightweight (just Pydantic). Each SDK and capability is an optional extra — pick a provider, combine what you need or grab everything.

Pick a provider

Install the SDK for the one you'll use.

$pip install "jangada-ai[anthropic]"

Claude

$pip install "jangada-ai[openai]"

GPT

$pip install "jangada-ai[groq]"

Groq

$pip install "jangada-ai[gemini]"

Gemini

$pip install "jangada-ai[mistral]"

Mistral

$pip install "jangada-ai[bedrock]"

AWS Bedrock

Optional capabilities

Add them only when you need them.

$pip install "jangada-ai[files]"

Documents (pdf/docx/csv/xlsx)

$pip install "jangada-ai[rag]"

RAG (pgvector/mongo/BM25)

$pip install "jangada-ai[mcp]"

MCP client

$pip install "jangada-ai[a2a]"

A2A server (Starlette)

Shortcuts and combos

A comma joins multiple extras.

$pip install "jangada-ai[all]"

All providers + files

$pip install "jangada-ai[anthropic,groq]"

Combine extras with a comma

$pip install "jangada-ai[all,rag,mcp]"

Everything, for real

Note: the [all] extra brings all providers + files, but does not include rag nor mcp — those are installed separately, e.g.: pip install "jangada-ai[all,rag,mcp]".

Frequently asked questions

The essentials about Jangada AI in direct answers.

What is Jangada AI?

Jangada AI is an open source Python library that acts as a thin layer over LLM SDKs (Anthropic, OpenAI, Groq, Gemini and OpenRouter). It normalizes their APIs so you can swap provider, model or api_key in a single line, without rewriting the rest of your code.

Which LLM providers does Jangada AI support?

Anthropic, OpenAI, Groq, Google Gemini and OpenRouter, plus the cloud gateways AWS Bedrock, Azure OpenAI and Vertex AI — all through the same API. Each SDK's complexity stays isolated in an adapter; outside it only normalized types flow, so the same call works with any provider.

How do I install Jangada AI?

Install it via pip with the extra for the provider you'll use, for example: pip install "jangada-ai[anthropic]". The core is lightweight (just Pydantic) and each SDK or capability is an optional extra — use [all] for every provider or combine extras with a comma, like [all,rag,mcp].

Is Jangada AI free?

Yes. Jangada AI is open source under the MIT license and free for commercial and personal use. The package is published on PyPI as jangada-ai.

What is structured output in Jangada AI?

It is the ability to get LLM responses already validated into Pydantic models, identically across every provider. You define the schema and Jangada AI guarantees the response comes back typed and validated.

Does Jangada AI support async calls?

Yes. There is full sync/async parity: every method has its async version prefixed with a* (for example complete and acomplete), so you use the same code in synchronous or async contexts.

How does retry with fallback work?

When a call fails with a recoverable error, Jangada AI retries and, if needed, automatically falls back to another configured provider. That way a momentary outage of one provider doesn't take your application down.

Start paddling with Jangada AI 🛶

Install, pick a provider and switch whenever you want — without rewriting anything.

Read the docs View on GitHub