Model Context Protocol (MCP)

python setup_mcp.py

git clone https://github.com/Papr-ai/papr_mcpserver
cd papr_mcpserver/python-mcp

uv venv
source .venv/bin/activate    # macOS/Linux
# or on Windows PowerShell
.venv\Scripts\Activate.ps1

uv pip install -e .[dev]

export PAPR_API_KEY=your_api_key_here        # macOS/Linux
setx PAPR_API_KEY your_api_key_here          # Windows (new shells)
$env:PAPR_API_KEY="your_api_key_here"       # Windows PowerShell (current shell)

uv run python paprmcp.py
# or for interactive development
fastmcp dev paprmcp.py

# Using uv directly
source .venv/bin/activate
uv run python paprmcp.py

# For debugging run and use mcp inspector as client
source .venv/bin/activate
fastmcp dev paprmcp.py

# Using uv directly
.venv\Scripts\activate
uv run python paprmcp.py

# For debugging run and use mcp inspector as client
.venv\Scripts\activate
fastmcp dev paprmcp.py

# Using uv directly
.venv\Scripts\Activate.ps1
uv run python paprmcp.py

# For debugging run and use mcp inspector as client
.venv\Scripts\Activate.ps1
fastmcp dev paprmcp.py

uv pip install ".[dev]"  # Development dependencies
uv pip install ".[test]"  # Testing dependencies
uv pip install ".[all]"  # All dependencies

uv pip install ".[dev]" 

# On Windows (using winget)
winget install OpenJS.NodeJS
# After installation, refresh PATH in PowerShell:
$env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")

# Also ensure uv is properly installed and in PATH:
$env:PATH = "C:\Users\$env:USERNAME\.local\bin;$env:PATH"

# On macOS (using Homebrew)
brew install node

# On Linux (using package manager)
# Ubuntu/Debian:
sudo apt update && sudo apt install nodejs npm
# Or using NodeSource repository for latest version:
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

source .venv/bin/activate
python -m debugpy --wait-for-client --listen 5678 .venv/bin/fastmcp dev paprmcp.py

.venv\Scripts\activate
python -m debugpy --wait-for-client --listen 5678 .venv\Scripts\fastmcp.exe dev paprmcp.py

.venv\Scripts\Activate.ps1
python -m debugpy --wait-for-client --listen 5678 .venv\Scripts\fastmcp.exe dev paprmcp.py

pip install langchain langchain_openai

import os
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

# Set up the MCP client for Papr Memory
class PaprMCPClient:
    def __init__(self, server_url="http://localhost:8000"):
        self.server_url = server_url
    
    async def get_memory(self, query: str, max_memory_items=20):
        import aiohttp
        
        url = f"{self.server_url}/mcp_Papr_MCP_Server_get_memory"
        payload = {
            "query": query,
            "max_memory_items": max_memory_items
        }
        
        async with aiohttp.ClientSession() as session:
            async with session.post(url, json=payload) as response:
                return await response.json()
    
    async def add_memory(self, content: str, memory_type="text", metadata=None):
        import aiohttp
        
        url = f"{self.server_url}/mcp_Papr_MCP_Server_add_memory"
        payload = {
            "content": content,
            "type": memory_type
        }
        if metadata:
            payload["metadata"] = metadata
        
        async with aiohttp.ClientSession() as session:
            async with session.post(url, json=payload) as response:
                return await response.json()

# Initialize the client
papr_client = PaprMCPClient()

@tool
async def search_memories(query: str):
    """Search for memories in Papr using MCP server."""
    return await papr_client.get_memory(query=query)

@tool
async def add_memory(content: str, metadata=None):
    """Add a new memory to Papr using MCP server."""
    return await papr_client.add_memory(content=content, metadata=metadata)

# Set up the LangChain agent
tools = [search_memories, add_memory]
llm = ChatOpenAI(model="gpt-4o", temperature=0).bind_tools(tools)

from langchain_core.messages import AIMessage, HumanMessage
from langgraph.graph import StateGraph, MessagesState
from langgraph.prebuilt import ToolNode

# Set up the graph nodes
workflow = StateGraph(MessagesState)
workflow.add_node("llm", llm)
workflow.add_node("tools", ToolNode(tools))

# Add the edges (basic agent workflow)
workflow.add_edge("llm", "tools")
workflow.add_edge("tools", "llm")
workflow.add_conditional_edges(
    "llm",
    lambda state: "END" if should_end(state) else "tools"
)

# Compile the graph
agent = workflow.compile()

# Run the agent with memory context
async def run_with_memory(query):
    # First search for relevant memories
    memories = await search_memories(query)
    
    # Build initial messages with memory context
    messages = [
        HumanMessage(content=f"Context from memory: {memories}\n\nUser query: {query}")
    ]
    
    # Execute the agent
    result = await agent.ainvoke({"messages": messages})
    
    # Store the conversation in memory
    await add_memory(
        content=f"Query: {query}\nResponse: {result['messages'][-1].content}",
        metadata={"conversation_type": "agent_interaction"}
    )
    
    return result['messages'][-1].content