Switch agent frameworks

Choose from 8 agent frameworks at scaffold time — only agent.py changes between them.

Create Context Graph supports 8 agent frameworks. The framework choice only affects backend/app/agent.py in the generated project — everything else (FastAPI backend, Neo4j client, frontend, data, and schema) stays the same.

Choosing a framework

Interactive wizard

Run the CLI and select your framework at the relevant step:

uvx create-context-graph my-app

CLI flag

uvx create-context-graph my-app --domain healthcare --framework langgraph

The --framework flag accepts one of the eight keys listed below.

Supported frameworks

PydanticAI

Key: pydanticai

Type-safe agents with @agent.tool decorators and dependency injection via RunContext. PydanticAI validates tool inputs and outputs against Pydantic models. Full token-by-token text streaming via agent.run_stream().

uvx create-context-graph my-app \
  --domain healthcare \
  --framework pydanticai \
  --demo-data

Required API key: ANTHROPIC_API_KEY

Streaming: Full (token-by-token text + real-time tool calls)

Claude Agent SDK

Key: claude-agent-sdk

Anthropic’s own SDK with dict-based tool definitions and a bounded agentic loop (max 15 iterations). Full token-by-token text streaming via client.messages.stream().

uvx create-context-graph my-app \
  --domain financial-services \
  --framework claude-agent-sdk \
  --demo-data

Required API key: ANTHROPIC_API_KEY

Streaming: Full (token-by-token text + real-time tool calls)

OpenAI Agents SDK

Key: openai-agents

OpenAI’s agent framework with @function_tool decorators and Runner.run(). Full token-by-token text streaming via Runner.run_streamed().

uvx create-context-graph my-app \
  --domain software-engineering \
  --framework openai-agents \
  --demo-data

Required API key: OPENAI_API_KEY

openai-agents requires OPENAI_API_KEY. The CLI will warn you if this variable is not set when you select this framework.

Streaming: Full (token-by-token text + real-time tool calls)

LangGraph

Key: langgraph

LangChain’s graph-based agent runtime with @tool decorators and create_react_agent(). Full token-by-token text streaming via graph.astream_events().

uvx create-context-graph my-app \
  --domain real-estate \
  --framework langgraph \
  --demo-data

Required API key: ANTHROPIC_API_KEY

Streaming: Full (token-by-token text + real-time tool calls)

CrewAI

Key: crewai

Multi-agent framework with Agent, Task, and Crew abstractions using @tool decorators. Uses Anthropic as the LLM provider. CrewAI is synchronous and runs in a worker thread via asyncio.to_thread() with thread-safe async bridging.

uvx create-context-graph my-app \
  --domain manufacturing \
  --framework crewai \
  --demo-data

Required API key: ANTHROPIC_API_KEY

Streaming: Tools only (real-time tool call events; text response arrives all at once)

Strands

Key: strands

Agent framework using Anthropic models with @tool decorators. Strands is synchronous and runs in a worker thread via asyncio.to_thread() with thread-safe async bridging.

uvx create-context-graph my-app \
  --domain trip-planning \
  --framework strands \
  --demo-data

Required API key: ANTHROPIC_API_KEY

Streaming: Tools only (real-time tool call events; text response arrives all at once)

Google ADK

Key: google-adk

Google’s Agent Development Kit with FunctionTool and Gemini models. Full token-by-token text streaming via runner.run_async().

uvx create-context-graph my-app \
  --domain wildlife-management \
  --framework google-adk \
  --google-api-key $GOOGLE_API_KEY \
  --demo-data

Required API key: GOOGLE_API_KEY

google-adk requires GOOGLE_API_KEY. The CLI will warn you if this variable is not set when you select this framework.

Streaming: Full (token-by-token text + real-time tool calls)

Anthropic Tools

Key: anthropic-tools

Modular agent framework with a @register_tool registry and a bounded Anthropic API agentic loop (max 15 iterations). Full token-by-token text streaming via client.messages.stream().

uvx create-context-graph my-app \
  --domain gaming \
  --framework anthropic-tools \
  --demo-data

Required API key: ANTHROPIC_API_KEY

Streaming: Full (token-by-token text + real-time tool calls)

Framework comparison

Framework	Key	API key	Streaming
PydanticAI	pydanticai	ANTHROPIC_API_KEY	Full
Claude Agent SDK	claude-agent-sdk	ANTHROPIC_API_KEY	Full
OpenAI Agents SDK	openai-agents	OPENAI_API_KEY	Full
LangGraph	langgraph	ANTHROPIC_API_KEY	Full
CrewAI	crewai	ANTHROPIC_API_KEY	Tools only
Strands	strands	ANTHROPIC_API_KEY	Tools only
Google ADK	google-adk	GOOGLE_API_KEY	Full
Anthropic Tools	anthropic-tools	ANTHROPIC_API_KEY	Full

Full streaming means token-by-token text delivery plus real-time tool call visualization. Tools only means tool call events stream in real-time, but the text response arrives all at once after the agent finishes. All frameworks use the same SSE (Server-Sent Events) protocol.

What changes between frameworks

Only one file varies between frameworks: backend/app/agent.py. This file contains:

• Agent initialization and model configuration
• Tool definitions generated from your domain’s agent_tools ontology
• The handle_message() async function that the FastAPI routes call
• For full-streaming frameworks: the handle_message_stream() async function for SSE text streaming

Each framework template uses idiomatic patterns for that framework (decorators, classes, registries) but exposes the same interface to the rest of the application.

What stays the same

Regardless of which framework you choose, the generated project always includes:

• FastAPI backend (main.py, config.py, routes.py, models.py) — identical across all frameworks
• Neo4j clients (context_graph_client.py, gds_client.py, vector_client.py) — shared graph access layer
• Frontend (Next.js + Chakra UI v3 + NVL graph visualization) — framework-agnostic
• Data and schema (cypher/schema.cypher, fixture data, ontology YAML)
• Infrastructure (docker-compose.yml, Makefile, .env)

Generating a second project with a different framework

To compare frameworks side by side, re-run the CLI with a new output directory:

uvx create-context-graph my-app-langgraph --domain healthcare --framework langgraph
uvx create-context-graph my-app-crewai    --domain healthcare --framework crewai

The two projects share the same schema, data, and frontend. Only agent.py and the agent-specific dependencies in pyproject.toml differ.

Framework-specific dependencies

The generated backend/pyproject.toml includes only the dependencies needed for the chosen framework. Examples:

• pydanticai → pydantic-ai
• langgraph → langgraph, langchain-anthropic
• strands → strands-agents[anthropic]
• google-adk → google-adk, nest-asyncio

All frameworks share common dependencies: fastapi, uvicorn, neo4j, pydantic, and python-dotenv.

Conversation memory uses local sentence-transformers embeddings by default — no OPENAI_API_KEY required. If you set OPENAI_API_KEY in your .env, the generated project automatically upgrades to OpenAI text-embedding-3-small embeddings.