jitapi
JitAPI is an MCP server that lets Claude interact with any API by registering its OpenAPI spec and using semantic search and dependency resolution to automatically find and execute the right endpoints.
Register APIs (
register_api): Ingest any OpenAPI spec from a URL, automatically parsing it, building a dependency graph, and creating searchable embeddings for all endpointsList Registered APIs (
list_apis): View all registered APIs and their endpoint countsSearch Endpoints (
search_endpoints): Semantically search across endpoints in one or all registered APIs using natural language queriesGet Workflow (
get_workflow): Retrieve a sequence of relevant endpoints with full schemas and dependency resolution for a given task, enabling correct multi-step execution across single or multiple APIsGet Endpoint Schema (
get_endpoint_schema): Fetch complete parameter and response schema details for a specific endpointCall API (
call_api): Execute API calls with support for path params, query params, and request bodySet API Authentication (
set_api_auth): Configure auth (bearer token, API key header/query) using direct credentials or securely via environment variable referencesDelete API (
delete_api): Remove a registered API and all associated data including embeddings, dependency graph, and auth credentialsFlexible embeddings: Use local embeddings by default or cloud providers (Voyage AI, OpenAI, Cohere) for improved search quality
Allows interaction with the GitHub API by registering its OpenAPI specification, enabling users to perform actions like listing repositories and managing account data through natural language commands.
Enables seamless interaction with Stripe's extensive API (over 300 endpoints) by indexing its OpenAPI spec, allowing for automated endpoint discovery and execution of financial workflows.
JitAPI
Point Claude at any API. JitAPI figures out which endpoints to call and in what order — automatically.
JitAPI is an MCP server that lets Claude interact with any API from its OpenAPI spec. Instead of dumping hundreds of endpoints into context, JitAPI uses semantic search and a dependency graph to surface only what's needed — then Claude plans and executes the calls.
https://github.com/user-attachments/assets/53f72f89-a41a-4a9c-a688-ec876ea05fbd
The Problem
Stripe has 300+ endpoints. GitHub has 800+. Loading the full spec into Claude's context wastes tokens and causes hallucinations. Writing a custom MCP server for every API you use doesn't scale.
JitAPI solves this: register any OpenAPI spec once, then ask for what you need in plain English. It finds the right endpoints, resolves dependencies between them, and lets Claude execute the calls.
Related MCP server: OpenAPI to MCP
Quick Start
pip install jitapiAdd to your Claude Code config (.mcp.json):
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"]
}
}
}That's it. No API keys required — JitAPI uses local embeddings out of the box.
Then in Claude:
You: Register the GitHub API from https://raw.githubusercontent.com/github/rest-api-description/main/descriptions/api.github.com/api.github.com.json
Claude: ✓ Registered GitHub v3 REST API — 1,107 endpoints indexed
You: List my repos
Claude: [searches for "list repositories for authenticated user" → finds GET /user/repos → executes]
Here are your repositories: ...Multi-API Orchestration
The killer feature: register multiple APIs and ask questions that span them. JitAPI searches across all registered APIs and Claude chains the calls.
You: Register the TMDB API and OpenWeatherMap API
Claude: ✓ Registered both APIs
You: Find the top popular movie on TMDB, then get the weather where it was filmed
Claude: [searches TMDB → GET /movie/popular → GET /movie/{id} for production locations
→ searches OpenWeather → GET /data/2.5/weather with the city]
The #1 popular movie is "Inception", filmed in Los Angeles.
Current weather in LA: 72°F, partly cloudy.How It Works
Register API Ask a question
│ │
▼ ▼
Parse OpenAPI spec Embed query → vector search
│ │
▼ ▼
Build dependency graph Find relevant endpoints
│ │
▼ ▼
Embed all endpoints Expand with dependencies
│ │
▼ ▼
Store in vector DB Return schemas → Claude executesRegister — Parse an OpenAPI spec, build a dependency graph (which endpoints need data from which other endpoints), and create searchable embeddings for all endpoints
Search — When you ask a question, JitAPI embeds your query and finds the most relevant endpoints via cosine similarity
Expand — The dependency graph adds any prerequisite endpoints (e.g., "you need to call GET /users first to get the user_id for POST /orders")
Execute — Claude gets the endpoint schemas and makes the API calls, passing data between steps
MCP Tools
Tool | Description |
| Register an API from an OpenAPI spec URL |
| List all registered APIs and their endpoint counts |
| Semantic search across endpoints using natural language |
| Find relevant endpoints with dependency resolution and full schemas |
| Get the complete schema for a specific endpoint |
| Execute a single API call with auth, path params, query params, and body |
| Configure authentication (API key header, API key query param, or bearer token) |
| Remove a registered API and all its data |
Setup
Claude Code
Create .mcp.json in your project directory (or ~/.claude.json for global access):
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"]
}
}
}Claude Desktop
Add to your Claude Desktop config:
OS | Config path |
macOS |
|
Windows |
|
Linux |
|
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"]
}
}
}Embedding Providers
JitAPI works out of the box with local embeddings (fastembed) — no API keys needed. For better search quality on large APIs, you can add a cloud embedding provider:
Provider | Quality | Setup |
Local (default) | Good | Nothing — works immediately |
Voyage AI (recommended) | Excellent |
|
OpenAI | Excellent |
|
Cohere | Very good |
|
Set the API key in your MCP config's env block:
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"],
"env": {
"VOYAGE_API_KEY": "your-key-here"
}
}
}
}Provider is auto-detected from available environment variables. Priority: Voyage AI > OpenAI > Cohere > local.
Authentication
Configure API authentication after registering. Supported auth types: bearer, api_key (custom header), and api_key_query (query parameter). The recommended approach uses environment variables so secrets are never written to disk:
{
"mcpServers": {
"jitapi": {
"command": "uvx",
"args": ["jitapi"],
"env": {
"GITHUB_TOKEN": "ghp_...",
"OPENWEATHER_API_KEY": "your-key-here"
}
}
}
}Then tell Claude to use the env var:
You: Set bearer auth for GitHub using env var GITHUB_TOKEN
Claude: [calls set_api_auth with auth_type="bearer", env_var="GITHUB_TOKEN"]
✓ Auth configured for github (from env var $GITHUB_TOKEN)With env_var, JitAPI reads the secret from the environment at request time — only the env var name is persisted, never the credential itself.
You can also pass credentials directly (they'll be stored in ~/.jitapi/auth.json with 0600 permissions):
You: Set API key auth for OpenWeather with param name "appid"
Claude: [calls set_api_auth with auth_type="api_key_query", credential="...", param_name="appid"]
✓ Auth configured for openweatherSupported auth types: bearer, api_key (custom header, default X-API-Key), api_key_query (query parameter).
Security note: When using
env_var, credentials are resolved at runtime and never touch the filesystem. When passingcredentialdirectly, secrets are stored as plaintext JSON at~/.jitapi/auth.json(file permissions0600, directory0700). For production use, prefer theenv_varapproach.
Environment Variables
Variable | Required | Description |
| No | Voyage AI API key (recommended cloud provider) |
| No | OpenAI API key (alternative cloud provider) |
| No | Cohere API key (alternative cloud provider) |
| No | Data directory (default: |
| No | DEBUG, INFO, WARNING, ERROR (default: INFO) |
Development
git clone https://github.com/nk3750/jitapi.git
cd jitapi
pip install -e ".[dev]"
pytest
ruff check src/License
MIT
Built by Neelabh Kumar — AI engineer and builder.
Available Tools
8 toolscall_apiB
Execute an API call. Make sure authentication is configured first.
Inputs: api_id (required), endpoint_id (required), path_params, query_params, +1 more.
delete_apiA
Delete a registered API and all its data including endpoints, embeddings, dependency graph, and authentication credentials.
Inputs: api_id (required).
get_endpoint_schemaB
Get the full schema for a specific endpoint. Use this to get detailed parameter and response information.
Inputs: api_id (required), endpoint_id (required).
get_workflowA
Get relevant endpoints with dependency resolution and full schemas for accomplishing a task. Returns search results expanded with their dependencies so you can plan and execute the right API calls in the right order. After reviewing the results, use call_api to execute each step.
Inputs: query (required), api_id (required), max_steps.
list_apisB
List all registered APIs with their basic information.
Inputs: no named parameters.
register_apiA
Register a new API by ingesting its OpenAPI specification. This parses the spec, builds a dependency graph, and creates searchable embeddings.
Inputs: api_id (required), spec_url (required).
search_endpointsA
Search for API endpoints using natural language. Returns semantically similar endpoints based on the query.
Inputs: query (required), api_id, top_k.
set_api_authA
Configure authentication for an API. Supports API key (header or query param) and bearer token auth. Use env_var to reference a secret from an environment variable — the credential is then resolved at request time and never stored on disk.
Inputs: api_id (required), auth_type (required), credential, env_var, +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Each tool has a clearly distinct purpose: register/delete/list for API lifecycle management, search_endpoints for discovery, get_endpoint_schema for detailed inspection, get_workflow for task planning with dependencies, set_api_auth for configuration, and call_api for execution. No overlapping functionality.
Consistent snake_case throughout with verb_noun pattern (call_api, delete_api, list_apis, register_api, search_endpoints, get_workflow, get_endpoint_schema, set_api_auth). All use standard CRUD-style verbs (get, list, search, call, set, register, delete).
8 tools is well-scoped for an API management server covering the full lifecycle: registration, listing, deletion, authentication, discovery (search), inspection (schema), planning (workflow), and execution. Each tool earns its place without redundancy.
Covers the core API lifecycle well (register, list, delete, auth, search, call) with helpful additions like workflow planning. Minor gaps: no get_api for specific API details (only list_apis), no update_api for refreshing specs without full deletion, and no way to remove auth without deleting the entire API.
Maintenance
Related MCP Connectors
Turn any task into the right API calls: discover, evaluate, and integrate public APIs.
One MCP endpoint for Claude, GPT & Gemini: 100+ tools + no-code connectors + agent workers.
Your AI Agent's Infrastructure Layer. Connect Claude, Copilot, Codex, or ChatGPT to 200+ managed open source services. Start databases, pipelines, and applications through natural language.
Connect ChatGPT or Claude to your CRM, store or shipping API. Keys stay out of the chat.
Related MCP Servers
- FlicenseBqualityNot gradedmaintenanceBridges Claude Code to a Cloud Orchestrator API, providing access to multi-AI consensus, web search, code execution sandboxes, long-term memory, knowledge graphs, deployment management, and 20+ integrated AI and developer tools.28-
- AlicenseNot gradedqualityDmaintenanceA standalone proxy that transforms any OpenAPI or Swagger-described REST API into an MCP server by mapping API operations to executable MCP tools. It enables AI clients to interact with existing web services through automated HTTP requests based on their official documentation.16MIT
- FlicenseNot gradedqualityNot gradedmaintenanceUniversal AI API Orchestrator. 850 tools across 53 services under a single MCP interface. Connect Claude, GPT, or Gemini to Stripe, Slack, GitHub, LinkedIn, Cloudflare, Shopify, Twilio, and 46 more via natural language. $0.10/execution, no subscription. Patent Pending.274 npm5-
- AlicenseAqualityCmaintenanceTurn any OpenAPI spec into MCP tools for Claude — instantly. Point mcp-openapi at any OpenAPI 3.x spec and Claude can call every endpoint through natural language. No custom integration code. No manual tool definitions. One line of config.240 npm1MIT