API Reference

npx -y mcp-remote@latest http://tetrix-level-1-dev-alb-463220232.us-east-1.elb.amazonaws.com/mcp --transport http-only --allow-http

{
  "uri": "tetrix://code/analysis",
  "name": "Code Analysis",
  "description": "Comprehensive codebase analysis and insights",
  "mimeType": "application/json"
}

{
  "uri": "tetrix://infrastructure/aws",
  "name": "AWS Infrastructure",
  "description": "AWS resource analysis and optimization",
  "mimeType": "application/json"
}

{
  "uri": "tetrix://system/health",
  "name": "System Health",
  "description": "Overall system health and status",
  "mimeType": "application/json"
}

{
  "path": "string (optional)",
  "language": "string (optional)",
  "depth": "number (optional, default: 3)"
}

{
  "name": "analyze_codebase",
  "arguments": {
    "path": "/src/components",
    "language": "typescript",
    "depth": 2
  }
}

{
  "component": "string (required)",
  "type": "string (optional: 'imports' | 'exports' | 'both')"
}

{
  "scope": "string (optional: 'file' | 'directory' | 'project')",
  "pattern_type": "string (optional)"
}

{
  "service": "string (optional)",
  "region": "string (optional)",
  "cost_analysis": "boolean (optional, default: true)"
}

{
  "scope": "string (required: 'code' | 'infrastructure' | 'both')",
  "severity": "string (optional: 'low' | 'medium' | 'high' | 'critical')"
}

{
  "domain": "string (required)",
  "query": "string (required)",
  "context": "object (optional)"
}

{
  "jsonrpc": "2.0",
  "id": "unique-request-id",
  "method": "tools/call",
  "params": {
    "name": "tool_name",
    "arguments": {
      "parameter": "value"
    }
  }
}

{
  "jsonrpc": "2.0",
  "id": "unique-request-id",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Response content"
      }
    ],
    "isError": false
  }
}

{
  "jsonrpc": "2.0",
  "id": "unique-request-id",
  "error": {
    "code": -32000,
    "message": "Error description",
    "data": {
      "details": "Additional error information"
    }
  }
}

{
  "capabilities": {
    "resources": {
      "subscribe": true,
      "listChanged": true
    },
    "tools": {
      "listChanged": true
    },
    "prompts": {
      "listChanged": false
    },
    "logging": {
      "level": "info"
    }
  },
  "serverInfo": {
    "name": "tetrix-ai-mcp-server",
    "version": "1.0.0",
    "description": "Tetrix AI MCP Server for system-wide intelligence"
  }
}

import { MCPClient } from '@modelcontextprotocol/client';
 
const client = new MCPClient({
  transport: 'http',
  url: 'http://tetrix-level-1-dev-alb-463220232.us-east-1.elb.amazonaws.com/mcp'
});
 
// Connect to server
await client.connect();
 
// List available tools
const tools = await client.request('tools/list');
 
// Call a tool
const result = await client.request('tools/call', {
  name: 'analyze_codebase',
  arguments: { path: '/src' }
});

from mcp_client import MCPClient
 
client = MCPClient(
    transport='http',
    url='http://tetrix-level-1-dev-alb-463220232.us-east-1.elb.amazonaws.com/mcp'
)
 
# Connect to server
await client.connect()
 
# List available tools
tools = await client.request('tools/list')
 
# Call a tool
result = await client.request('tools/call', {
    'name': 'analyze_codebase',
    'arguments': {'path': '/src'}
})

// Complete example of integrating Tetrix AI MCP Server
import { MCPClient } from '@modelcontextprotocol/client';
 
class TetrixAIClient {
  constructor() {
    this.client = new MCPClient({
      transport: 'http',
      url: 'http://tetrix-level-1-dev-alb-463220232.us-east-1.elb.amazonaws.com/mcp',
      timeout: 30000
    });
  }
 
  async connect() {
    try {
      await this.client.connect();
      console.log('Connected to Tetrix AI MCP Server');
      
      // Get server capabilities
      const capabilities = await this.client.request('initialize');
      console.log('Server capabilities:', capabilities);
      
      return true;
    } catch (error) {
      console.error('Connection failed:', error);
      return false;
    }
  }
 
  async analyzeCode(path = '.') {
    try {
      const result = await this.client.request('tools/call', {
        name: 'analyze_codebase',
        arguments: { path, depth: 2 }
      });
      
      return result.content[0].text;
    } catch (error) {
      console.error('Code analysis failed:', error);
      throw error;
    }
  }
 
  async getAWSInsights() {
    try {
      const result = await this.client.request('tools/call', {
        name: 'analyze_aws_resources',
        arguments: { cost_analysis: true }
      });
      
      return result.content[0].text;
    } catch (error) {
      console.error('AWS analysis failed:', error);
      throw error;
    }
  }
 
  async consultExpert(domain, query) {
    try {
      const result = await this.client.request('tools/call', {
        name: 'consult_expert',
        arguments: { domain, query }
      });
      
      return result.content[0].text;
    } catch (error) {
      console.error('Expert consultation failed:', error);
      throw error;
    }
  }
 
  async disconnect() {
    await this.client.disconnect();
    console.log('Disconnected from Tetrix AI MCP Server');
  }
}
 
// Usage example
async function main() {
  const tetrix = new TetrixAIClient();
  
  if (await tetrix.connect()) {
    // Analyze codebase
    const codeAnalysis = await tetrix.analyzeCode('/src');
    console.log('Code Analysis:', codeAnalysis);
    
    // Get AWS insights
    const awsInsights = await tetrix.getAWSInsights();
    console.log('AWS Insights:', awsInsights);
    
    // Consult architecture expert
    const expertAdvice = await tetrix.consultExpert(
      'architecture',
      'How can I improve the scalability of my microservices?'
    );
    console.log('Expert Advice:', expertAdvice);
    
    await tetrix.disconnect();
  }
}
 
main().catch(console.error);