jido_mcp
MCP server integration package with pooled clients and Jido action surfaces
Install / Use
claude mcp add agentjido -- npx -y github:agentjido/jido_mcpIf the server publishes to npm under a different name, use that package instead — check the repo README.
MCP Server
Model Context Protocol server
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of jido_mcp
jido_mcp scores 81/100 on our quality scale, 3428th of 4,698 Development & Engineering skills we index.
Its MCP Server is 13 KB long, well organised into 24 sections with 15 code examples: a thorough specification that gives an agent plenty to work with.
It has 10 GitHub stars, so there is little community track record yet; judge it on its content.
Maintenance, license and trust
- The repository was last updated 3 days ago, so jido_mcp is actively maintained.
- Our last check on 2026-09-22 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 92/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-11-12. Automated pattern scan on 2026-11-12. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
jido_mcp compared with similar skills
All 4 of these similar skills score higher than jido_mcp; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| jido_mcp (this skill)by agentjido | 81 | 10 | 3d ago | MCP Server |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
Frequently asked questions
- How do I install jido_mcp?
- Run
claude mcp add agentjido -- npx -y github:agentjido/jido_mcp. The install tabs above show the steps for each supported agent. - Which AI agents does jido_mcp work with?
- It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
- Is jido_mcp safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 92/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is jido_mcp still maintained?
- The repository was last updated 3 days ago, so jido_mcp is actively maintained.
Skill content
View source on GitHubJido.MCP
jido_mcp integrates MCP servers into the Jido ecosystem. ExMCP provides the
client and server protocol runtime. The public Jido API keeps endpoint pooling,
response envelopes, actions, and explicit server allowlists stable.
Deprecated
jido_mcp is deprecated. Version 2.0.0 is the final release. The package will
not receive new features, compatibility fixes, security fixes, or new
versions. Published releases are retired on Hex with the deprecated reason.
They remain available for existing lockfiles.
Version 2.0 replaces Anubis with stable ExMCP and records the final Jido compatibility surface.
Use these packages for new work:
- Use ExMCP for MCP clients, servers, transports, resources, prompts, and protocol behavior.
- Use Jido Connect for managed MCP connections, connector discovery, and tool calls.
- Use Jido Harness for ACP and coding-agent lifecycles.
There is no support window and no promise of a replacement for every Jido API. See the final API inventory, the ExMCP migration guide, and the deprecation record.
Features
- Shared pooled MCP clients per configured endpoint
- Consume-side API for MCP tools/resources/prompts
- Jido actions + plugin routes for signal-driven usage
- Jido.AI runtime tool sync (MCP tools -> proxy
Jido.Actions) - MCP server bridge (
use Jido.MCP.Server) with explicit allowlists and a Jido-owned Plug host adapter
Legacy Installation
Do not add jido_mcp to a new application. This example is for existing
applications that must complete a migration.
def deps do
[
{:jido_mcp, "~> 2.0"}
]
end
Endpoint Configuration
config :jido_mcp, :endpoints,
github: %{
transport: {:streamable_http, [base_url: "http://localhost:8080", mcp_path: "/mcp"]},
client_info: %{name: "my_app", version: "1.0.0"},
protocol_version: "2025-06-18",
capabilities: %{},
timeouts: %{request_ms: 30_000}
},
local_fs: %{
transport: {:stdio, [command: "uvx", args: ["mcp-server-filesystem"]]},
client_info: %{name: "my_app", version: "1.0.0"}
}
Supported transports:
{:stdio, keyword()}for shell/command-based MCP servers{:shell, keyword()}as an alias normalized to:stdio{:streamable_http, keyword()}for MCP Streamable HTTP{:beam, keyword()}for a client and server in the same BEAM instance
For Streamable HTTP, :url or a :base_url containing a non-root path is
normalized to the existing :base_url + :mcp_path option shape before it is
mapped to ExMCP.
The deprecated {:sse, keyword()} client transport is not supported. Migrate
these endpoints to Streamable HTTP.
ExMCP client safety
config :jido_mcp, :endpoints,
remote: %{
transport:
{:streamable_http,
[
base_url: "https://mcp.example/mcp",
headers: [{"Authorization", "Bearer ..."}]
]},
client_info: %{name: "my_app", version: "1.0.0"}
}
ExMCP tool calls do not use the normal request retry policy. Stream recovery
uses http_stream_retry: :safe_only, and retry_safe is false by default.
Only set retry_safe: true when the tool has a tested idempotency contract.
Advanced ExMCP options can be supplied with :client_options. Transport,
credential, timeout, lifecycle, and retry controls remain protected and must
use the documented endpoint fields.
See the ExMCP migration guide for transport and server mapping, authorization, compatibility limits, and release gates.
Endpoint config may also be loaded through an MFA callback:
config :jido_mcp, :endpoints, {MyApp.MCPConfig, :endpoints, []}
The callback must return a map/keyword endpoint declaration or {:ok, endpoints}.
Runtime endpoints can be registered after application start:
{:ok, endpoint} =
Jido.MCP.Endpoint.new(:github, %{
transport: {:streamable_http, [base_url: "http://localhost:8080", mcp_path: "/mcp"]},
client_info: %{name: "my_app", version: "1.0.0"}
})
{:ok, ^endpoint} = Jido.MCP.register_endpoint(endpoint)
Runtime registration is process-local, rejects duplicate endpoint ids, and starts the MCP client only when the endpoint is first used. Atom and string ids with the same text are duplicates. String ids must be valid UTF-8 without ASCII control characters and cannot exceed 255 bytes.
Runtime Endpoint Lifecycle
{:ok, endpoint} =
Jido.MCP.Endpoint.new(:runtime_demo, %{
transport: {:streamable_http, [base_url: "http://localhost:8080/mcp"]},
client_info: %{name: "my_app"}
})
{:ok, ^endpoint} = Jido.MCP.register_endpoint(endpoint)
{:ok, tools} = Jido.MCP.list_tools(:runtime_demo)
{:ok, _removed} = Jido.MCP.unregister_endpoint(:runtime_demo)
For config changes at runtime, unregister then register the updated endpoint.
Consume MCP APIs
{:ok, tools} = Jido.MCP.list_tools(:github)
{:ok, called} = Jido.MCP.call_tool(:github, "search_issues", %{"query" => "label:bug"})
{:ok, resources} = Jido.MCP.list_resources(:github)
{:ok, content} = Jido.MCP.read_resource(:github, "repo://owner/name/README")
{:ok, prompts} = Jido.MCP.list_prompts(:github)
{:ok, prompt} = Jido.MCP.get_prompt(:github, "release_notes", %{"version" => "1.2.0"})
All calls return normalized envelopes:
- success:
%{status: :ok, endpoint: atom() | String.t(), method: String.t(), data: map(), raw: ...} - error:
%{status: :error, endpoint: atom() | String.t(), type: ..., message: String.t(), details: ...}
Jido Actions + Plugin
Actions
Jido.MCP.Actions.ListToolsJido.MCP.Actions.CallToolJido.MCP.Actions.ListResourcesJido.MCP.Actions.ListResourceTemplatesJido.MCP.Actions.ReadResourceJido.MCP.Actions.ListPromptsJido.MCP.Actions.GetPromptJido.MCP.Actions.RegisterEndpointJido.MCP.Actions.RefreshEndpointJido.MCP.Actions.UnregisterEndpointJido.MCP.Actions.SetDefaultEndpoint
Plugin
defmodule MyApp.Agent do
use Jido.Agent,
name: "assistant",
plugins: [
{Jido.MCP.Plugins.MCP,
%{
default_endpoint: :github,
allowed_endpoints: [:github, :local_fs]
# or allowed_endpoints: :all
}}
]
end
allowed_endpoints defaults to [] (deny-all) when omitted.
Set it to :all to allow all currently configured/runtime-registered endpoints.
Signal routes:
mcp.tools.listmcp.tools.callmcp.resources.listmcp.resources.templates.listmcp.resources.readmcp.prompts.listmcp.prompts.getmcp.endpoint.registermcp.endpoint.refreshmcp.endpoint.unregistermcp.endpoint.default.set
To update the plugin default endpoint at runtime, emit mcp.endpoint.default.set with
%{endpoint_id: "github"} (or nil/omitted to clear).
Jido.AI Sync
Jido.MCP.JidoAI.Actions.SyncToolsToAgent discovers remote tools and creates proxy Jido.Action modules, then registers them on a running Jido.AI.Agent.
Jido.MCP.JidoAI.Actions.UnsyncToolsFromAgent removes previously synced proxies.
Dynamic Jido AI proxy modules require a trusted atom endpoint id. String endpoint ids remain available for normal MCP calls and actions, but proxy sync rejects them because Elixir module names are atoms.
Tool sync uses deterministic MCP readiness: endpoint calls wait on ExMCP readiness before they execute.
Plugin route support:
mcp.ai.sync_toolsmcp.ai.unsync_tools
Host Runtime Orchestration (Signals)
Host projects are expected to orchestrate runtime endpoint lifecycle and tool sync explicitly using plugin signals.
Recommended signal sequences:
- Register endpoint then sync tools
mcp.endpoint.registermcp.ai.sync_tools
- Refresh endpoint then resync tools
mcp.endpoint.refreshmcp.ai.sync_tools(withreplace_existing: true)
- Unsync tools before unregistering endpoint
mcp.ai.unsync_toolsmcp.endpoint.unregister
Example signal payloads:
# mcp.endpoint.register
%{
endpoint_id: "runtime_demo",
endpoint: %{
transport: {:streamable_http, [base_url: "http://localhost:8080/mcp"]},
client_info: %{name: "my_app"}
}
}
# mcp.ai.sync_tools
%{
endpoint_id: "runtime_demo",
agent_server: :my_ai_agent,
replace_existing: true,
prefix: "mcp_"
}
# mcp.ai.unsync_tools
%{endpoint_id: "runtime_demo", agent_server: :my_ai_agent}
# mcp.endpoint.unregister
%{endpoint_id: "runtime_demo"}
Expose Jido As MCP Server
Server module
defmodule MyApp.MCPServer do
use Jido.MCP.Server,
name: "my-app",
version: "1.0.0",
publish: %{
tools: [MyApp.Actions.SearchIssues],
resources: [MyApp.MCP.Resources.ReleaseNotes],
prompts: [MyApp.MCP.Prompts.CodeReview]
}
end
Publication is explicit allowlist only.
Supervision
children =
Jido.MCP.Server.server_children(MyApp.MCPServer,
transport: :stdio
)
Use server_children/2 for stdio or local BEAM transports. A Plug host starts
per-request handlers and does not need this HTTP child.
Router (streamable HTTP)
forward "/mcp", Jido.MCP.Server.Plug,
Jido.MCP.Server.plug_init_opts(MyApp.MCPServer,
request_context: fn conn, _request ->
with {:ok, grant} <- MyApp.Grants.authorize(conn) do
{:ok,
%{
principal_id: grant.id,
tenant_id: grant.tenant_id,
assigns: %{grant_id: grant.id, grant_revision: grant.revision}
}}
end
end,
limits: [
allowed_hosts: ["mcp.example.com"],
allowed_origins: ["https://app.example.com"],
body_bytes: 1_000_000,
response_bytes: 1_000_000,
handler_deadline_ms: 10_000,
max_sessions_per_identity: 8,
idle_session_ttl_ms: 900_000
]
)
request_context runs before ExMCP resolves or creates a session for every
POST and DELETE. It must authenticate the current caller. It returns only
redacted assigns and stable principal and tenant strings. The adapter removes
assign keys that name bearer, authorization, credential, password, secret, or
token values. It never passes the Plug connection or request headers to a Jido
action. ExMCP binds a session to the principal and tenant values, and DELETE
terminates that session.
max_sessions_per_identity atomically limits sessions for one
principal-and-tenant pair. idle_session_ttl_ms closes a tracked session after
its idle period. You can set either limit independently. A failed initialize
releases its admission reservation; an abandoned reservation also has a bounded
lifetime. Lifecycle events include redacted :session_created,
:session_deleted, and :session_invalidated events. An invalidated event
contains a safe reason such as :revoked, :expired, or :revision_changed.
To reject a request and invalidate its current session, return this shape from
request_context:
{:error,
%{invalidate_session: %{principal_id: principal_id, tenant_id: tenant_id},
reason:
Truncated for display — read the full file on GitHub.
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
81.9k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
