Merge pull request #24 from syncable-dev/feature/langgraph-stdio-sse

Feature/langgraph stdio sse

Author: LishuaiJing3

mcp-python-server-client/src/langgraph_sse_demo.py

@@ -0,0 +1,48 @@
+import asyncio
+import os
+from dotenv import load_dotenv
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langgraph.prebuilt import create_react_agent
+import openai
+
+# remember to start the sse server first
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+async def main():
+    # Connect to HTTP-based MCP server using SSE
+    client = MultiServerMCPClient({
+        "demo": {
+            "url": "http://127.0.0.1:8000/sse",
+            "transport": "streamable_http"
+        }
+    })
+
+    # Get available tools from server
+    tools = await client.get_tools()
+    print(f"Fetched {len(tools)} tools from MCP server.")
+    for tool in tools:
+        print(f"- {tool.name}")
+
+    # Create an agent using GPT-4o and those tools
+    agent = create_react_agent("openai:gpt-4o", tools)
+
+    # Prompts to trigger each tool
+    prompts = [
+        ("about_info", "Call the 'about_info' tool."),
+        ("analysis_scan", "Call the 'analysis_scan' tool on path '../' with display 'matrix'."),
+        ("security_scan", "Call the 'security_scan' tool on path '../'."),
+        ("dependency_scan", "Call the 'dependency_scan' tool on path '../'.")
+    ]
+
+    for tool_name, prompt in prompts:
+        print(f"\nInvoking agent to call '{tool_name}'...")
+        response = await agent.ainvoke({
+            "messages": [
+                {"role": "user", "content": prompt}
+            ]
+        })
+        print(f"Result for '{tool_name}':")
+        print(response)
+
+asyncio.run(main())

mcp-python-server-client/src/langgraph_stdio_demo.py

@@ -0,0 +1,47 @@
+# src/langgraph_stdio_demo.py
+
+import asyncio
+import os
+from dotenv import load_dotenv
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langgraph.prebuilt import create_react_agent
+import openai
+
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+async def main():
+    client = MultiServerMCPClient({
+        "syncable_cli": {
+            # Adjust this path if needed—just needs to point
+            # at your compiled mcp-stdio binary.
+            "command": "../rust-mcp-server-syncable-cli/target/release/mcp-stdio",
+            "args": [],              # no extra args
+            "transport": "stdio",    # stdio transport
+        }
+    })
+
+    tools = await client.get_tools()
+    print(f"Fetched {len(tools)} tools:")
+    for t in tools:
+        print(f" • {t.name}")
+
+    agent = create_react_agent("openai:gpt-4o", tools)
+
+    tests = [
+        ("about_info",    "Call the 'about_info' tool."),
+        ("analysis_scan", "Call 'analysis_scan' on path '../' with display 'matrix'."),
+        ("security_scan", "Call 'security_scan' on path '../'."),
+        ("dependency_scan","Call 'dependency_scan' on path '../'."),
+    ]
+
+    for name, prompt in tests:
+        print(f"\n--- {name} → {prompt}")
+        resp = await agent.ainvoke({
+            "messages": [{"role": "user", "content": prompt}]
+        })
+        print(resp)
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp-python-server-client/src/py_client_sse.py

@@ -0,0 +1,44 @@
+import asyncio
+import json
+from mcp.client.session import ClientSession
+from mcp.client.sse import sse_client
+from .utils import render_utility_result
+
+# to start the server, run:
+# cargo run --release --bin mcp-sse
+
+async def main():
+    # The URL where the Rust SSE server is listening.
+    server_url = "http://127.0.0.1:8000/sse"
+
+    async with sse_client(server_url) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            # List available tools
+            tools = await session.list_tools()
+            print("Tools:")
+            render_utility_result(tools)
+
+            # Call the 'about info' tool
+            about_info_result = await session.call_tool("about_info", {})
+            print("About info result:")
+            render_utility_result(about_info_result)
+
+            code_analyze_result = await session.call_tool("analysis_scan", {"path": "../", "display": "matrix"})
+            print("Code analysis result:")
+            render_utility_result(code_analyze_result)
+
+            # Call the 'security scan' tool
+            security_scan_result = await session.call_tool("security_scan", {"path": "../"})
+            print("Security scan result:")
+            render_utility_result(security_scan_result)
+
+            # Call the 'dependency scan' tool
+            dependency_scan_result = await session.call_tool("dependency_scan", {"path": "../"})
+            print("Dependency scan result:")
+            render_utility_result(dependency_scan_result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp-python-server-client/src/py_client_stdio.py

@@ -0,0 +1,42 @@
+import asyncio
+import json
+from mcp.client.session import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+from .utils import render_utility_result
+
+# to start the server, run:
+# from cpr-rust-server folder cargo run --release 
+
+async def main():
+    async with stdio_client(
+        StdioServerParameters(command="mcp-stdio")
+    ) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+
+            # List available tools
+            tools = await session.list_tools()
+            print("Tools:")
+            render_utility_result(tools)
+
+            # Call the 'about info' tool
+            about_info_result = await session.call_tool("about_info", {})
+            print("About info result:")
+            render_utility_result(about_info_result)
+
+            code_analyze_result = await session.call_tool("analysis_scan", {"path": "../", "display": "matrix"})
+            print("Code analysis result:")
+            render_utility_result(code_analyze_result)
+
+            # Call the 'security scan' tool
+            security_scan_result = await session.call_tool("security_scan", {"path": "../"})
+            print("Security scan result:")
+            render_utility_result(security_scan_result)
+
+            # Call the 'dependency scan' tool
+            dependency_scan_result = await session.call_tool("dependency_scan", {"path": "../"})
+            print("Dependency scan result:")
+            render_utility_result(dependency_scan_result)
+
+
+asyncio.run(main())

rust-mcp-server-syncable-cli/Cargo.toml

@@ -35,6 +35,9 @@ serde_json = "1.0"
 tokio = { version = "1", features = ["full"] }
 env_logger = "0.11"
 syncable-cli = "0.11.1"
+axum = { version = "0.8.4", features = ["json"] }
+futures = "0.3.31"
+bytes = "1.10.1"
 
 [[bin]]
 name = "mcp-stdio"

rust-mcp-server-syncable-cli/README.md

@@ -262,6 +262,116 @@ We are planning to add **first-class support for the [LangGraph](https://github.
 
 ---
 
+## Python LangGraph Agent Integration
+
+You can use the [LangGraph](https://github.com/langchain-ai/langgraph) framework to connect to this MCP server in both stdio and SSE modes. Below are example Python scripts for each mode.
+
+### Using Stdio Mode
+
+This example launches the `mcp-stdio` binary and connects via stdio:
+
+```python
+import asyncio
+import os
+from dotenv import load_dotenv
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langgraph.prebuilt import create_react_agent
+import openai
+
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+async def main():
+    client = MultiServerMCPClient({
+        "syncable_cli": {
+            "command": "mcp-stdio",  # Ensure mcp-stdio is in your PATH
+            "args": [],
+            "transport": "stdio",
+        }
+    })
+
+    tools = await client.get_tools()
+    print(f"Fetched {len(tools)} tools:")
+    for t in tools:
+        print(f" • {t.name}")
+
+    agent = create_react_agent("openai:gpt-4o", tools)
+
+    tests = [
+        ("about_info",    "Call the 'about_info' tool."),
+        ("analysis_scan", "Call 'analysis_scan' on path '../' with display 'matrix'."),
+        ("security_scan", "Call 'security_scan' on path '../'."),
+        ("dependency_scan","Call 'dependency_scan' on path '../'."),
+    ]
+
+    for name, prompt in tests:
+        print(f"\n--- {name} → {prompt}")
+        resp = await agent.ainvoke({
+            "messages": [{"role": "user", "content": prompt}]
+        })
+        print(resp)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### Using SSE Mode
+
+This example connects to a running `mcp-sse` server via HTTP/SSE:
+
+```python
+import asyncio
+import os
+from dotenv import load_dotenv
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langgraph.prebuilt import create_react_agent
+import openai
+
+load_dotenv()
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+async def main():
+    client = MultiServerMCPClient({
+        "demo": {
+            "url": "http://127.0.0.1:8000/sse",
+            "transport": "sse",
+        }
+    })
+
+    tools = await client.get_tools()
+    print(f"Fetched {len(tools)} tools from MCP server:")
+    for t in tools:
+        print(f" • {t.name}")
+
+    agent = create_react_agent("openai:gpt-4o", tools)
+
+    prompts = [
+        ("about_info",     "Call the 'about_info' tool."),
+        ("analysis_scan",  "Call the 'analysis_scan' tool on path '../' with display 'matrix'."),
+        ("security_scan",  "Call the 'security_scan' tool on path '../'."),
+        ("dependency_scan","Call the 'dependency_scan' tool on path '../'."),
+    ]
+
+    for name, prompt in prompts:
+        print(f"\n--- Invoking {name} ---")
+        resp = await agent.ainvoke({
+            "messages": [{"role": "user", "content": prompt}]
+        })
+        print(resp)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Requirements:**
+- Install the required Python packages:
+  ```bash
+  pip install langgraph openai python-dotenv langchain_mcp_adapters
+  ```
+- For stdio mode, ensure `mcp-stdio` is in your `PATH`.
+- For SSE mode, start the server with `mcp-sse` and connect to the correct URL.
+
+---
 
 ## License
 

rust-mcp-server-syncable-cli/src/schema/schema_utils.rs

@@ -0,0 +1,30 @@
+// src/schema/schema_utils.rs
+
+use std::fmt;
+
+/// An error returned when calling a tool fails.
+pub struct CallToolError(Box<dyn std::error::Error + Send + Sync + 'static>);
+
+impl CallToolError {
+    /// Wrap any `Error + Send + Sync + 'static` into a `CallToolError`.
+    pub fn new<E>(e: E) -> Self
+    where
+        E: std::error::Error + Send + Sync + 'static,
+    {
+        CallToolError(Box::new(e))
+    }
+}
+
+impl fmt::Debug for CallToolError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(&*self.0, f)
+    }
+}
+
+impl fmt::Display for CallToolError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&*self.0, f)
+    }
+}
+
+impl std::error::Error for CallToolError {}