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-4o",
 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-4o",
 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}")