Initial commit

Author: adhikasp

.cursorrule

@@ -0,0 +1,46 @@
+
+  You are an expert in Python, FastAPI, microservices architecture, and serverless environments.
+  
+  Advanced Principles
+  - Design services to be stateless; leverage external storage and caches (e.g., Redis) for state persistence.
+  - Implement API gateways and reverse proxies (e.g., NGINX, Traefik) for handling traffic to microservices.
+  - Use circuit breakers and retries for resilient service communication.
+  - Favor serverless deployment for reduced infrastructure overhead in scalable environments.
+  - Use asynchronous workers (e.g., Celery, RQ) for handling background tasks efficiently.
+  
+  Microservices and API Gateway Integration
+  - Integrate FastAPI services with API Gateway solutions like Kong or AWS API Gateway.
+  - Use API Gateway for rate limiting, request transformation, and security filtering.
+  - Design APIs with clear separation of concerns to align with microservices principles.
+  - Implement inter-service communication using message brokers (e.g., RabbitMQ, Kafka) for event-driven architectures.
+  
+  Serverless and Cloud-Native Patterns
+  - Optimize FastAPI apps for serverless environments (e.g., AWS Lambda, Azure Functions) by minimizing cold start times.
+  - Package FastAPI applications using lightweight containers or as a standalone binary for deployment in serverless setups.
+  - Use managed services (e.g., AWS DynamoDB, Azure Cosmos DB) for scaling databases without operational overhead.
+  - Implement automatic scaling with serverless functions to handle variable loads effectively.
+  
+  Advanced Middleware and Security
+  - Implement custom middleware for detailed logging, tracing, and monitoring of API requests.
+  - Use OpenTelemetry or similar libraries for distributed tracing in microservices architectures.
+  - Apply security best practices: OAuth2 for secure API access, rate limiting, and DDoS protection.
+  - Use security headers (e.g., CORS, CSP) and implement content validation using tools like OWASP Zap.
+  
+  Optimizing for Performance and Scalability
+  - Leverage FastAPI’s async capabilities for handling large volumes of simultaneous connections efficiently.
+  - Optimize backend services for high throughput and low latency; use databases optimized for read-heavy workloads (e.g., Elasticsearch).
+  - Use caching layers (e.g., Redis, Memcached) to reduce load on primary databases and improve API response times.
+  - Apply load balancing and service mesh technologies (e.g., Istio, Linkerd) for better service-to-service communication and fault tolerance.
+  
+  Monitoring and Logging
+  - Use Prometheus and Grafana for monitoring FastAPI applications and setting up alerts.
+  - Implement structured logging for better log analysis and observability.
+  - Integrate with centralized logging systems (e.g., ELK Stack, AWS CloudWatch) for aggregated logging and monitoring.
+  
+  Key Conventions
+  1. Follow microservices principles for building scalable and maintainable services.
+  2. Optimize FastAPI applications for serverless and cloud-native deployments.
+  3. Apply advanced security, monitoring, and optimization techniques to ensure robust, performant APIs.
+  
+  Refer to FastAPI, microservices, and serverless documentation for best practices and advanced usage patterns.
+  

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.env

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -0,0 +1,3 @@
+# Model Context Protocol exploration
+
+This repository contains a simple client for the Model Context Protocol (MCP) and a simple server for testing purposes.

brave_search_client.py

@@ -0,0 +1,57 @@
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+import asyncio
+import os
+import dotenv
+
+dotenv.load_dotenv()
+
+async def search_brave(query: str, count: int = 10):
+    # Configure server parameters for Brave Search
+    server_params = StdioServerParameters(
+        command="/usr/bin/npx",
+        args=["@modelcontextprotocol/server-brave-search"],
+        env={
+            "BRAVE_API_KEY": os.getenv("BRAVE_API_KEY")
+        }
+    )
+
+    print("Starting server...")
+    async with stdio_client(server_params) as (read, write):
+        print("Server started, initializing session...")
+        async with ClientSession(read, write) as session:
+            # Initialize the connection
+            await session.initialize()
+
+            # List available tools to verify Brave Search is available
+            tools = await session.list_tools()
+            print("Available tools:", [tool.name for tool in tools])
+
+            # Call the Brave Search tool
+            result = await session.call_tool(
+                "brave_web_search",
+                arguments={
+                    "query": query,
+                    "count": count
+                }
+            )
+
+            # Print the search results
+            if result and result.content:
+                for content in result.content:
+                    if content.type == "text":
+                        print(content.text)
+
+async def main():
+    # Check for Brave API key
+    if not os.getenv("BRAVE_API_KEY"):
+        print("Please set BRAVE_API_KEY environment variable")
+        return
+
+    # Perform a search
+    search_query = "Model Context Protocol"
+    print(f"\nSearching for: {search_query}")
+    await search_brave(search_query)
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "mcp-exploration"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "langchain-anthropic>=0.3.0",
+    "langchain>=0.3.8",
+    "mcp>=1.0.0",
+    "python-dotenv>=1.0.1",
+    "langgraph>=0.2.53",
+]

repro_github.py

@@ -0,0 +1,40 @@
+import os
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+import dotenv
+from mcp import types
+
+dotenv.load_dotenv()
+
+async def main():
+    # Create GitHub server parameters
+    server_params = StdioServerParameters(
+        command="npx",
+        args=["-y", "@modelcontextprotocol/server-github"],
+        env={
+            "GITHUB_PERSONAL_ACCESS_TOKEN": os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN"),
+            "PATH": os.getenv("PATH")
+        }
+    )
+
+    # Create client session and connect to GitHub server
+    async with stdio_client(server_params) as (read, write):
+        async with ClientSession(read, write) as session:
+            # Initialize the connection
+            await session.initialize()
+
+            # Example: Call tool to list repositories
+            repos = await session.send_request(
+                types.ClientRequest(
+                    types.CallToolRequest(
+                        method="tools/call",
+                        params=types.CallToolRequestParams(name="search_repositories", arguments={"query": "user:adhikasp"}),
+                    )
+                ),
+                types.TextContent,
+            )
+            print("Repositories:", repos)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

simple_client.py

@@ -0,0 +1,138 @@
+from mcp import ClientSession, StdioServerParameters, types
+from mcp.client.stdio import stdio_client
+import dotenv
+import os
+from pydantic import BaseModel, Field, create_model
+from langchain_core.tools import BaseTool
+from typing import Optional, Type, List
+import json
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.messages import HumanMessage
+from langchain_anthropic import ChatAnthropic
+
+dotenv.load_dotenv()
+
+def create_tool_model(tool_schema: types.Tool) -> Type[BaseModel]:
+    """Create a Pydantic model from MCP tool input schema"""
+    field_definitions = {}
+    for name, field_schema in tool_schema.inputSchema["properties"].items():
+        field_type = str  # Default to string type
+        if field_schema.get("type") == "string":
+            field_type = str
+        elif field_schema.get("type") == "integer":
+            field_type = int
+        elif field_schema.get("type") == "number":
+            field_type = float
+        elif field_schema.get("type") == "boolean":
+            field_type = bool
+            
+        field_description = field_schema.get("description", "")
+        field_definitions[name] = (field_type, Field(description=field_description))
+    
+    return create_model(
+        tool_schema.inputSchema.get("title", tool_schema.name),
+        **field_definitions
+    )
+
+def create_langchain_tool(tool_schema: types.Tool, session: ClientSession, server_params: StdioServerParameters) -> Type[BaseTool]:
+    """Create a LangChain tool class from MCP tool schema"""
+    input_model = create_tool_model(tool_schema)
+    
+    class McpConvertedLangchainTool(BaseTool):
+        name: str = tool_schema.name
+        description: str = tool_schema.description
+        args_schema: Type[BaseModel] = input_model
+        mcp_session: ClientSession = session
+        mcp_server_params: StdioServerParameters = server_params
+
+        def _run(
+            self,
+            run_manager: Optional[CallbackManagerForToolRun] = None,
+            **kwargs,
+        ) -> any:
+            raise NotImplementedError("Implement me!")
+
+        async def _arun(
+            self,
+            run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+            **kwargs,
+        ) -> any:
+            async with stdio_client(self.mcp_server_params) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    return await session.call_tool(self.name, arguments=kwargs)
+    
+    return McpConvertedLangchainTool()
+
+async def convert_mcp_to_langchain_tools(server_params: List[StdioServerParameters]) -> List[BaseTool]:
+    """Convert MCP tools to LangChain tools based on given server parameters"""
+    langchain_tools = []
+    for server_param in server_params:      
+        async with stdio_client(server_param) as (read, write):
+            async with ClientSession(read, write) as session:
+                await session.initialize()
+
+                # Convert all MCP tools to LangChain tools
+                tools: types.ListToolsResult = await session.list_tools()
+                for tool in tools.tools:
+                    tool_class = create_langchain_tool(tool, session, server_param)
+                    langchain_tools.append(tool_class)
+                
+    return langchain_tools
+
+async def run():
+    # Create server parameters for stdio connection
+    server_params = [
+        StdioServerParameters(
+            command="/home/adhikasp/.local/bin/uvx",
+            args=["mcp-server-fetch"],
+            env={
+                "PATH": os.getenv("PATH")
+            }
+        ),
+        StdioServerParameters(
+            command="/usr/bin/npx",
+            args=["-y", "@modelcontextprotocol/server-brave-search"],
+            env={
+                "BRAVE_API_KEY": os.getenv("BRAVE_API_KEY"),
+                "PATH": os.getenv("PATH")
+            }
+        ),
+        # StdioServerParameters(
+        #     command="/usr/bin/npx",
+        #     args=["-y", "@modelcontextprotocol/server-github"],
+        #     env={
+        #         "GITHUB_PERSONAL_ACCESS_TOKEN": os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN"),
+        #         "PATH": os.getenv("PATH")
+        #     }
+        # ),
+    ]
+
+    langchain_tools = await convert_mcp_to_langchain_tools(server_params)
+    
+    # model = ChatAnthropic(model="claude-3-haiku-20240307")
+    model = ChatAnthropic(model="claude-3-5-sonnet-latest")
+    memory = MemorySaver()
+    agent_executor = create_react_agent(model, langchain_tools, checkpointer=memory)
+
+    config = {"configurable": {"thread_id": "abc123"}}
+    messages = []
+    async for chunk in agent_executor.astream({"messages": [HumanMessage(
+        content="Search github repositories owned by adhikasp. What are his interest based on it?")]}, config):
+        messages.append(chunk)
+
+    for message in messages:
+        print(message)
+        # if 'agent' in message:
+        #     print(message['agent']['messages'][-1].content[0])
+        # if 'tools' in message:
+        #     print(message['tools']['messages'][-1].content)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(run())