Wordware Research

🚀 Wordware MCP Dictionary

A Model Context Protocol (MCP) server that integrates Wordware's powerful proxy capabilities with Claude and other MCP-compatible AI assistants.

🚀 Quick Start

The Wordware MCP Dictionary is a Model Context Protocol (MCP) server that combines Wordware's robust proxy features with AI assistants like Claude. It enables seamless interaction between these components through the Anthropic's MCP, allowing Claude to access specialized Wordware processes.

✨ Features

• 🔄 Dynamic Tool Loading - Automatically load tools from the Wordware API based on configuration.
• 🧠 Intelligent Mode Detection - Automatically detect and adapt to the input modes of different tools.
• 🔍 Advanced Parameter Handling - Process various input formats (JSON, nested structures, strings).
• ⚙️ Robust Error Handling - Comprehensive error logging and event loop management.
• 🔑 Simple Authentication - Easily connect your Wordware account via configuration.

📦 Installation

Prerequisites

• Python 3.8+
• Wordware API credentials
• Claude Desktop or other MCP-compatible clients

Steps

# Clone the repository
git clone https://github.com/yourusername/wordware-mcp.git
cd wordware-mcp

# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Set environment variables
cp .env.example .env
# Edit the .env file with your Wordware API credentials

📚 Documentation

Configuration

Create a tools_config.json file with the following structure:

{
  "tools": [
    {
      "id": "your-tool-id-1"
    },
    {
      "id": "your-tool-id-2"
    },
    {
      "id": "your-tool-id-3"
    }
  ]
}

You can specify any Wordware tool ID in the configuration file, and the server will dynamically load and register them as MCP tools. Tool metadata, including input modes and descriptions, will be fetched directly from the Wordware API.

To specify a custom configuration file path, use the CONFIG_PATH environment variable.

Running the Server

# Run with default settings
python server.py

# Run with debug logging
python server.py --debug

# Run with SSE transport on a specific port
python server.py --transport sse --host 127.0.0.1 --port 8000

# Or install in Claude Desktop
mcp install python server.py --name "Wordware Tools"

How It Works

The Wordware MCP server operates in the following steps:

1. Tool Configuration Loading - Read the list of tool IDs from the configuration file.
2. Dynamic Tool Registration - For each tool ID:
   • Fetch metadata from the Wordware API.
   • Detect input mode requirements.
   • Create the corresponding MCP tool function.
   • Register the tool with the MCP server.
3. Request Handling - When a tool is called:
   • Process various input parameter formats (JSON objects, strings, nested structures).
   • Adapt the parameter format according to the tool's requirements.
   • Send the correctly formatted request to the Wordware API.
4. Response Handling - Process the Wordware API response:
   • Parse the Server-Sent Events (SSE) stream.
   • Collect all output values.
   • Format the response to Claude in a user-friendly manner.

Advanced Features

Intelligent Parameter Handling

The server automatically processes different input parameter formats:

• Direct parameters: {"Full Name": "John Doe", "Company": "Tech Corp"}
• JSON-formatted strings: "{\"Full Name\": \"John Doe\", \"Company\": \"Tech Corp\"}"
• Nested structures: [ {"name": "John Doe"}, {"company": "Tech Corp"} ]

Tool Registration

Specify the tool IDs to be registered through the configuration file, and the server will automatically load and register these tools.

Runtime Example

# Example configuration file tools_config.json
{
  "tools": [
    {
      "id": "wordware_create_document"
    },
    {
      "id": "wordware_analyze_data"
    }
  ]
}

# Start the server
python server.py

# Now the tools are registered and available for Claude to use

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

• Anthropic for the Model Context Protocol
• Wordware for its proxy platform
• MCP Python SDK for the protocol implementation

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.