DreamFactory MCP Server Setup

API Namespace:  my-ai-service    // becomes /mcp/my-ai-service
Label:          My AI Service
Description:    MCP server for AI access to enterprise data

// Protocol details (auto-configured)
Transport:      Streamable HTTP
Protocol:       JSON-RPC 2.0
Version:        2025-03-26

Client ID:      auto-generated-unique-id
Client Secret:  auto-generated-keep-secret
Endpoint:       /mcp/my-ai-service

{
  "apis": [
    {
      "name": "salesdb",
      "type": "database",
      "description": "Sales database (MySQL)"
    },
    {
      "name": "documents",
      "type": "file_storage",
      "description": "Document storage (S3)"
    }
  ]
}

{
  "table_configs": {
    "customers": {
      "allowed_columns": [
        "id",
        "first_name",
        "last_name",
        "email",
        "city",
        "state",
        "created_at"
      ],
      // Sensitive columns hidden from AI
      "blocked_columns": [
        "ssn",
        "credit_card_last4",
        "internal_notes"
      ]
    },
    "orders": {
      "allowed_columns": "*",
      "blocked_columns": ["payment_token"]
    }
  }
}

{
  "procedures": {
    "mcp_enabled": true,
    "allowed_procedures": [
      {
        "name": "create_order",
        "description": "Create a new order for a customer",
        "parameters": [
          {"name": "customer_id", "type": "integer", "required": true},
          {"name": "product_ids", "type": "array", "required": true},
          {"name": "notes", "type": "string", "required": false}
        ]
      },
      {
        "name": "update_order_status",
        "description": "Update the status of an existing order",
        "parameters": [
          {"name": "order_id", "type": "integer", "required": true},
          {"name": "new_status", "type": "string", "required": true}
        ]
      }
    ]
  }
}

MCP Endpoint:   https://your-instance.com/mcp/my-ai-service
Client ID:      (from MCP service settings)
Client Secret:  (from MCP service settings)

# Install MCP Inspector globally
npm install -g @modelcontextprotocol/inspector

# Or use npx to run without installing
npx @modelcontextprotocol/inspector

# Set your DreamFactory MCP endpoint
export DF_URL="https://your-dreamfactory-instance.com"
export MCP_SERVICE="my-ai-service"

# Launch inspector connected to DreamFactory MCP
npx @modelcontextprotocol/inspector \
  --url "${DF_URL}/mcp/${MCP_SERVICE}"

{
  "tools": [
    {
      "name": "salesdb_get_data_model",
      "description": "Get condensed schema overview including tables, columns, foreign keys, and row counts"
    },
    {
      "name": "salesdb_get_tables",
      "description": "Retrieve a list of all available tables in the sales database"
    },
    {
      "name": "salesdb_get_table_data",
      "description": "Query table data with filtering, pagination, and sorting",
      "inputSchema": {
        "type": "object",
        "properties": {
          "table_name": {"type": "string"},
          "filter": {"type": "string"},
          "limit": {"type": "integer", "default": 100}
        },
        "required": ["table_name"]
      }
    },
    {
      "name": "salesdb_aggregate_data",
      "description": "Compute SUM, COUNT, AVG, MIN, MAX aggregations"
    },
    {
      "name": "salesdb_call_stored_procedure",
      "description": "Execute a stored procedure with custom parameters"
    }
  ]
}

{
  "name": "salesdb_get_table_data",
  "arguments": {
    "table_name": "customers",
    "limit": 5,
    "fields": "id,first_name,last_name,email"
  }
}

pip install mcp anthropic python-dotenv

import os
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client
from dotenv import load_dotenv

load_dotenv()

class DreamFactoryMCPClient:
    """Client for interacting with DreamFactory via MCP protocol."""

    def __init__(self):
        self.url = os.getenv("DREAMFACTORY_URL")
        self.service = os.getenv("MCP_SERVICE_NAME", "my-ai-service")
        self.mcp_endpoint = f"{self.url}/mcp/{self.service}"
        self.session = None
        self.tools = []

    async def connect(self):
        """Establish MCP connection to DreamFactory."""

        # Create Streamable HTTP client connection
        # Auth is handled via OAuth 2.0 - no API key headers needed
        self.transport = streamablehttp_client(self.mcp_endpoint)
        read_stream, write_stream = await self.transport.__aenter__()

        # Initialize MCP session (protocol version 2025-03-26)
        self.session = ClientSession(read_stream, write_stream)
        await self.session.__aenter__()
        await self.session.initialize()

        # Discover available tools
        tools_response = await self.session.list_tools()
        self.tools = tools_response.tools

        print(f"Connected! Available tools: {len(self.tools)}")
        for tool in self.tools:
            print(f" - {tool.name}: {tool.description}")

        return self

    async def get_data_model(self, api_prefix: str):
        """Get condensed schema overview - recommended first call."""
        result = await self.session.call_tool(
            f"{api_prefix}_get_data_model",
            arguments={}
        )
        return result.content

    async def query_table(self, api_prefix: str, table: str, filter: str = None, limit: int = 100):
        """Query a database table through MCP."""
        arguments = {
            "table_name": table,
            "limit": limit
        }
        if filter:
            arguments["filter"] = filter

        result = await self.session.call_tool(
            f"{api_prefix}_get_table_data",
            arguments=arguments
        )
        return result.content

    async def call_procedure(self, api_prefix: str, procedure: str, params: dict):
        """Execute a stored procedure."""
        result = await self.session.call_tool(
            f"{api_prefix}_call_stored_procedure",
            arguments={
                "procedure_name": procedure,
                "params": params
            }
        )
        return result.content

    async def close(self):
        """Close the MCP connection."""
        if self.session:
            await self.session.__aexit__(None, None, None)
        if self.transport:
            await self.transport.__aexit__(None, None, None)


# Example usage
async def main():
    client = DreamFactoryMCPClient()
    await client.connect()

    # Get data model overview (recommended first step)
    model = await client.get_data_model("salesdb")
    print("Data model:", model)

    # Query customers
    customers = await client.query_table(
        "salesdb", "customers",
        filter="state='CA'",
        limit=10
    )
    print("California customers:", customers)

    # Call a stored procedure
    result = await client.call_procedure(
        "salesdb", "create_order",
        {"customer_id": 123, "product_ids": [1, 2, 3]}
    )
    print("Order created:", result)

    await client.close()

if __name__ == "__main__":
    asyncio.run(main())

import os
import asyncio
import json
from anthropic import Anthropic
from dreamfactory_mcp_client import DreamFactoryMCPClient

client = Anthropic()

async def process_user_query(user_message: str):
    """Process a natural language query using Claude and DreamFactory."""

    # Connect to DreamFactory MCP
    df_client = DreamFactoryMCPClient()
    await df_client.connect()

    # Get available tools and schema for Claude
    schema = await df_client.get_schema()

    # Convert MCP tools to Claude's tool format
    tools = []
    for tool in df_client.tools:
        tools.append({
            "name": tool.name,
            "description": tool.description,
            "input_schema": tool.inputSchema
        })

    # Initial message to Claude with context
    messages = [
        {
            "role": "user",
            "content": f"""You have access to a sales database with the following schema:
{json.dumps(schema, indent=2)}

User question: {user_message}

Use the available tools to answer the user's question."""
        }
    ]

    # Call Claude with tools
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        tools=tools,
        messages=messages
    )

    # Process tool calls
    while response.stop_reason == "tool_use":
        tool_results = []

        for content in response.content:
            if content.type == "tool_use":
                # Execute the tool via MCP
                result = await df_client.session.call_tool(
                    content.name,
                    arguments=content.input
                )

                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": content.id,
                    "content": json.dumps(result.content)
                })

        # Continue conversation with tool results
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})

        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

    await df_client.close()

    # Return Claude's final response
    return response.content[0].text


# Example
async def main():
    answer = await process_user_query(
        "What are our top 5 customers by order value this quarter?"
    )
    print(answer)

if __name__ == "__main__":
    asyncio.run(main())

# macOS
~/Library/Application Support/Claude/claude_desktop_config.json

# Windows
%APPDATA%\Claude\claude_desktop_config.json

# Linux
~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "dreamfactory": {
      "command": "npx",
      "args": [
        "-y",
        "@anthropic/mcp-proxy",
        "--url",
        "https://your-dreamfactory-instance.com/mcp/my-ai-service"
      ],
      "env": {}
    }
  }
}

{
  "mcpServers": {
    "dreamfactory": {
      "command": "npx",
      "args": [
        "-y",
        "@anthropic/mcp-proxy",
        "--url",
        "${DREAMFACTORY_URL}/mcp/${MCP_SERVICE}"
      ],
      "env": {
        "DREAMFACTORY_URL": "https://your-dreamfactory-instance.com",
        "MCP_SERVICE": "my-ai-service"
      }
    }
  }
}