Server Bridge for Advanced Claude API Interaction via MCP Protocol

This repository details an intermediary server implementation designed to bridge the communication gap between the standard Claude Desktop application and the robust Claude Application Programming Interface (API). It serves to circumvent constraints inherent in the standard subscription tier (e.g., Professional Plan limits) by granting access to high-level features like granular system directives and comprehensive session control.

Core Capabilities

• Native integration with the Claude inference service through the Messaging Control Protocol (MCP).
• Robust tracking and state maintenance for ongoing dialogue sessions.
• Direct injection and utilization of custom initial directives (System Prompts).
• Fluid toggling between default subscription mode and external API invocation.
• Simplified initial configuration tethered to the local Claude client environment.

Operational Scenarios

• Standard Subscription Mode (Default Client Behavior):
• Routine conversational exchanges within the local desktop client.
• Operations confined by existing service level agreements.

• Zero supplementary setup required.

• External API Invocation (Via this Proxy Server):

• When processing demands necessitate significantly larger input contexts.
• For enforcing specific behavioral constraints via system prompts.
• For mitigating service-side usage throttling.
• When sophisticated historical context management is crucial.

Deployment Sequence

1. Source Code Retrieval ```bash # Utilizing VS Code for cloning: # 1. Open Command Palette (Cmd + Shift + P) # 2. Select "Git: Clone" # 3. Paste URI: https://github.com/mlobo2012/Claude_Desktop_API_USE_VIA_MCP.git

# Alternative via command line: git clone https://github.com/mlobo2012/Claude_Desktop_API_USE_VIA_MCP.git cd Claude_Desktop_API_USE_VIA_MCP ```

1. Dependency Resolution bash pip install -r requirements.txt

2. Environment Initialization ```bash # Duplicate the template file cp .env.example .env

# Modify .env to insert your secret key ANTHROPIC_API_KEY=your_secret_key_here ```

1. Client Configuration Adjustment
2. macOS Users: Navigate to the support directory: ~/Library/Application Support/Claude/ bash # Finder shortcut: # 1. Use Cmd + Shift + G # 2. Input path: ~/Library/Application Support/Claude/
3. Windows Users: Target location: %APPDATA%\Claude\
4. Generate or modify the configuration file named claude_desktop_config.json.
5. Ingest content from the repository's config/claude_desktop_config.json resource.
6. Update all relative pointers and API credential locations.

Operational Directives

Standard Client Interaction

1. Normal Client Use
2. Engage with Claude Desktop as usual.
3. Traffic routes through your active subscription tier.

4. No specialized invocation syntax is mandatory.

5. Forced API Invocation Initiate queries prefixed with the designated trigger command: @claude-api Execute query via the service endpoint: What is the capital city of France?

Leveraging Advanced Functions

1. Applying System Directives Embed a JSON payload specifying the desired persona or rules: @claude-api {"system_prompt": "You function as a certified endurance sports mentor"} Draft a comprehensive marathon preparation schedule

2. Session Thread Management ```bash # Commencement of a distinct dialogue thread @claude-api {"conversation_id": "endurance_phase_alpha"} Initiate discussion on cardiovascular training principles

# Continuation within the same thread context @claude-api {"conversation_id": "endurance_phase_alpha"} Elaborate further on Zone 2 cardio benefits

# Retrieval of prior exchanges @claude-api view_dialogue_log endurance_phase_alpha

# Termination and reset of a thread @claude-api purge_dialogue endurance_phase_alpha ```

Fiscal Responsibility Notes

• All requests routed via the API utilize your allocated Anthropic service credits, potentially incurring transactional costs.
• Reserve the standard client mode for routine operations.
• Employ the @claude-api prefix exclusively when benefiting from:
• Extended input context capacity.
• Custom rule enforcement via system messaging.
• Bypassing transient request volume restrictions.

Exposed MCP Utilities

1. invoke_claude_service
2. Executes raw calls against the Anthropic backend.
3. Full support for injecting custom initial instruction sets.

4. Integrated mechanism for maintaining sequence continuity.

5. terminate_dialogue_thread

6. Provides the functionality to reset specific conversation contexts.

7. Aids in organizing numerous parallel dialogue streams.

8. retrieve_dialogue_history

9. Fetches stored message sequences for review.
10. Useful for auditing or tracing complex interaction pathways.

Software Engineering Notes

The primary server logic resides in src/claude_api_server.py. New capabilities can be integrated seamlessly by leveraging the @mcp.tool() decorator.

Example of adding a new atomic utility:

@mcp.tool()
async def execute_utility_function(input_data: str) -> str:
    """
    Description for this novel utility function.

    Args:
        input_data: The required input parameter description.
    """
    try:
        # Implementation logic here
        return computed_output
    except Exception as operational_error:
        return f"Execution Failure: {str(operational_error)}"

Debugging Protocols

1. Credential Verification Failures
2. Confirm the API token integrity within the .env file.
3. Validate the accuracy of file paths specified in the client configuration.

4. Check that the service account possesses the necessary operational permissions.

5. Network Linkage Problems

6. Ensure the intermediary MCP dispatch server process is active.
7. Confirm the Python runtime environment is correctly bootstrapped.

8. Examine logs generated by the local Claude Desktop client.

9. Operational Syntax Errors

10. Verify strict adherence to the @claude-api command syntax.
11. Validate the structural integrity of provided conversation_id values.
12. Cross-reference the system prompt formatting against required specifications.

Collaboration Guidelines

1. Create a definitive fork of the official repository.
2. Establish a dedicated branch for feature development.
3. Commit and push your modifications.
4. Submit a formal Pull Request for review.

Licensing

This project operates under the terms of the MIT License.

Assistance Channels

For support or to report defects: 1. Initiate a new Issue within the repository tracker. 2. Review existing community discussions for prior resolutions. 3. Consult the integrated troubleshooting documentation.