MCP Tools

Copy

• Copy for LLM

  Copy page as Markdown for LLMs
• View as Markdown

  Open this page as Markdown
• Open in ChatGPT

  Get insights from ChatGPT
• Open in Claude

  Get insights from Claude

# Tools are discovered automatically based on assistant configuration
assistant = freddy.assistants.create(
    name="MCP-Enabled Assistant",
    instructions="You have access to MCP tools for enhanced capabilities.",
    model="gpt-4",
    tools=["mcp"]  # Enable MCP tool discovery
)

{
  "name": "tool_name",
  "description": "What this tool does",
  "input_schema": {
    "type": "object",
    "properties": {
      "param1": {"type": "string", "description": "Parameter description"}
    }
  },
  "implementation": "tool_implementation_function"
}

# Assistant automatically calls MCP tools when needed
result = await mcp_client.call_tool(
    tool_name="example_tool",
    parameters={"param1": "value"}
)

from mcp import Tool, MCPServer

# Define a custom tool
class CustomTool(Tool):
    def __init__(self):
        super().__init__(
            name="custom_calculator",
            description="Perform advanced mathematical calculations",
            input_schema={
                "type": "object",
                "properties": {
                    "operation": {
                        "type": "string",
                        "enum": ["add", "multiply", "power"],
                        "description": "Mathematical operation to perform"
                    },
                    "numbers": {
                        "type": "array",
                        "items": {"type": "number"},
                        "description": "Numbers for the calculation"
                    }
                },
                "required": ["operation", "numbers"]
            }
        )

    async def execute(self, operation: str, numbers: list) -> dict:
        """Execute the mathematical operation."""
        if operation == "add":
            result = sum(numbers)
        elif operation == "multiply":
            result = 1
            for num in numbers:
                result *= num
        elif operation == "power":
            result = numbers[0] ** numbers[1]
        else:
            raise ValueError(f"Unknown operation: {operation}")

        return {
            "operation": operation,
            "inputs": numbers,
            "result": result
        }

# Register the tool
server = MCPServer(tools=[CustomTool()])

# Publish tool to MCP registry
freddy.mcp_tools.publish(
    tool=CustomTool(),
    metadata={
        "author": "Your Name",
        "version": "1.0.0",
        "tags": ["mathematics", "calculator"],
        "documentation": "https://example.com/docs/custom-calculator"
    }
)

# Create assistant with MCP support
assistant = freddy.assistants.create(
    name="MCP Assistant",
    instructions="""You have access to MCP tools that extend your capabilities:

Available tools:
- Use web_search for current information
- Use code_executor for running code
- Use database_query for data analysis
- Use custom_calculator for complex math

Always choose the most appropriate tool for each task.""",
    model="gpt-4",
    tools=[{"type": "mcp"}]
)

# Assistant automatically selects and uses MCP tools
message = freddy.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="Calculate 2^10 + 15 * 3 using the custom calculator"
)

# Assistant will:
# 1. Recognize the need for mathematical calculation
# 2. Select the custom_calculator MCP tool
# 3. Call the tool with appropriate parameters
# 4. Present the result in natural language

# List available MCP tools
tools = freddy.mcp_tools.list()

for tool in tools:
    print(f"Name: {tool.name}")
    print(f"Description: {tool.description}")
    print(f"Category: {tool.category}")
    print(f"Version: {tool.version}")

# Configure tool settings
freddy.mcp_tools.configure(
    tool_name="web_search",
    settings={
        "default_engine": "google",
        "safe_search": True,
        "max_results": 10,
        "timeout": 30
    }
)

# Monitor tool usage and performance
usage = freddy.mcp_tools.get_usage(
    tool_name="custom_calculator",
    start_date="2024-01-01",
    end_date="2024-01-31"
)

print(f"Total executions: {usage.total_executions}")
print(f"Average execution time: {usage.avg_execution_time}ms")
print(f"Success rate: {usage.success_rate}%")

# Example: Research workflow using multiple tools
async def research_workflow(topic: str):
    """Perform comprehensive research using multiple MCP tools."""

    # Step 1: Search the web for current information
    web_results = await mcp_client.call_tool("web_search", {"query": topic})

    # Step 2: Search documents for related information
    doc_results = await mcp_client.call_tool("document_search", {"query": topic})

    # Step 3: Analyze data with code execution
    analysis = await mcp_client.call_tool("code_executor", {
        "code": "analyze_research_data(web_results, doc_results)"
    })

    return {
        "topic": topic,
        "findings": analysis["result"],
        "sources": {"web": web_results, "documents": doc_results}
    }

# Load specialized tools for specific tasks
def load_specialized_tools(task_type: str):
    """Load appropriate tools based on task requirements."""

    if task_type == "data_analysis":
        return ["pandas_analyzer", "statistics_tool", "visualization_tool"]
    elif task_type == "web_research":
        return ["web_search", "content_summarizer", "fact_checker"]
    elif task_type == "code_development":
        return ["code_executor", "linter", "test_runner"]

    return ["general_search"]  # Default tools

# Enable debug mode for detailed logging
freddy.mcp_tools.set_debug_mode(True)

# Test individual tools
test_result = freddy.mcp_tools.test("custom_calculator", {
    "operation": "add",
    "numbers": [1, 2, 3]
})

print(f"Test result: {test_result}")