Merge pull request #141 from intelligentnode/validate-gpt5-support

Validate gpt5 support

Author: intelligentnode

IntelliNode/MCP_IMPLEMENTATION.md

@@ -0,0 +1,255 @@
+# MCP (Model Context Protocol) Implementation in IntelliNode
+
+## Overview
+Added support for Model Context Protocol (MCP) to IntelliNode. MCP allows IntelliNode to connect to external tools and data sources via MCP servers. This is implemented as a "nice to have" feature with **zero additional dependencies** - only using existing `cross-fetch` package.
+
+## What Was Added
+
+### 1. Core Implementation: `utils/MCPClient.js`
+A lightweight HTTP-based MCP client for connecting to MCP servers.
+
+**Features:**
+- ✅ Connect to MCP servers via HTTP
+- ✅ Fetch available tools from MCP server
+- ✅ Call tools with parameters
+- ✅ Tool discovery and listing
+- ✅ Error handling
+- ✅ **No external dependencies** (uses cross-fetch which is already a dependency)
+
+**Key Methods:**
+```javascript
+class MCPClient {
+  constructor(serverUrl)              // Initialize with MCP server URL
+  async initialize()                  // Connect and fetch tools
+  async getTools()                    // Get all tools from server
+  async callTool(toolName, input)    // Execute a tool
+  getTool(toolName)                  // Get specific tool
+  getToolNames()                     // List all tool names
+  hasTool(toolName)                  // Check if tool exists
+  listTools()                        // Get formatted tool list
+}
+```
+
+### 2. Test Suite: `test/integration/MCPClient.test.js`
+Comprehensive test coverage with **2 mock tests + 2 optional real server tests**:
+
+**Mock Tests (Always Run - No Server Needed):**
+- ✅ Test 1: Tool management methods (getToolNames, getTool, hasTool, listTools)
+- ✅ Test 2: Error handling for non-existent tools
+
+**Real Server Tests (Optional - Requires MCP Server):**
+- ✅ Test 3: Initialize connection with real MCP server
+- ✅ Test 4: Fetch and list tools from real server
+
+**Run tests:**
+```bash
+# Mock tests only (CI/CD ready, always passes)
+node test/integration/MCPClient.test.js
+
+# With real server (optional)
+MCPClient_REAL_SERVER=true node test/integration/MCPClient.test.js
+```
+
+**Setup Real Server Tests:**
+```bash
+# Terminal 1: Start MCP server
+npx @modelcontextprotocol/server-filesystem /tmp
+
+# Terminal 2: Run tests with real server
+MCPClient_REAL_SERVER=true node test/integration/MCPClient.test.js
+```
+
+All mock tests pass ✓
+
+### 3. Updated Files
+
+#### `index.js` (Line 78, 138)
+- Added MCPClient import
+- Added MCPClient to module.exports
+
+#### `package.json`
+- Version bumped: `2.3.0` → `2.4.0`
+- Added keywords: "mcp", "model-context-protocol"
+
+#### `README.md`
+- Added new "Model Context Protocol (MCP)" section in Utilities
+- Includes example code and reference to MCP documentation
+
+## No Dependencies Added! 🎉
+This implementation uses **only existing dependencies**:
+- `cross-fetch` (already in package.json) - for HTTP requests
+- No need for `@modelcontextprotocol/sdk` (can be added later if full SDK features needed)
+- No need for `zod` (not required for basic tool communication)
+
+## Usage Examples
+
+### Basic Usage
+```javascript
+const { MCPClient } = require('intellinode');
+
+// Connect to MCP server
+const mcpClient = new MCPClient('http://localhost:3000');
+
+// Initialize and get tools
+const tools = await mcpClient.initialize();
+console.log('Available tools:', mcpClient.getToolNames());
+
+// Call a tool
+const result = await mcpClient.callTool('get_weather', { 
+  location: 'New York',
+  units: 'celsius' 
+});
+```
+
+### With Chatbot Integration
+```javascript
+const { Chatbot, ChatGPTInput } = require('intellinode');
+const { MCPClient } = require('intellinode');
+
+// Initialize MCP client
+const mcpClient = new MCPClient('http://localhost:3000');
+await mcpClient.initialize();
+
+// Create chat input with tool context
+const input = new ChatGPTInput('You are an assistant with access to tools');
+
+// Add tools information to context
+const toolsContext = mcpClient.listTools()
+  .map(t => `- ${t.name}: ${t.description}`)
+  .join('\n');
+
+input.addSystemMessage(`Available tools:\n${toolsContext}`);
+input.addUserMessage('What is the weather in New York?');
+
+// Get response from chatbot
+const bot = new Chatbot(openaiKey);
+const responses = await bot.chat(input);
+```
+
+### Mock Tools (for testing without server)
+```javascript
+const mcpClient = new MCPClient('http://localhost:3000');
+
+// Simulate tools locally (useful for development)
+mcpClient.tools = [
+  {
+    name: 'tool_name',
+    description: 'What this tool does',
+    inputSchema: { /* schema */ }
+  }
+];
+
+// Now you can use the client without running a server
+console.log(mcpClient.listTools());
+```
+
+## MCP Servers to Try
+
+### Built-in Servers (from Anthropic)
+```bash
+# Filesystem server
+npx @modelcontextprotocol/server-filesystem /path/to/root
+
+# GitHub server
+npm install -g @modelcontextprotocol/server-github
+
+# Slack server
+npm install -g @modelcontextprotocol/server-slack
+```
+
+### Other Available Servers
+- Google Drive
+- Notion
+- GitLab
+- Linear
+- And many more at: https://modelcontextprotocol.io
+
+## Architecture
+
+```
+┌─────────────────────────────────────┐
+│      IntelliNode Application        │
+├─────────────────────────────────────┤
+│                                     │
+│  Chatbot     +      MCPClient       │
+│                         │           │
+└─────────────────────────┼───────────┘
+                          │
+                  HTTP/JSON-RPC
+                          │
+                    ┌─────▼─────┐
+                    │ MCP Server │
+                    │ (Tools)    │
+                    └────────────┘
+```
+
+## Design Decisions
+
+1. **Minimal Dependencies**: No new npm packages required
+   - Only uses existing `cross-fetch`
+   - Can upgrade to full SDK if needed later
+
+2. **Simple HTTP Transport**: 
+   - Easy to debug
+   - Works with any HTTP-based MCP server
+   - Can be extended for WebSocket/SSE later
+
+3. **Flexible Tool Integration**:
+   - Tools can be loaded from server or mocked locally
+   - Easy to integrate into Chatbot prompts
+   - No breaking changes to existing code
+
+4. **Good to Have Philosophy**:
+   - Doesn't affect core library functionality
+   - Can be used optionally
+   - No required setup or configuration
+
+## Future Enhancements
+
+1. **WebSocket/SSE Transport**: For streaming responses
+2. **Tool Caching**: Cache tool definitions to reduce calls
+3. **Retry Logic**: Auto-retry with exponential backoff
+4. **Request Timeout**: Add configurable timeout handling
+5. **Authentication**: Support for API keys and OAuth
+6. **Batch Tool Calls**: Execute multiple tools in parallel
+7. **SDK Integration**: Optional `@modelcontextprotocol/sdk` for full features
+
+## Testing
+
+✅ All mock tests pass (CI/CD ready)
+```
+✓ Test 1: Mock Tool Management Methods
+✓ Test 2: Mock Error Handling
+```
+
+Optional real server tests (require running MCP server):
+```
+✓ Test 3: Real Server - Initialize
+✓ Test 4: Real Server - List Tools
+```
+
+**Run tests:**
+```bash
+# Default: Mock tests only
+node test/integration/MCPClient.test.js
+
+# With real server (set environment variable)
+MCPClient_REAL_SERVER=true node test/integration/MCPClient.test.js
+
+# Setup real server before running
+npx @modelcontextprotocol/server-filesystem /tmp
+```
+
+## Version Info
+
+- **IntelliNode Version**: 2.4.0 (increased from 2.3.0)
+- **MCP Implementation**: v1.0 (Basic HTTP client)
+- **Node.js Support**: 14+
+
+## References
+
+- [Model Context Protocol Documentation](https://modelcontextprotocol.io)
+- [MCP GitHub Repository](https://github.com/modelcontextprotocol)
+- [LlamaIndex MCP Integration](https://developers.llamaindex.ai/typescript/framework/modules/agents/tool/#mcp-tools)
+- [OpenAI MCP Support](https://platform.openai.com/docs/mcp)
+- [Anthropic MCP Announcement](https://www.anthropic.com/news/model-context-protocol)

IntelliNode/README.md

@@ -18,6 +18,7 @@
 Integrate your data with the latest language models and deep learning frameworks using intellinode **javascript**. The library provides intuitive functions for sending input to models like ChatGPT, WaveNet and Stable diffusion, and receiving generated text, speech, or images. With just a few lines of code, you can easily access the power of cutting-edge AI models to enhance your projects.
 
 # Latest Updates
+- Add support for OpenAI GPT-5 with reasoning effort control. 🧠
 - Add support for self-hosted vLLM models.
 - Generate frontend version from intellinode.
 - Integrated Nvidia-hosted models (DeepSeek and Llama3 🦙).
@@ -39,13 +40,25 @@ Chat with your docs via Intellinode one key at [app.intellinode.ai](https://app.
 ```js
 const { Chatbot, ChatGPTInput } = require('intellinode');
 ```
-2. call:
+2. call with GPT-5 (default):
 ```js
-// set chatGPT system mode and the user message.
+// GPT-5 is now the default model with medium reasoning effort
 const input = new ChatGPTInput('You are a helpful assistant.');
 input.addUserMessage('What is the distance between the Earth and the Moon?');
 
-// get chatGPT responses.
+// get GPT-5 responses.
+const bot = new Chatbot(openaiKey);
+const responses = await bot.chat(input);
+```
+3. control GPT-5 reasoning effort:
+```js
+// customize reasoning effort: minimal, low, medium, high
+const input = new ChatGPTInput('You are a helpful assistant.', { 
+  model: 'gpt-5',
+  effort: 'high'
+});
+input.addUserMessage('Explain quantum computing');
+
 const bot = new Chatbot(openaiKey);
 const responses = await bot.chat(input);
 ```
@@ -174,6 +187,30 @@ ProxyHelper.getInstance().setAzureOpenai(resourceName);
 ### Custom proxy
 Check the code to access the chatbot through a proxy: [proxy chatbot](https://github.com/Barqawiz/IntelliNode/blob/main/samples/command_sample/test_chatbot_proxy.js).
 
+### Model Context Protocol (MCP)
+Connect to external tools and data sources via MCP servers (good to have, not core):
+```js
+const { MCPClient } = require('intellinode');
+
+// Initialize MCP client pointing to your MCP server
+const mcpClient = new MCPClient('http://localhost:3000');
+
+// Fetch available tools from MCP server
+const tools = await mcpClient.initialize();
+console.log('Available tools:', mcpClient.getToolNames());
+
+// Call a tool
+const result = await mcpClient.callTool('get_weather', { 
+  location: 'New York',
+  units: 'celsius' 
+});
+
+// Use tools with your chatbot prompts
+const toolsList = mcpClient.listTools();
+console.log('Tools:', toolsList);
+```
+
+Supported MCP servers include: Filesystem, GitHub, Slack, Google Drive, and more. See [MCP Documentation](https://modelcontextprotocol.io) for available servers.
 
 # :closed_book: Documentation
 - [IntelliNode Docs](https://doc.intellinode.ai/docs/npm): Detailed documentation about IntelliNode.

IntelliNode/config.json

@@ -8,6 +8,7 @@
       "base": "https://api.openai.com",
       "completions": "/v1/completions",
       "chatgpt": "/v1/chat/completions",
+      "responses": "/v1/responses",
       "imagegenerate": "/v1/images/generations",
       "embeddings": "/v1/embeddings",
       "audiotranscriptions": "/v1/audio/transcriptions",
@@ -20,6 +21,7 @@
       "base": "https://{resource-name}.openai.azure.com/openai",
       "completions": "/deployments/{deployment-id}/completions?api-version={api-version}",
       "chatgpt": "/deployments/{deployment-id}/chat/completions?api-version={api-version}",
+      "responses": "/deployments/{deployment-id}/responses?api-version={api-version}",
       "imagegenerate": "/images/generations:submit?api-version={api-version}",
       "embeddings": "/deployments/{deployment-id}/embeddings?api-version={api-version}",
       "audiotranscriptions": "/deployments/{deployment-id}/audio/transcriptions?api-version={api-version}",