Add an example

Author: RussellLuo

README.md

@@ -566,6 +566,7 @@ reporter = AgentSpec(
 
 - [patterns](examples/patterns)
 - [a2a](examples/a2a)
+- [react-mcp](examples/react-mcp)
 - [mcp](examples/mcp)
 - [mcp-new](examples/mcp-new)
 - [structured-outputs](examples/structured-outputs)

examples/react-mcp/README.md

@@ -0,0 +1,45 @@
+# Model Context Protocol
+
+This example demonstrates how to use [MCP][1] tools in a ReAct agent.
+
+
+## Prerequisites
+
+- Install `coagent` (see [Installation](../../README.md#installation)).
+- Start a NATS server (see [Distributed](../../README.md#distributed)).
+
+
+## Quick Start
+
+Set the environment variables for your model:
+
+```bash
+export MODEL_ID="your-model-id"
+export MODEL_BASE_URL="your-base-url"
+export MODEL_API_KEY="your-api-key"
+```
+
+Run the MCP server:
+
+```bash
+python examples/react-mcp/server.py
+```
+
+Run the agent:
+
+```bash
+python examples/react-mcp/agent.py
+```
+
+```
+I'll check the weather in Beijing for you right away.
+[tool#call_hs9xiswsunbcynv946n43z46 call: get_weather]
+
+[tool#call_hs9xiswsunbcynv946n43z46 progress: Getting weather for Beijing]
+
+[tool#call_hs9xiswsunbcynv946n43z46 output: The weather in Beijing is sunny.]
+The weather in Beijing is sunny today! It looks like a beautiful day there.
+```
+
+
+[1]: https://modelcontextprotocol.io/

examples/react-mcp/agent.py

@@ -0,0 +1,75 @@
+import asyncio
+from coagent.agents.react_agent import (
+    ReActAgent,
+    InputMessage,
+    InputHistory,
+    OutputMessage,
+    MessageOutputItem,
+    ToolCallItem,
+    ToolCallOutputItem,
+    ToolCallProgressItem,
+)
+from coagent.core import AgentSpec, new, init_logger
+from coagent.runtimes import LocalRuntime
+import mcputil
+
+
+async def main():
+    async with LocalRuntime() as runtime:
+        # Alternative usage:
+        #   ```
+        #   mcp_client = mcputil.Client(mcputil.StreamableHTTP(url="http://localhost:8000"))
+        #   await mcp_client.connect()
+        #   ...
+        #   await mcp_client.close()
+        #   ```
+        async with mcputil.Client(
+            mcputil.StreamableHTTP(url="http://localhost:8000")
+        ) as mcp_client:
+            reporter = AgentSpec(
+                "reporter",
+                new(
+                    ReActAgent,
+                    name="reporter",
+                    system="You are a helpful weather reporter",
+                    tools=[mcp_client],
+                ),
+            )
+            await runtime.register(reporter)
+
+            result = await reporter.run(
+                InputHistory(
+                    messages=[
+                        InputMessage(
+                            role="user", content="What's the weather like in Beijing?"
+                        )
+                    ]
+                ).encode(),
+                stream=True,
+            )
+            async for chunk in result:
+                msg = OutputMessage.decode(chunk)
+                i = msg.item
+                match i:
+                    case MessageOutputItem():
+                        print(i.raw_item.content[0].text, end="", flush=True)
+                    case ToolCallItem():
+                        print(
+                            f"\n[tool#{i.raw_item.call_id} call: {i.raw_item.name}]",
+                            flush=True,
+                        )
+                    case ToolCallProgressItem():
+                        print(
+                            f"\n[tool#{i.raw_item.call_id} progress: {i.raw_item.message}]",
+                            flush=True,
+                        )
+                    case ToolCallOutputItem():
+                        print(
+                            f"\n[tool#{i.raw_item.call_id} output: {i.raw_item.output}]",
+                            flush=True,
+                        )
+
+
+if __name__ == "__main__":
+    init_logger()
+    asyncio.run(main())

examples/react-mcp/server.py

@@ -0,0 +1,22 @@
+from mcp.server.fastmcp import Context, FastMCP
+from mcp.server.session import ServerSession
+
+mcp = FastMCP(name="Progress Example")
+
+
+@mcp.tool()
+async def get_weather(
+    city: str,
+    ctx: Context[ServerSession, None],
+) -> str:
+    """Get the weather for a given city."""
+    await ctx.report_progress(
+        progress=0,
+        total=1.0,
+        message=f"Getting weather for {city}",
+    )
+    return f"The weather in {city} is sunny."
+
+
+if __name__ == "__main__":
+    mcp.run(transport="streamable-http")