10xgraph 0.10.0__tar.gz

10xgraph-0.10.0/10xgraph.egg-info/PKG-INFO

@@ -0,0 +1,511 @@
+Metadata-Version: 2.4
+Name: 10xgraph
+Version: 0.10.0
+Summary: 10xGraph (formerly Agentflow) is a Python framework for multi-agent AI systems that stay correct under failure: replay-safe tool calls that are not re-executed after a crash, versioned state writes, real node and tool timeouts, and two-tier Redis plus PostgreSQL checkpointing. MIT licensed, self-hosted, any model (OpenAI, Google Gemini, Anthropic). Pair it with 10xgraph-api to generate the production server around your graph.
+Author-email: Shudipto Trafder <shudiptotrafder@gmail.com>
+Maintainer-email: Shudipto Trafder <shudiptotrafder@gmail.com>, 10xScale <contact@10xscale.ai>
+License: MIT License
+        
+        Copyright (c) 2025 10xScale
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://10xgraph.com
+Project-URL: Repository, https://github.com/10xGraph/10xGraph
+Project-URL: Issues, https://github.com/10xGraph/10xGraph/issues
+Project-URL: Documentation, https://10xgraph.com
+Project-URL: Changelog, https://github.com/10xGraph/10xGraph/blob/main/CHANGELOG.md
+Keywords: agent,agents,ai-agents,multi-agent,multi-agent-systems,agentic-ai,agent-framework,agent-orchestration,workflow-engine,state-machine,stategraph,graph,llm,llm-framework,llm-orchestration,genai,generative-ai,production,self-hosted,fault-tolerance,idempotency,durable-state,checkpointing,human-in-the-loop,redis,postgresql,openai,anthropic,claude,gemini,google-genai,mcp,model-context-protocol,tool-use,function-calling,react-agent,rag,memory,vector-store,qdrant,mem0,a2a,realtime-audio,opentelemetry,kafka,10xgraph,agentflow
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: injectq<0.5,>=0.4.0
+Requires-Dist: pillow>=12.2.0
+Requires-Dist: pydantic<3,>=2.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: google-genai
+Requires-Dist: google-genai>=1.56.0; extra == "google-genai"
+Provides-Extra: realtime
+Requires-Dist: google-genai>=1.56.0; extra == "realtime"
+Provides-Extra: openai
+Requires-Dist: openai>=1.77.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic<2,>=1.0.0; extra == "anthropic"
+Provides-Extra: anthropic-vertex
+Requires-Dist: anthropic[vertex]<2,>=1.0.0; extra == "anthropic-vertex"
+Provides-Extra: anthropic-bedrock
+Requires-Dist: anthropic[bedrock]<2,>=1.0.0; extra == "anthropic-bedrock"
+Provides-Extra: pg-checkpoint
+Requires-Dist: asyncpg>=0.29.0; extra == "pg-checkpoint"
+Requires-Dist: redis>=4.2; extra == "pg-checkpoint"
+Provides-Extra: sqlite-checkpoint
+Requires-Dist: aiosqlite>=0.19.0; extra == "sqlite-checkpoint"
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=2.11.3; extra == "mcp"
+Requires-Dist: mcp>=1.13.0; extra == "mcp"
+Provides-Extra: images
+Requires-Dist: Pillow>=10.0.0; extra == "images"
+Provides-Extra: cloud-storage
+Requires-Dist: cloud-storage-manager>=0.1.2; extra == "cloud-storage"
+Provides-Extra: redis
+Requires-Dist: redis>=4.2; extra == "redis"
+Provides-Extra: kafka
+Requires-Dist: aiokafka>=0.8.0; extra == "kafka"
+Provides-Extra: rabbitmq
+Requires-Dist: aio-pika>=9.0.0; extra == "rabbitmq"
+Provides-Extra: qdrant
+Requires-Dist: qdrant-client>=1.7.0; extra == "qdrant"
+Provides-Extra: mem0
+Requires-Dist: mem0ai>=0.1.117; extra == "mem0"
+Provides-Extra: a2a-sdk
+Requires-Dist: a2a-sdk>=0.2.7; extra == "a2a-sdk"
+Provides-Extra: otel
+Requires-Dist: opentelemetry-api>=1.20.0; extra == "otel"
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == "otel"
+Provides-Extra: logfire
+Requires-Dist: logfire>=3.0.0; extra == "logfire"
+Provides-Extra: langsmith
+Requires-Dist: opentelemetry-api>=1.20.0; extra == "langsmith"
+Requires-Dist: opentelemetry-sdk>=1.20.0; extra == "langsmith"
+Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.20.0; extra == "langsmith"
+Provides-Extra: observability
+Requires-Dist: 10xgraph[langsmith,logfire,otel]; extra == "observability"
+Provides-Extra: all-publishers
+Requires-Dist: redis>=4.2; extra == "all-publishers"
+Requires-Dist: aiokafka>=0.8.0; extra == "all-publishers"
+Requires-Dist: aio-pika>=9.0.0; extra == "all-publishers"
+Provides-Extra: all
+Requires-Dist: 10xgraph[google-genai,mcp,openai,realtime]; extra == "all"
+Requires-Dist: 10xgraph[anthropic,anthropic-bedrock,anthropic-vertex]; extra == "all"
+Requires-Dist: 10xgraph[pg_checkpoint,sqlite_checkpoint]; extra == "all"
+Requires-Dist: 10xgraph[mem0,qdrant]; extra == "all"
+Requires-Dist: 10xgraph[all_publishers,observability]; extra == "all"
+Requires-Dist: 10xgraph[a2a_sdk,cloud-storage,images]; extra == "all"
+Dynamic: license-file
+
+# 10xGraph
+
+*Formerly Agentflow.* 10xGraph by 10xScale: graph engineering for production AI agents.
+
+[![CI](https://github.com/10xGraph/10xGraph/actions/workflows/ci.yml/badge.svg)](https://github.com/10xGraph/10xGraph/actions/workflows/ci.yml)
+[![Release](https://github.com/10xGraph/10xGraph/actions/workflows/release.yml/badge.svg)](https://github.com/10xGraph/10xGraph/actions/workflows/release.yml)
+[![PyPI](https://img.shields.io/pypi/v/10xgraph?color=blue)](https://pypi.org/project/10xgraph/)
+[![Python](https://img.shields.io/pypi/pyversions/10xgraph)](https://pypi.org/project/10xgraph/)
+[![License](https://img.shields.io/github/license/10xGraph/10xGraph)](https://github.com/10xGraph/10xGraph/blob/main/LICENSE)
+
+10xGraph is an open-source Python framework for building multi-agent AI systems and running them in production. You write the agent as a graph of nodes and tools. 10xGraph keeps tool calls from running twice after a crash, guards state writes, enforces timeouts, and, with the `10xgraph-api` package, generates the API server around the graph.
+
+This repository is the core engine (PyPI `10xgraph`, import `tenxgraph`). The docs live at [10xgraph.com](https://10xgraph.com).
+
+---
+
+## What it gives you
+
+**1. Correct under failure (this package)**
+
+- **Replay-safe tools.** The run loop persists the current node before running it, so a process killed mid-node re-runs that node on resume. Before calling a tool, 10xGraph checks the checkpointer's tool ledger and records each completed call as soon as it returns. A tool that already ran is not executed again: no double charge, no duplicate email. Requires a checkpointer.
+- **Versioned state writes.** Durable writes use optimistic compare-and-swap, so two runs on one thread cannot overwrite each other. The Redis cache write is version-guarded too.
+- **Real node and tool timeouts.** Set `node_timeout` and `tool_timeout` in the run config (defaults 900 s and 300 s), so a hung tool cannot hold a worker forever.
+- **Human approval inside a tool.** `interrupt()` pauses the run and saves the thread; resume with the decision.
+
+**2. The production server ships in the box (`10xgraph-api`, MIT)**
+
+`10xgraph-api` generates the production server around your compiled graph: REST, SSE streaming, WebSocket and realtime-audio endpoints; JWT or custom auth; scoped authorization on every endpoint; thread ownership isolation; rate limiting; and Docker Compose and Kubernetes files. You drive it with the `10xgraph` command (`10xgraph init`, `10xgraph api`, `10xgraph build`). See [the ecosystem table](#ecosystem).
+
+**3. Built to scale**
+
+- **Two-tier persistence.** `PgCheckpointer` caches active thread state in Redis and reads it first (default TTL 24 hours); PostgreSQL holds the durable history with versioned writes. Threads survive restarts and cache expiry. `SqliteCheckpointer` covers local work.
+- **Event publishing** to Kafka, Redis Pub/Sub, RabbitMQ and OpenTelemetry.
+- **Long-term memory** in Qdrant or Mem0.
+
+**4. One stack, backend to frontend**
+
+- **Remote tools.** The model can call tools that run in the user's browser or client. Declare them on the graph or pass them per run in `config["remote_tools"]`; the run pauses until the client returns the result.
+- **Typed TypeScript client** (`10xgraph-client`) for invoke, stream, threads, memory and files, plus a React playground (`10xgraph play`).
+
+**5. You own it**
+
+- MIT licensed and self-hosted. The server layer is part of the same open-source project, not a paid platform.
+- No LangChain dependency. Core requires InjectQ, Pydantic, Pillow, PyYAML and python-dotenv; everything else is an optional extra.
+- Any model: OpenAI and OpenAI-compatible endpoints, Google Gemini (including Vertex AI), Anthropic (direct, Vertex AI or Bedrock). Changing the model string does not change the graph or the tools.
+- Built and run in production by 10xScale for its own AI products.
+
+**Also included** (standard for agent frameworks, listed as facts): graph orchestration and the ReAct tool-calling loop, parallel tool execution, OpenAI, Google Gemini and Anthropic support, MCP tools, streaming, and checkpointing to a database.
+
+---
+
+## When it fits
+
+| You are | The problem | What 10xGraph does |
+|---|---|---|
+| A Python team taking an agent to production | Server, auth, persistence and deployment all have to be built around the agent | `10xgraph-api` generates them from the graph |
+| Running agents with side effects (payments, email, tickets) | A retry or crash repeats an action | Tool ledger: a completed tool call is replayed from the checkpointer, not re-run |
+| Building a multi-user product | Users must not see each other's threads | Thread ownership isolation and scoped authorization on every endpoint |
+| Required to self-host | Paid platforms, data residency, lock-in | MIT, self-hosted, any model |
+| A Python backend with a TypeScript frontend | Hand-written SSE and client glue | Typed client and remote tools |
+
+---
+
+## Install
+
+```bash
+pip install 10xgraph
+```
+
+Provider SDKs and infrastructure integrations are optional extras. Install only what you use:
+
+| Extra | Adds |
+|---|---|
+| `google-genai`, `openai`, `anthropic` | Provider SDK adapters |
+| `anthropic-vertex`, `anthropic-bedrock` | Claude on Vertex AI or Amazon Bedrock |
+| `realtime` | Audio-to-audio agents over Gemini Live |
+| `mcp` | Model Context Protocol client and tools |
+| `pg_checkpoint`, `sqlite_checkpoint` | Durable checkpointing (Postgres + Redis, or SQLite) |
+| `qdrant`, `mem0` | Long-term vector memory stores |
+| `redis`, `kafka`, `rabbitmq`, `otel` | Event publishers and tracing |
+| `images`, `cloud-storage` | Multimodal media handling and offload |
+| `all` | Every extra above at once, for development and CI |
+
+```bash
+pip install "10xgraph[google-genai,openai,anthropic,mcp,pg_checkpoint]"
+```
+
+Then set your provider key. A `.env` file in the working directory is loaded automatically.
+
+```bash
+export GEMINI_API_KEY=...        # Google Gemini
+export OPENAI_API_KEY=sk-...     # OpenAI, or any OpenAI-compatible endpoint
+export ANTHROPIC_API_KEY=sk-...  # Anthropic Claude
+```
+
+Requires Python 3.12 or newer.
+
+---
+
+## Quick start: a support agent with an approval step
+
+`lookup_order` reads data. `refund_order` moves money, so it pauses for a human decision with `interrupt()` before it acts. With a checkpointer, a crash or retry after the refund does not issue it twice.
+
+```python
+from tenxgraph.core.state import Message
+from tenxgraph.prebuilt.agent import ReactAgent
+from tenxgraph.storage.checkpointer import InMemoryCheckpointer
+from tenxgraph.utils import interrupt
+
+
+def lookup_order(order_id: str) -> dict:
+    """Look up an order by id."""
+    return {"order_id": order_id, "status": "delivered", "total": 42.00}
+
+
+def refund_order(order_id: str, amount: float) -> str:
+    """Refund an order. Requires approval."""
+    decision = interrupt({"amount": amount}, message=f"Refund ${amount}?")
+    if not decision.get("approved"):
+        return "Refund declined by reviewer."
+    return f"Refunded ${amount} for order {order_id}."
+
+
+app = ReactAgent(
+    model="gemini/gemini-2.5-flash",
+    system_prompt=[{"role": "system", "content": "You are a support agent for an online store."}],
+    tools=[lookup_order, refund_order],
+).compile(checkpointer=InMemoryCheckpointer())
+
+config = {"thread_id": "1"}
+result = app.invoke(
+    {"messages": [Message.text_message("Order A-1001 arrived broken, please refund it.")]},
+    config=config,
+)
+
+# The run pauses inside refund_order. After a reviewer approves:
+result = app.invoke({"resume": {"approved": True}}, config)
+```
+
+Swap `ReactAgent` for `RAGAgent`, `SwarmAgent`, `SupervisorTeamAgent` or `PlanActReflectAgent` and the shape stays the same. Use `PgCheckpointer` (Postgres plus Redis) in production, or `SqliteCheckpointer` for local work.
+
+**Stream it:**
+
+```python
+async for chunk in app.astream(
+    {"messages": [Message.text_message("Where is order A-1001?")]},
+    config={"thread_id": "2"},
+):
+    print(chunk.model_dump())
+```
+
+**Add MCP tools** by passing a `fastmcp` client; remote tools join your local ones:
+
+```python
+from fastmcp import Client
+
+mcp_client = Client({
+    "mcpServers": {
+        "orders": {"url": "http://127.0.0.1:8000/mcp", "transport": "streamable-http"},
+    }
+})
+
+app = ReactAgent(
+    model="gemini/gemini-2.5-flash",
+    tools=[lookup_order],
+    client=mcp_client,
+).compile()
+```
+
+---
+
+## Building your own graph
+
+Prebuilt agents are graphs. When you need custom control flow, build one directly:
+
+```python
+from tenxgraph.core.graph import Agent, StateGraph, ToolNode
+from tenxgraph.core.state import AgentState
+from tenxgraph.utils.constants import END
+
+graph = StateGraph()
+graph.add_node("MAIN", Agent(
+    model="gemini/gemini-2.5-flash",
+    system_prompt=[{"role": "system", "content": "You are a support agent."}],
+    tool_node="TOOL",
+))
+graph.add_node("TOOL", ToolNode([lookup_order, refund_order]))
+
+
+def route(state: AgentState) -> str:
+    if state.context and state.context[-1].tools_calls:
+        return "TOOL"
+    return END
+
+
+graph.add_conditional_edges("MAIN", route, {"TOOL": "TOOL", END: END})
+graph.add_edge("TOOL", "MAIN")
+graph.set_entry_point("MAIN")
+
+app = graph.compile()
+```
+
+Nodes can be plain functions too, so you can call a provider SDK directly. See [`examples/react/`](https://github.com/10xGraph/10xGraph/tree/main/examples/react).
+
+---
+
+## Realtime Audio Agents
+
+Live audio-to-audio sessions over Gemini Live. The provider owns the turn loop, so the session runs
+through `arealtime`: you push into an input queue and consume normalized events.
+
+```python
+from tenxgraph.prebuilt.agent import AudioAgent
+from tenxgraph.core.realtime import LiveInputQueue, RealtimeConfig
+
+app = AudioAgent(
+    "gemini-live-2.5-flash-preview",
+    realtime_config=RealtimeConfig(model="gemini-live-2.5-flash-preview", voice="Puck"),
+    tools=[lookup_order],
+).compile()
+
+queue = LiveInputQueue()
+queue.send_audio(pcm16_bytes)   # non-blocking, safe to call from an audio callback
+
+async for event in app.arealtime(queue, {"thread_id": "t1"}):
+    ...                         # AudioDeltaEvent / transcripts / ToolCallEvent / ...
+
+queue.close()
+```
+
+Barge-in, persisted transcripts (raw audio is never stored), automatic reconnect with session
+resumption, and image/video frame input are handled for you. `system_prompt`, `skills`, and `memory`
+work as they do on any other agent. Needs ``pip install "10xgraph[realtime]"``.
+
+---
+
+## Prebuilt agents and patterns
+
+- **Agents:** React, RAG, Guarded, Plan-Act-Reflect, Audio, Swarm, SupervisorTeam, StructuredOutput
+- **Orchestration:** Router, MapReduce, Sequential, Branch-Join
+- **Other:** dependency injection through InjectQ, skills (Agent Skills spec), 3-layer memory (working state, checkpointer, vector stores such as Qdrant and Mem0), publishers (Console, Redis, Kafka, RabbitMQ, OpenTelemetry), evaluation and testing helpers
+
+---
+
+## Moving from Agentflow
+
+10xGraph is the new name of Agentflow. The framework, license and maintainers are the same. `10xscale-agentflow` 0.10.1 is its last release.
+
+```bash
+pip uninstall 10xscale-agentflow
+pip install 10xgraph
+```
+
+Uninstall first: both distributions provide the `agentflow` module and must not be installed side by side.
+
+```python
+# before
+from agentflow.core.graph import StateGraph
+# after
+from tenxgraph import StateGraph
+```
+
+The import name is `tenxgraph` because a Python identifier cannot start with a digit. All canonical paths are the old ones with `agentflow` replaced by `tenxgraph` (for example `tenxgraph.core.graph`, `tenxgraph.storage.checkpointer`, `tenxgraph.prebuilt.agent`). `import agentflow` keeps working as a deprecated alias until 2.0, with one `DeprecationWarning`.
+
+Other renamed identifiers (old values still work where noted):
+
+| Item | Old | New |
+|---|---|---|
+| OpenTelemetry tracer and meter name, `GEN_AI_SYSTEM` | `agentflow` | `10xgraph` |
+| Logger names | `agentflow.*` | `tenxgraph.*` |
+| Media URI scheme | `agentflow://media/` | `graph://media/` (old URIs still read) |
+| Default home directory | `~/.agentflow` | `~/.10xgraph` (falls back to `~/.agentflow` if only that exists) |
+| Cloud media prefix | `agentflow-media` | `10xgraph-media` (old objects still read) |
+| Prebuilt tools user-agent | `agentflow-prebuilt-tools` | `10xgraph-prebuilt-tools/1.0` |
+| Server config file | `agentflow.json` | `10xgraph.json` (the CLI falls back to `agentflow.json`) |
+| CLI command | `agentflow` | `10xgraph` (`agentflow` stays as a deprecated alias until 2.0) |
+
+---
+
+## Ecosystem
+
+| Package | What it does | Install | Source |
+|---|---|---|---|
+| Core framework, `10xgraph` | Graph engine, state and checkpointing, memory, tools, MCP, publishers, evaluation | `pip install 10xgraph` | this repository |
+| API server, `10xgraph-api` (formerly `10xscale-agentflow-cli`) | Generates the production server around your graph: REST, SSE, WebSocket, JWT auth, scoped authorization, rate limiting, Docker and Kubernetes files | `pip install 10xgraph-api` | [10xGraph/10xgraph-api](https://github.com/10xGraph/10xgraph-api) |
+| TypeScript client, `10xgraph-client` (formerly `@10xscale/agentflow-client`) | Typed client for every endpoint, React streaming hooks, client-side tools | `npm install 10xgraph-client` | [10xGraph/10xgraph-client](https://github.com/10xGraph/10xgraph-client) |
+| Playground | React UI to chat with agents and inspect graphs, threads and state | `10xgraph play` | [10xHub/agentflow-playground](https://github.com/10xHub/agentflow-playground) |
+| Documentation | Tutorials, guides, concepts, reference | [10xgraph.com](https://10xgraph.com) | [10xGraph/10xgraph-docs](https://github.com/10xGraph/10xgraph-docs) |
+
+From install to a running service:
+
+```bash
+pip install 10xgraph-api         # pulls in 10xgraph
+10xgraph init --path my-agent && cd my-agent
+10xgraph api                     # REST and WebSocket API on :8000
+10xgraph play                    # server plus playground
+10xgraph build --docker-compose --k8s
+```
+
+A production scaffold with JWT auth and Redis rate limiting:
+
+```bash
+10xgraph init --path my-agent --yes --template production --auth jwt --rate-limit redis
+```
+
+---
+
+## Examples
+
+Runnable scripts in [`examples/`](https://github.com/10xGraph/10xGraph/tree/main/examples):
+
+| Topic | Directory |
+|---|---|
+| React agents, sync and class-based | [`react/`](https://github.com/10xGraph/10xGraph/tree/main/examples/react), [`react-injection/`](https://github.com/10xGraph/10xGraph/tree/main/examples/react-injection), [`agent-class/`](https://github.com/10xGraph/10xGraph/tree/main/examples/agent-class), [`tool-decorator/`](https://github.com/10xGraph/10xGraph/tree/main/examples/tool-decorator) |
+| Streaming and stop/resume | [`react_stream/`](https://github.com/10xGraph/10xGraph/tree/main/examples/react_stream) |
+| MCP servers and tools | [`react-mcp/`](https://github.com/10xGraph/10xGraph/tree/main/examples/react-mcp), [`github-mcp/`](https://github.com/10xGraph/10xGraph/tree/main/examples/github-mcp), [`xquik-mcp/`](https://github.com/10xGraph/10xGraph/tree/main/examples/xquik-mcp) |
+| RAG, memory, and vector stores | [`rag/`](https://github.com/10xGraph/10xGraph/tree/main/examples/rag), [`memory/`](https://github.com/10xGraph/10xGraph/tree/main/examples/memory), [`store/`](https://github.com/10xGraph/10xGraph/tree/main/examples/store) |
+| Multi-agent: swarm, supervisor, handoff, plan-act-reflect | [`swarm/`](https://github.com/10xGraph/10xGraph/tree/main/examples/swarm), [`supervisor_team/`](https://github.com/10xGraph/10xGraph/tree/main/examples/supervisor_team), [`handoff/`](https://github.com/10xGraph/10xGraph/tree/main/examples/handoff), [`multiagent/`](https://github.com/10xGraph/10xGraph/tree/main/examples/multiagent), [`plan_act_reflect/`](https://github.com/10xGraph/10xGraph/tree/main/examples/plan_act_reflect) |
+| Realtime audio, multimodal | [`realtime/`](https://github.com/10xGraph/10xGraph/tree/main/examples/realtime), [`multimodal/`](https://github.com/10xGraph/10xGraph/tree/main/examples/multimodal) |
+| Structured output, skills, custom state | [`structured_output/`](https://github.com/10xGraph/10xGraph/tree/main/examples/structured_output), [`skills/`](https://github.com/10xGraph/10xGraph/tree/main/examples/skills), [`custom-state/`](https://github.com/10xGraph/10xGraph/tree/main/examples/custom-state) |
+| Providers and A2A | [`providers/`](https://github.com/10xGraph/10xGraph/tree/main/examples/providers), [`a2a_sdk/`](https://github.com/10xGraph/10xGraph/tree/main/examples/a2a_sdk) |
+| Checkpointing, graceful shutdown | [`checkpointer/`](https://github.com/10xGraph/10xGraph/tree/main/examples/checkpointer), [`graceful_shutdown/`](https://github.com/10xGraph/10xGraph/tree/main/examples/graceful_shutdown) |
+| Evaluation and testing | [`evaluation/`](https://github.com/10xGraph/10xGraph/tree/main/examples/evaluation), [`testing/`](https://github.com/10xGraph/10xGraph/tree/main/examples/testing) |
+
+Run one:
+
+```bash
+export GEMINI_API_KEY=...   # or OPENAI_API_KEY
+python examples/react/react_single_class.py
+```
+
+Some examples still use pre-rename import paths; the canonical paths are listed in [CLAUDE.md](https://github.com/10xGraph/10xGraph/blob/main/CLAUDE.md).
+
+---
+
+## Limitations
+
+- Smaller community and fewer integrations than LangGraph or CrewAI.
+- Pre-1.0 (current release line 0.10.x): pin versions and read the changelog.
+- The rename from Agentflow resets brand recognition; "10xGraph" has no search history yet.
+- LangGraph has stronger visual tooling (Studio, LangSmith observability).
+- Requires Python 3.12 or newer. Code-first, not a no-code builder.
+- Automatic per-tool permissions (user A may call `refund`, user B may not) are not built in. Tools can check the caller's verified scopes with `tenxgraph.core.authz.has_scope`.
+
+---
+
+## Roadmap
+
+- Done: Core graph engine with nodes and edges
+- Done: State management and checkpointing
+- Done: Tool integration (MCP, custom tools, parallel execution)
+- Done: Streaming and event publishing
+- Done: Human-in-the-loop support
+- Done: Prebuilt agent patterns
+- Done: Agent-to-Agent (A2A) communication protocols
+- Done: Observability and tracing (OpenTelemetry)
+- Done: Realtime audio-to-audio agents (Gemini Live)
+- Planned: Remote node execution for distributed processing
+- Planned: More persistence backends (Redis, DynamoDB)
+- Planned: Parallel/branching strategies
+- Planned: Visual graph editor
+
+---
+
+## Contributing
+
+10xGraph is built in the open and contributions are welcome: bug reports with a clean reproduction, docs and examples, provider coverage, persistence backends, and typing (removing a module from the `mypy` ignore list is a welcome pull request).
+
+```bash
+git clone https://github.com/10xGraph/10xGraph.git
+cd 10xGraph
+uv sync --dev
+uv run pytest
+uv run ruff check .
+uv run mypy tenxgraph/
+```
+
+Read [CONTRIBUTING.md](https://github.com/10xGraph/10xGraph/blob/main/CONTRIBUTING.md) for the full workflow and the [Code of Conduct](https://github.com/10xGraph/10xGraph/blob/main/CODE_OF_CONDUCT.md). Questions and ideas go to [Discussions](https://github.com/10xGraph/10xGraph/discussions).
+
+---
+
+## Security
+
+Found a vulnerability? Do not open a public issue. Follow the process in [SECURITY.md](https://github.com/10xGraph/10xGraph/blob/main/SECURITY.md).
+
+---
+
+## License
+
+10xGraph is [MIT licensed](https://github.com/10xGraph/10xGraph/blob/main/LICENSE) and made by [10xScale](https://10xscale.ai). Copyright 10xScale. Contributions are accepted under the same license.
+
+---
+
+## Links
+
+- Documentation: [10xgraph.com](https://10xgraph.com)
+- PyPI: [`10xgraph`](https://pypi.org/project/10xgraph/)
+- [Issues](https://github.com/10xGraph/10xGraph/issues) and [Discussions](https://github.com/10xGraph/10xGraph/discussions)
+- [Changelog](https://github.com/10xGraph/10xGraph/blob/main/CHANGELOG.md)
+- [Examples](https://github.com/10xGraph/10xGraph/tree/main/examples)