Jentic MCP Server

MCP server that lets agents discover, load, and execute thousands of public APIs and Arazzo workflows without writing per-API integration code.

Automation by Jentic Labs OAuth2 active

Connect (Remote Server) GitHub Docs

Overview

Jentic is an MCP server that gives AI agents access to a large catalog of external APIs and multi-step workflows without per-integration glue code. Instead of wiring up a custom tool for every SaaS endpoint, the agent calls a small set of generic tools that search the Jentic API directory, load operation schemas on demand, and execute calls through Jentic's broker. Credentials are stored in Jentic's vault and injected at runtime, so secrets never appear in prompts or model context.

The server is backed by the Open Agentic Knowledge (OAK) project and the jentic/jentic-public-apis repository, which curates OpenAPI specs and Arazzo workflow definitions for thousands of public APIs. Jentic publishes both a hosted Remote MCP endpoint at https://api.jentic.com/mcp (recommended, with OAuth and PKCE) and a local launcher you can run via uvx from the open-source jentic/jentic-sdks repo using an agent API key.

This design is notable for solving the "tool sprawl" problem in MCP: rather than exposing hundreds of individual tools that bloat the agent's context window, Jentic exposes a handful of meta tools (search, load, execute) and lets the agent retrieve specifications just-in-time. Operations and credentials are scoped per agent, and the project is licensed under Apache-2.0.

Tools

Tool	Description
`search_apis`	Search the Jentic directory for APIs and workflows that match a natural-language description of what the agent needs to do.
`load_execution_info`	Load the detailed schema, parameter requirements, and authentication details for a specific API operation or workflow returned by search.
`execute`	Execute the chosen API operation or Arazzo workflow with the supplied inputs, brokering the call and injecting stored credentials at runtime.
`list_credentials`	List the credentials the current agent is permitted to use, returned as text (secret values are never exposed).

Setup Guide

Prerequisites

A Jentic account, create one at app.jentic.com/sign-in
API credentials for any third-party services you want the agent to call, added to your Jentic registry
For local mode: uvx (from the uv Python package manager)

Option 1: Remote MCP server (recommended)

Point your MCP client at the hosted endpoint and authenticate with OAuth (PKCE) or an agent API key.

Server URL: https://api.jentic.com/mcp
OAuth is supported by Claude Desktop, ChatGPT, Cursor, and Windsurf
API key auth is supported by Cursor and Windsurf

Follow the per-client instructions at docs.jentic.com/guides/mcp/remote-mcp.

Option 2: Local MCP server via uvx

Add the following to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json) or Cursor config (~/cursor/.mcp.json):

{
  "mcpServers": {
    "jentic": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/jentic/jentic-sdks.git@main#subdirectory=mcp",
        "mcp"
      ],
      "env": {
        "JENTIC_AGENT_API_KEY": "<your-agent-api-key>"
      }
    }
  }
}

Environment variables

JENTIC_AGENT_API_KEY (required for local mode): agent API key from your Jentic account
JENTIC_API_URL (optional): override the Jentic API base URL for a self-hosted instance
Additional service credentials (e.g. DISCORD_BOTTOKEN) can be supplied in env if an API requires them and you are not using the Jentic vault

Restart the MCP client after editing its config.

Use Cases

Let an agent call any of thousands of public APIs (Slack, Discord, HubSpot, Stripe, GitHub, etc.) on demand without registering each one as a separate MCP tool
Execute multi-step Arazzo workflows from the OAK catalog, for example "create a Discord channel, post a message, then archive after 24h"
Discover the right API at runtime ("find an API that returns weather forecasts for a lat/lon") and immediately execute against it
Centralize API credentials in Jentic's vault so secrets never enter prompts, audit logs, or model context
Build internal automation agents where the toolset evolves without redeploying or reconfiguring the MCP client

Example Prompts

"Search Jentic for an API that can send a message to a Discord channel, then send 'deploy completed' to #releases."
"Find an API to look up a company by domain, load its execution info, then enrich every contact in this list."
"Use Jentic to fetch the latest issues from the openai/openai-python repo on GitHub."
"List which credentials my agent currently has access to."
"Find a workflow that creates a Stripe customer and subscribes them to a plan, then run it with these inputs."

Pros

Single MCP server gives access to a large catalog of APIs and Arazzo workflows, avoiding per-service MCP servers and tool-bloat in the agent's context
Credentials are stored in Jentic's vault and injected at execution time, so secret values never flow through the LLM
Official server maintained by Jentic Labs, open-source SDK on GitHub under Apache-2.0, with both hosted (Remote MCP) and self-runnable options
OAuth with PKCE supported across Claude Desktop, ChatGPT, Cursor, and Windsurf

Limitations

Requires a Jentic account and adds Jentic as a runtime dependency in the call path between the agent and target APIs
The "search then load then execute" pattern adds round trips compared to a purpose-built MCP server for a single service
API coverage and workflow availability depend on what is curated in the OAK / jentic-public-apis catalog

Alternatives

Pipedream MCP - similar "thousands of APIs through one MCP" pattern, backed by Pipedream's connector catalog
Composio MCP - managed tool catalog with auth handling for agents
Purpose-built single-service MCP servers (e.g. official Stripe, HubSpot, GitHub MCP servers) when you only need one integration and want minimal indirection