Integrations

Each integration is one module under agent_adapter.integrations and, where it needs a framework, one extra (install with pip install "agent-adapter[<extra>]"). Framework imports are lazy, so an integration costs nothing until you call it. Each must pass a contract test that runs a real tool through that framework and the real Executor.

Integration	Module	Extra
OpenAI	openai	none (plain dicts)
Gemini	gemini	gemini
Anthropic	anthropic	none (plain dicts)
LangChain	langchain	langchain
OpenAPI	openapi	openapi
MCP	mcp	mcp
OpenAI Agents SDK	openai_agents	openai-agents
Pydantic AI	pydantic_ai	pydantic-ai
LlamaIndex	llamaindex	llamaindex
CrewAI	crewai	crewai (own environment)
Microsoft Agent Framework	agent_framework	agent-framework
Agno	agno	agno
Strands Agents	strands	strands (own environment)
Haystack	haystack	haystack
Claude Agent SDK	claude_agent	claude-agent
Semantic Kernel	semantic_kernel	semantic-kernel (own environment)
DSPy	dspy	dspy
smolagents	smolagents	smolagents
AutoGen 0.7	autogen	autogen
LangGraph	langgraph	langgraph
Google ADK 2.x	adk	adk (own environment)
CAMEL-AI	camel	camel (own environment)
AG2	ag2	ag2
A2A	a2a	a2a
AG-UI	ag_ui	ag-ui

Not on this list? Connect anywhere attaches 12 more stacks through MCP, REST or the TS client.

flowchart LR
  REG[("Registry")] --> OA["OpenAI"]
  REG --> GM["Gemini"]
  REG --> AN["Anthropic"]
  REG --> MAF["Agent Framework"]
  REG --> AGNO["Agno"]
  REG --> ST["Strands"]
  REG --> HS["Haystack"]
  REG --> CL["Claude Agent SDK"]
  REG --> SK["Semantic Kernel"]
  REG --> DSPY["DSPy"]
  REG --> SMOL["smolagents"]
  REG --> AGEN["AutoGen"]
  REG --> LG["LangGraph"]
  REG --> ADK["Google ADK"]
  REG --> LC["LangChain"]
  REG --> MCP["MCP server"]
  REG --> OAG["OpenAI Agents SDK"]
  REG --> PAI["Pydantic AI"]
  REG --> LI["LlamaIndex"]
  REG --> CR["CrewAI"]
  REG --> CAM["CAMEL-AI"]
  REG --> AG2["AG2"]
  REG --> A2A["A2A server"]
  REG --> AGUI["AG-UI bridge"]
  A2AC["A2A agent"] --> REG
  MCPC["MCP client"] --> REG
  LCT["LangChain tools"] --> REG
  OAPI["OpenAPI spec"] --> REG

Every integration is available; arrows into the registry are importers.

Matrix

Target	Exports	Also	Status
OpenAI (Chat / Responses)	tool dicts, strict schemas	—	Available
Gemini	function declarations, genai_tool(), AFC callables	run_function_calls	Available
Anthropic	input_schema tools	—	Available
Microsoft Agent Framework	FunctionTools	approval_mode="always_require", answered by resolve_approvals(response, port, registry)	Available
Agno	Functions	requires_confirmation, resolved by resolve_requirements(output, port, registry)	Available
Strands Agents	AgentTools	strands_approval_hook(port, registry)	Available
Haystack	Tools	confirmation_hook(port, registry)	Available
Claude Agent SDK	SDK MCP server	claude_sdk_bridge(registry, port): server + its own can_use_tool (edits via updated_input)	Available
Semantic Kernel	kernel functions, plugin	approval_filter(port, registry)	Available
DSPy	dspy.Tool per spec (acall; sync __call__ via run_sync)	—	Available
smolagents	Tool subclass per spec (sync forward via run_sync)	—	Available
AutoGen 0.7	BaseTool per spec (native call id, CancellationToken)	—	Available
LangGraph	tool_node (interrupt approvals, one at a time), tool_task + fan_out (Send), reducer(rule) channels	compile_flow(flow) -> StateGraph, run_compiled (parity with the local runner)	Available
Google ADK 2.x	BaseTool per spec; confirmations answered by resolve_confirmations(events, port, registry) (one-use tokens, edits)	compile_flow(flow) -> Workflow (superstep driver), run_workflow, resume_message	Available
LangChain	StructuredTools	importer: import_langchain	Available
MCP	lowlevel Server and stateless Streamable HTTP app over for_target("mcp"); annotations from effects; principal-scoped ids	import_mcp importer, mcp_client	Available
OpenAI Agents SDK	FunctionTools with needs_approval	resolve_interruptions (edits travel in one-use tokens)	Available
OpenAPI	—	importer: import_openapi(registry, spec, base_url=, auth=)	Available
Pydantic AI	Tool.from_schema, requires_approval	resolve_deferred (edits via override_args)	Available
LlamaIndex	FunctionTool with fn_schema (async + run_sync)	—	Available
CrewAI	BaseTools (_run via run_sync, _arun)	own environment	Available
CAMEL-AI	FunctionTools via camel_tools(registry)	the executor's port decides (no native gate, no call id); own environment	Available
AG2	FunctionTools via ag2_tools(registry, approval=port)	one-use token gate in tool middleware	Available
A2A	a2a_app, a2a_executor, agent_card	connect_a2a, import_a2a importer; approvals via input-required	Available
AG-UI	AGUIBridge event stream (SSE), agui_endpoint	approvals as interrupts; resumes ask your port	Available

Where your app runs (FastAPI, Flask, Celery, scripts) is covered on Sync code and backends and the backend guides: FastAPI, Flask, Django, Celery, Scripts, Serverless, Queues. Every backend, its attach call and its tests: Backends and runtimes.

Install several

pip install "agent-adapter[all]" installs every extra that co-installs from wheels without downgrading another one. pip check and every contract test run on that set in the contract-all-compatible nox session. Pinned ranges and test sessions: Support matrix.

In all	Own environment, and why
openai, gemini, anthropic, redis, otel, langchain, langgraph, mcp, openai-agents, pydantic-ai, llamaindex, openapi, agent-framework, agno, haystack, smolagents, claude-agent, autogen, server, server-wsgi, ag2, a2a, ag-ui, sqlalchemy, dynamodb	crewai: needs mcp<2 (the mcp extra needs >=2.3)
	strands: needs mcp<2.2
	semantic-kernel: pins pydantic<2.14
	adk: pins opentelemetry<=1.44, older than the otel extra resolves to
	camel: needs mcp<2 (the mcp extra needs >=2.3) and pins pydantic<=2.12.0 (google-genai in all needs >=2.12.5)
	dspy: pulls in LiteLLM (about 300 MB), which caps openai<3, below the openai extra; the adapter itself never uses it

Install an own-environment extra in a separate venv, for example pip install "agent-adapter[crewai]"; each has its own contract-<target> nox session.

Third-party integrations

The Integration protocol (export_tool, bind_context, bind_approval, optional compile_flow) plus the agent_adapter.integrations entry-point group: a new framework is supported without changing the adapter. get_integration(name) finds built-in and third-party integrations the same way. See Writing an integration.

Schema per family

Integrations reuse the three schema transforms:

Transform	Used by
OpenAI strict	OpenAI, OpenAI Agents SDK
Gemini	Gemini, ADK
Anthropic (plain)	Anthropic, MCP

Details on Schemas.