Skip to main content

​
Integration Points Database

The Integration Points Database defines how MOOD MNKY agents connect with other systems in the ecosystem and external services. It outlines the technical interfaces, protocols, and data exchange formats used by agents to communicate with their environment.

​
Purpose and Role

The Integration Points Database defines “where” agents connect, enabling seamless integration across the ecosystem and with external tools.
This database documents:
  • API specifications for agent connections
  • MCP server integrations and configurations
  • Authentication and security requirements
  • Data exchange formats and protocols
  • Service dependencies
  • Integration testing and validation procedures

​
Schema and Structure

  • Database Schema
  • Example Entry
{
  "integration_id": "string",
  "name": "string",
  "description": "string",
  "integration_type": "string",
  "protocol": "string",
  "endpoint": "string",
  "auth_method": "string",
  "data_format": "string",
  "capabilities": "array",
  "agents": "array",
  "status": "string",
  "mcp_configuration": "object"
}

​
Field Descriptions

A unique identifier for the integration point.
The name of the integration in human-readable form.
A detailed description of what the integration does and how it’s used.
The category of integration (e.g., e-commerce, content management, analytics).
The communication protocol used for the integration.
The base URL or address for the integration.
The authentication method required for the integration.
The format used for data exchange.
An array of capabilities that utilize this integration.
An array of agents that utilize this integration.
Current status of the integration (active, beta, deprecated, etc.).
Configuration details for MCP server implementation.

​
MCP Server Types

The MOOD MNKY agent system uses two primary types of MCP servers for integrations:

Stdio MCP Servers

  • Uses standard input/output for communication
  • Ideal for local development
  • Lower latency for co-located processes
  • Simpler setup for development environments
  • Direct process communication

SSE MCP Servers

  • Uses HTTP with Server-Sent Events
  • Better for distributed systems
  • Supports remote service integration
  • More robust for production environments
  • Scalable for multiple agents

​
Implementation with OpenAI Agents SDK

​
Basic Integration Setup

from agents import Agent, Tool, Runner
import requests

# Define custom tool for integration
def shopify_product_search(query: str) -> dict:
    """Search for products in the Shopify store."""
    response = requests.get(
        "https://shop.moodmnky.com/api/products/search",
        params={"query": query},
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    return response.json()

# Create tool for the agent
shopify_tool = Tool(
    name="shopify_product_search",
    description="Search for products in the MOOD MNKY store",
    function=shopify_product_search
)

# Create agent with the tool
agent = Agent(
    name="MOOD MNKY",
    instructions="You are MOOD MNKY, the brand assistant. Help customers find products.",
    tools=[shopify_tool]
)

# Run the agent
runner = Runner()
result = await runner.run(agent, "I'm looking for candles with lavender")

​
MCP Server Integration

from agents import Agent, Runner
from agents.mcp.server import MCPServerSse, MCPServerSseParams

# Set up MCP server for Shopify integration
async with MCPServerSse(
    params=MCPServerSseParams(
        url="http://localhost:3000/mcp",
        headers={"Authorization": f"Bearer {API_KEY}"}
    ),
    name="shopify_mcp",
    cache_tools_list=True
) as shopify_server:
    
    # Create agent with MCP server
    agent = Agent(
        name="MOOD MNKY",
        instructions="You are MOOD MNKY, the brand assistant. Help customers find products.",
        mcp_servers=[shopify_server]
    )
    
    # Run the agent
    runner = Runner()
    result = await runner.run(agent, "I'm looking for candles with lavender")

​
Integration Categories

E-commerce

Connections to Shopify store and product systems

Content Management

Integrations with Notion, Mintlify, and content repositories

User Data

Connections to user profile systems and preference data

Analytics

Integrations with data analytics and reporting tools

Communication

Connections to messaging and notification systems

Community

Integrations with community platforms and forums

​
Best Practices for MCP Integrations

​
Design Principles

  • Modular Design: Create focused, single-purpose MCP servers
  • Consistent Interfaces: Standardize tool naming and parameter structures
  • Error Handling: Implement robust error handling and graceful degradation
  • Performance Optimization: Use tool caching for frequently accessed data
  • Security First: Apply principle of least privilege for all integrations

​
Implementation Guidelines

  • Server Selection: Choose Stdio servers for local development, SSE servers for production
  • Configuration Management: Use configuration files for MCP server parameters
  • Monitoring: Implement tracing and logging for all MCP server interactions
  • Testing Strategy: Develop mocks and test harnesses for MCP servers
  • Documentation: Maintain comprehensive documentation of all integration points

​
Deployment Considerations

  • Environment Isolation: Use environment-specific configurations
  • Scaling Strategy: Plan for horizontal scaling of MCP servers
  • Failover Mechanisms: Implement redundancy for critical integrations
  • Versioning: Manage API versions explicitly
  • Compliance: Ensure all integrations meet data protection requirements

​
Using YAML Configuration for MCP Servers

MCP servers can be configured using a YAML configuration file: 
mcp_servers:
  shopify:
    type: stdio
    command: node
    args:
      - ./mcp-servers/shopify-server.js
    cache_tools: true
    
  file_system:
    type: stdio
    command: npx
    args:
      - @mcp/fs-server
      - --allow-paths
      - ./data,./content
    cache_tools: false
Using configuration with OpenAI Agents SDK: 
from agents_mcp import Agent, Runner

# The Agent SDK will automatically find mcp_agent.config.yaml
agent = Agent(
    name="MOOD MNKY",
    instructions="You are MOOD MNKY, the brand assistant.",
    mcp_servers=["shopify", "file_system"]
)

runner = Runner()
result = await runner.run(agent, "Can you find my previous orders?")

​
Additional Resources