MCP Examples

🚀 MCP Server Team Deployment Plan

This project explores the deployment configuration and custom implementation of the Model Context Protocol (MCP) server for team use. It aims to provide a comprehensive solution for teams to effectively utilize the MCP server in various scenarios.

📚 Understanding the MCP Architecture

Through research, we've gained insights into the following aspects of the MCP architecture:

1. MCP servers typically communicate using Unix sockets or standard input/output.
2. They are primarily designed for local use rather than HTTP/REST APIs.
3. Team-wide access requires additional integration work.
4. MCP servers can support multiple contexts/resources based on client requests.

📁 Project Structure

.
├── deployments/         # Kubernetes deployment configurations (experimental)
│   └── git/             # Git MCP server deployment
│       ├── Dockerfile
│       ├── k8s-deployment.yaml
│       ├── k8s-ingress.yaml
│       ├── deploy.sh
│       └── README.md
│
└── servers/             # Custom MCP server implementations
    ├── git/             # Custom implementation of Git MCP server (if needed)
    │   └── README.md
    └── README.md

💡 Recommended Approaches

👤 Individual Development (Simple)

1. Install Dependencies: Install the necessary libraries and tools according to the documentation.
2. Run the Server:

   mcp_server_git --port 8000
   

3. Use the Client:

   # Initialize a new repository
   git_init(repo_path="/path/to/repo")
   
   # Get the repository status
   git_status(repo_path="/path/to/repo")
   

👥 Team-wide Access

1. Configure the Server: Deploy the MCP server in a Kubernetes cluster.
2. Update Client Configuration:

   mcp_client --server_url http://mcp-server.example.com
   

3. Permission Management: Implement authentication and authorization mechanisms to ensure secure access for team members.

🔌 Integration with Cursor (Example)

Suppose we're developing a new tool named my_plugin that needs to interact with the MCP server:

Step 1: Install Dependencies

pip install mcp-client

Step 2: Configuration

Create mcp_config.json in the project root directory:

{
  "server_url": "http://mcp-server.example.com",
  "api_key": "your_api_key_here"
}

Step 3: Plugin Implementation

from mcp_client import MCPClient

client = MCPClient()
response = client.git_status(repo_path="/path/to/repo")
print(response.status)

🚧 Experimental Kubernetes Deployment

1. Deploy the Server:

   kubectl apply -f deployments/git/k8s-deployment.yaml
   

2. Expose the Service:

   kubectl expose deployment mcp-server --port 8000
   

3. Access the Service:

   kubectl get services
   # Get the EXTERNAL-IP, then open http://<external-ip>:8000 in the browser
   

🛠️ Features of the Git MCP Server

1. Initialize a Repository: Create a new repository using the git_init tool.
2. Get Status: Check the repository status via git_status.
3. Commit Changes: Commit files to the repository using git_commit.

Example:

# Initialize a new repository
git_init(repo_path="/path/to/new/repo")

# Get the repository status
git_status(repo_path="/path/to/new/repo")

➕ Adding a New MCP Server

1. Create a New Directory: Create a new folder under the servers/ directory, e.g., my_server/.
2. Implement the Interface: Inherit from the MCPServer class and implement the required methods.
3. Register the Server: Update the main README.md document to record the new server implementation.

🐞 Troubleshooting

Error: "/repos is not a valid Git repository"

Problem: ERROR:mcp_server_git.server:/repos is not a valid Git repository

Solution:

1. Create a repository using the git_init tool:

   git_init(repo_path="/path/to/repo")
   

2. Specify this path in subsequent operations:

   git_status(repo_path="/path/to/repo")
   

Communication Issues

• Check if the server is running: kubectl get pods or ps aux | grep mcp_server_git
• Ensure the client configuration correctly points to the target address
• Verify permissions for the repository directory

🚀 Next Steps

1. Explore custom MCP server implementations suitable for the team environment.
2. Investigate WebSocket or gRPC protocols for network communication.
3. Develop an authentication and authorization layer.
4. Create a client adapter that can interact with the network-accessible MCP server.

📚 References

• Model Context Protocol
• MCP Python SDK
• MCP Git Server