Second Opinion MCP Server

🚀 Second Opinion MCP Server

The Second Opinion MCP (Multi - Consultation Protocol) Server is a system that combines multiple AI tools to provide solutions for programming problems. By integrating Gemini AI, Perplexity AI, and the Stack Overflow API, it can offer users comprehensive technical support.

🚀 Quick Start

The Second Opinion MCP Server integrates multiple AI tools to assist developers in solving programming problems. You can follow the steps below to install, configure, and use it.

✨ Features

1. Automatic Language Detection: Identifies the language of code snippets.
2. Code Snippet Extraction and Formatting: Extracts code from files and formats it.
3. AI Consultation Integration:
   • Gemini AI: Provides code analysis and improvement suggestions.
   • Perplexity AI: Answers programming questions.
4. Stack Overflow Integration: Automatically searches for relevant solutions.

📦 Installation

Install Dependencies

npm install express uuid @types/node typescript ts-node

Build the Server

npm run build

Configure Environment Variables

Edit config.ts:

export const config = {
  GEMINI_API_KEY: 'your_api_key',
  PERPLEXITY_API_KEY: 'your_api_key',
  STACK_OVERFLOW_API_KEY: 'your_api_key'
};

💻 Usage Examples

Basic Usage

The main tool is get_second_opinion, which sends programming questions via an HTTP POST request.

Input Example

{
  "problem": "How to implement a WebSocket connection in TypeScript?",
  "context": {
    "codeSnippet": "const socket = new WebSocket('ws://localhost:8080');"
  }
}

Output Example

{
  "Solutions": [
    {
      "Method": "Use useRef to manage the WebSocket instance",
      "Code Example": "const socketRef = useRef<WebSocket | null>(null);"
    },
    {
      "Method": "Lifecycle management",
      "Code Example": "useEffect(() => { // WebSocket connection logic }, []);"
    }
  ],
  "Best Practices": [
    "Use useCallback to handle event listeners",
    "Ensure graceful connection closure"
  ]
}

🔧 Technical Details

Understanding the Problem

When implementing a WebSocket connection in TypeScript, the following points need to be considered:

• Connection Management: How to correctly open, maintain, and close the connection.
• State Management: Handle different WebSocket connection states (Connecting, Open, Closing, Closed).
• Message Handling: Parse received messages and update the component's state.

Solutions

Method 1: Use useRef to Manage the Instance

function useSocket(url: string) {
  const socketRef = useRef<WebSocket | null>(null);

  useEffect(() => {
    socketRef.current = new WebSocket(url);
    
    return () => {
      if (socketRef.current) {
        socketRef.current.close();
      }
    };
  }, [url]);

  const sendMessage = useCallback((message: string) => {
    if (socketRef.current?.readyState === WebSocket.OPEN) {
      socketRef.current.send(message);
    }
  }, []);

  return { sendMessage };
}

Method 2: Handle the Connection Lifecycle

function useWebSocket(url: string) {
  const [messages, setMessages] = useState<string[]>([]);

  useEffect(() => {
    const socket = new WebSocket(url);

    socket.onmessage = (event: MessageEvent) => {
      setMessages(prev => [...prev, event.data]);
    };

    return () => {
      socket.close();
    };
  }, [url]);

  const sendMessage = useCallback((message: string) => {
    if (socket.readyState === WebSocket.OPEN) {
      socket.send(message);
    }
  }, []);

  return { messages, sendMessage };
}

📚 Best Practices

1. Dependency Management:
   • Use useRef to maintain state.
   • Use useCallback to optimize performance.
2. Performance Optimization:
   • Reduce unnecessary re - renders.
3. Error Handling:
   • Handle connection errors and timeouts.
4. Testing:
   • Simulate WebSocket connections.
   • Verify cleanup logic.

📚 Documentation

Project Structure

src/
├── config.ts        # Configuration file containing API keys and other settings
├── fileUtils.ts     # File operations and language detection functions
├── index.ts         # Entry point to start the server
├── perplexity.ts   # Perplexity AI interface implementation
├── server.ts       # Core logic of the MCP server
├── stackOverflow.ts # Stack Overflow API call handling
└── types.ts        # TypeScript type definition file

⚠️ Important Note

• Error Handling: Ensure that sufficient error catching and handling mechanisms are added to all network operations.
• Performance Optimization: Use React hooks reasonably to avoid unnecessary re - renders.
• Code Style: Follow a unified code specification, such as Prettier formatting.

Through the above methods and technologies, the Second Opinion MCP Server can effectively help developers solve complex programming problems.