Skip to main content
Light mode mcp

Explore MCP Servers

Discover available MCP servers and tools to enhance your AI workflows.

​
Enhanced AI Capabilities

MCP allows AI models to:
  • Execute system commands and interact with the file system
  • Query databases and external APIs
  • Access external data sources like documentation and knowledge bases
  • Use specialized tools for code execution, testing, and deployment
  • Integrate with development tools like linters, formatters, and build systems

Tool Execution

Enable AI models to run tools and commands with user approval.

Data Access

Connect to external data sources and APIs for enhanced context.

System Integration

Integrate with development tools and workflow automation.

Multi-Modal

Combine multiple tools and data sources for complex tasks.

Secure Execution

Execute tools safely with approval workflows and error handling.

Dynamic Loading

Load and unload tools dynamically without restarting the application.

​
Connection Methods

CodinIT supports all major MCP server connection types:

STDIO Servers

Connect to local applications and tools via standard input/output streams.

SSE Servers

Connect to HTTP servers using Server-Sent Events for real-time communication.

Streamable HTTP

Connect to web servers with streaming HTTP support for optimal performance.

Multi-Server

Connect to multiple MCP servers simultaneously for diverse tool sets.

​
Configuration File Structure

{
  "mcpServers": {
    "filesystem": {
      "type": "stdio",
      "command": "node",
      "args": ["/path/to/filesystem-server.js"]
    },
    "database": {
      "type": "stdio",
      "command": "python",
      "args": ["database-tool.py"],
      "cwd": "/project/database"
    },
    "api-client": {
      "type": "sse",
      "url": "http://localhost:3001/events"
    },
    "web-service": {
      "type": "streamable-http",
      "url": "https://api.example.com/mcp"
    }
  }
}

​
Server Configuration Options

​
STDIO Server Integration

STDIO servers connect to local applications and tools through standard input/output streams, enabling AI models to interact with command-line tools and local services.

MCP STDIO Specification

Learn about the STDIO server protocol and implementation details.

​
Common STDIO Servers

Filesystem Tools

Browse files, read content, and perform file operations.

Git Integration

Execute Git commands and manage repository operations.

Terminal Commands

Run shell commands and scripts with proper error handling.

Code Execution

Execute code snippets and scripts in various languages.

Database Tools

Query databases and perform data operations.

API Clients

Make HTTP requests and interact with web services.

​
STDIO Server Example

// filesystem-server.js
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server(
  {
    name: 'filesystem-server',
    version: '1.0.0',
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Register file reading tool
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'read_file') {
    const content = await fs.readFile(args.path, 'utf8');
    return { content };
  }

  throw new Error(`Unknown tool: ${name}`);
});

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error('Filesystem MCP server running on STDIO');
}

main().catch(console.error);

​
Server-Sent Events (SSE)

SSE servers provide real-time, bidirectional communication over HTTP using the Server-Sent Events protocol.

Real-time Updates

Receive real-time updates and notifications from servers.

Persistent Connections

Maintain persistent connections for low-latency communication.

Auto-reconnection

Automatic reconnection handling for robust connectivity.

Event Streaming

Stream events and data continuously from server to client.

​
Streamable HTTP Servers

Streamable HTTP servers provide optimal performance for high-throughput scenarios with streaming response support.

High Performance

Optimized for high-throughput tool execution and data transfer.

Streaming Responses

Stream responses for better user experience with large datasets.

Connection Reuse

Reuse connections for improved efficiency and reduced latency.

Scalable Architecture

Scale horizontally with multiple server instances.

​
Dynamic Tool Loading

# Load servers from configuration
1. Define MCP servers in configuration file
2. Restart CodinIT or reload configuration
3. Tools become available for AI model use
4. Test tool execution with approval workflow

​
Tool Discovery

1

Server Connection

Connect to MCP server using specified transport method.
2

Capability Negotiation

Exchange capabilities and tool definitions with the server.
3

Tool Registration

Register available tools in the local tool registry.
4

Schema Validation

Validate tool parameters and response schemas.
5

Availability Testing

Test tool execution and handle any connection issues.

​
Safe Tool Execution

All MCP tool executions require explicit user approval to ensure safe and controlled AI model interactions.

Execution Preview

Preview tool execution details before approval.

Parameter Validation

Validate tool parameters and ensure type safety.

Error Handling

Comprehensive error handling and user feedback.

Execution Logging

Log all tool executions for audit and debugging.

​
Approval Interface

interface ToolApprovalRequest {
  serverName: string;
  toolName: string;
  description: string;
  parameters: Record<string, any>;
  riskLevel: 'low' | 'medium' | 'high';
}

const approvalRequest: ToolApprovalRequest = {
  serverName: 'filesystem',
  toolName: 'write_file',
  description: 'Write content to a file',
  parameters: {
    path: '/project/src/config.js',
    content: 'console.log("Hello World");'
  },
  riskLevel: 'medium'
};

​
Connection Management

Problem: Unable to connect to MCP server.Solutions:
  • Verify server is running and accessible
  • Check network connectivity and firewall settings
  • Validate server configuration and parameters
  • Review server logs for error details
Problem: Tool execution fails or returns errors.Solutions:
  • Check tool parameters and input validation
  • Verify tool permissions and access rights
  • Review server-side error logs and messages
  • Test tool manually if possible
Problem: Communication errors between client and server.Solutions:
  • Verify MCP protocol version compatibility
  • Check message format and encoding
  • Validate JSON-RPC message structure
  • Monitor network stability and timeouts
Problem: Server runs out of resources or becomes unresponsive.Solutions:
  • Monitor server resource usage
  • Implement proper resource cleanup
  • Configure appropriate timeouts and limits
  • Scale server resources if needed

​
Health Monitoring

# Monitor server status
1. Periodic connectivity tests
2. Tool availability verification
3. Resource usage monitoring
4. Automatic reconnection on failures
5. Health status reporting

​
Secure Server Configuration

Access Control

Implement proper authentication and authorization for MCP servers.

Input Validation

Validate all inputs and parameters before processing.

Sandboxing

Run servers in sandboxed environments when possible.

Audit Logging

Log all tool executions and server interactions.

​
Network Security

1

Use HTTPS

Always use HTTPS for HTTP-based MCP servers in production.
2

Authentication

Implement proper authentication mechanisms for server access.
3

Network Isolation

Run servers in isolated network environments when possible.
4

Firewall Configuration

Configure firewalls to restrict access to necessary ports only.
5

Certificate Validation

Validate SSL certificates for encrypted communications.

​
Efficient Tool Execution

Optimize tool execution for better performance and user experience.

Connection Pooling

Reuse connections for multiple tool executions.

Response Caching

Cache frequent tool responses to reduce execution time.

Async Processing

Process multiple tools concurrently when possible.

Resource Limits

Set appropriate resource limits for server processes.

​
Monitoring and Analytics

# Track key performance indicators
- Tool execution times
- Server response times
- Error rates and types
- Resource utilization
- User approval patterns

​
Filesystem Operations

# AI can now perform file operations
- Read project files and analyze code
- Create new files and directories
- Search and replace across multiple files
- Run file transformations and formatting

​
Database Integration

# AI can interact with databases
- Query data and analyze results
- Generate SQL migrations
- Perform data transformations
- Create database schemas and relationships

​
Development Tools

# AI can use development tools
- Run tests and linting
- Execute build processes
- Deploy applications
- Monitor system status

​
Server Development Best Practices

1

Implement Proper Error Handling

Provide clear error messages and handle edge cases gracefully.
2

Validate All Inputs

Validate parameters and inputs before processing to prevent issues.
3

Use Timeouts

Implement appropriate timeouts for long-running operations.
4

Log Activities

Log tool executions and errors for debugging and monitoring.
5

Handle Resource Cleanup

Properly clean up resources and connections when tools complete.

​
Production Deployment

Security First

Implement comprehensive security measures for production servers.

Monitoring Setup

Set up monitoring and alerting for server health and performance.

Scalability Planning

Plan for scaling as usage grows and tool complexity increases.

Backup Strategy

Implement backup and recovery strategies for critical server data.

​
Usage Guidelines

Start with simple tools and gradually add complexity as you become familiar with MCP integration.
1

Start Simple

Begin with basic tools like filesystem operations and terminal commands.
2

Test Thoroughly

Test all tools in development environment before production use.
3

Monitor Usage

Monitor tool usage patterns and performance metrics.
4

Expand Gradually

Add more complex tools as your workflows become more sophisticated.
5

Maintain Security

Regularly review and update security measures as you add new tools.

​
Common Issues

Problem: Cannot connect to MCP server.Solutions:
  • Verify server process is running
  • Check network connectivity and port availability
  • Validate server configuration and startup parameters
  • Review server logs for error messages
Problem: Tools not appearing in available tools list.Solutions:
  • Check server capability negotiation
  • Verify tool definitions are properly formatted
  • Review server logs for tool registration errors
  • Restart server and reload configuration
Problem: Tool execution fails with permission errors.Solutions:
  • Check file/directory permissions for STDIO servers
  • Verify user has appropriate system permissions
  • Review tool parameter validation and access control
  • Check server configuration for permission settings
Problem: Tool execution is slow or unresponsive.Solutions:
  • Monitor server resource usage and performance
  • Check for resource leaks or memory issues
  • Optimize tool implementation for better performance
  • Scale server resources if needed

​
Debug Tools

# Enable debug logging
DEBUG=mcp:* codinit

# Test server connectivity
curl http://localhost:3000/health

# Monitor server resources
top -p $(pgrep -f "mcp-server")

# Check server logs
tail -f /var/log/mcp-server.log
Ready to extend AI capabilities? Start with simple STDIO servers and gradually explore HTTP-based servers for more advanced integrations.