Merge branch 'main' into update_readme

Author: lipandongDr

README.md

@@ -31,7 +31,7 @@ An MCP server implementation that integrates the Brave Search API, providing bot
 ### Getting an API Key
 1. Sign up for a [Brave Search API account](https://brave.com/search/api/)
 2. Choose a plan (Free tier available with 2,000 queries/month)
-3. Generate your API key [from the developer dashboard](https://api.search.brave.com/app/keys)
+3. Generate your API key [from the developer dashboard](https://api-dashboard.search.brave.com/app/keys)
 
 ### Usage with Claude Desktop
 Add this to your `claude_desktop_config.json`:

package-lock.json

@@ -108,22 +108,24 @@ export const createServer = () => {
         resources: { subscribe: true },
         tools: {},
         logging: {},
+        completions: {},
       },
     }
   );
 
   let subscriptions: Set<string> = new Set();
   let subsUpdateInterval: NodeJS.Timeout | undefined;
-  // Set up update interval for subscribed resources
+  let stdErrUpdateInterval: NodeJS.Timeout | undefined;
 
+  // Set up update interval for subscribed resources
   subsUpdateInterval = setInterval(() => {
     for (const uri of subscriptions) {
       server.notification({
         method: "notifications/resources/updated",
         params: { uri },
       });
     }
-  }, 5000);
+  }, 10000);
 
   let logLevel: LoggingLevel = "debug";
   let logsUpdateInterval: NodeJS.Timeout | undefined;
@@ -152,7 +154,21 @@ export const createServer = () => {
     };
     if (!isMessageIgnored(message.params.level as LoggingLevel))
       server.notification(message);
-  }, 15000);
+  }, 20000);
+
+
+  // Set up update interval for stderr messages
+  stdErrUpdateInterval = setInterval(() => {
+    const shortTimestamp = new Date().toLocaleTimeString([], {
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+    server.notification({
+      method: "notifications/stderr",
+      params: { content: `${shortTimestamp}: A stderr message` },
+    });
+  }, 30000);
 
   // Helper method to request sampling from client
   const requestSampling = async (
@@ -676,6 +692,7 @@ export const createServer = () => {
   const cleanup = async () => {
     if (subsUpdateInterval) clearInterval(subsUpdateInterval);
     if (logsUpdateInterval) clearInterval(logsUpdateInterval);
+    if (stdErrUpdateInterval) clearInterval(stdErrUpdateInterval);
   };
 
   return { server, cleanup };

src/brave-search/README.md

@@ -21,7 +21,7 @@
     "start:sse": "node dist/sse.js"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "1.0.1",
+    "@modelcontextprotocol/sdk": "^1.9.0",
     "express": "^4.21.1",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5"
@@ -31,4 +31,4 @@
     "shx": "^0.3.4",
     "typescript": "^5.6.2"
   }
-}
+}

src/everything/everything.ts

@@ -111,24 +111,6 @@ async function createBranch(
   return GitLabReferenceSchema.parse(await response.json());
 }
 
-async function getDefaultBranchRef(projectId: string): Promise<string> {
-  const response = await fetch(
-    `${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}`,
-    {
-      headers: {
-        "Authorization": `Bearer ${GITLAB_PERSONAL_ACCESS_TOKEN}`
-      }
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`GitLab API error: ${response.statusText}`);
-  }
-
-  const project = GitLabRepositorySchema.parse(await response.json());
-  return project.default_branch;
-}
-
 async function getFileContents(
   projectId: string,
   filePath: string,
@@ -138,6 +120,8 @@ async function getFileContents(
   let url = `${GITLAB_API_URL}/projects/${encodeURIComponent(projectId)}/repository/files/${encodedPath}`;
   if (ref) {
     url += `?ref=${encodeURIComponent(ref)}`;
+  } else {
+    url += '?ref=HEAD';
   }
 
   const response = await fetch(url, {
@@ -444,7 +428,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const args = CreateBranchSchema.parse(request.params.arguments);
         let ref = args.ref;
         if (!ref) {
-          ref = await getDefaultBranchRef(args.project_id);
+          ref = "HEAD";
         }
 
         const branch = await createBranch(args.project_id, {

src/everything/package.json

@@ -189,7 +189,7 @@ const knowledgeGraphManager = new KnowledgeGraphManager();
 // The server instance and tools exposed to Claude
 const server = new Server({
   name: "memory-server",
-  version: "1.0.0",
+  version: "0.6.3",
 },    {
     capabilities: {
       tools: {},
@@ -416,4 +416,4 @@ async function main() {
 main().catch((error) => {
   console.error("Fatal error in main():", error);
   process.exit(1);
-});
+});

src/gitlab/index.ts

@@ -14,12 +14,18 @@ A Model Context Protocol server that provides access to Redis databases. This se
 ### Connection Errors
 
 **ECONNREFUSED**
-  - **Cause**: Redis server is not running or unreachable
+  - **Cause**: Redis/Memurai server is not running or unreachable
   - **Solution**: 
-    - Verify Redis is running: `redis-cli ping` should return "PONG"
-    - Check Redis service status: `systemctl status redis` (Linux) or `brew services list` (macOS)
+    - Verify server is running:
+      - Redis: `redis-cli ping` should return "PONG"
+      - Memurai (Windows): `memurai-cli ping` should return "PONG"
+    - Check service status:
+      - Linux: `systemctl status redis`
+      - macOS: `brew services list`
+      - Windows: Check Memurai in Services (services.msc)
     - Ensure correct port (default 6379) is not blocked by firewall
     - Verify Redis URL format: `redis://hostname:port`
+    - If `redis://localhost:6379` fails with ECONNREFUSED, try using the explicit IP: `redis://127.0.0.1:6379`
 
 ### Server Behavior
 
@@ -57,7 +63,7 @@ To use this server with the Claude Desktop app, add the following configuration
 ### Docker
 
 * when running docker on macos, use host.docker.internal if the server is running on the host network (eg localhost)
-* Redis URL can be specified as an argument, defaults to "redis://localhost:6379"
+* Redis URL can be specified as an argument, defaults to "redis://localhost:6379" (use "redis://127.0.0.1:6379" if localhost fails)
 
 ```json
 {

src/memory/index.ts

@@ -1,20 +1,20 @@
 {
   "name": "@modelcontextprotocol/server-redis",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "MCP server for using Redis",
   "license": "MIT",
   "author": "Anthropic, PBC (https://anthropic.com)",
   "homepage": "https://modelcontextprotocol.io",
   "bugs": "https://github.com/modelcontextprotocol/servers/issues",
   "type": "module",
   "bin": {
-    "redis": "./build/index.js"
+    "mcp-server-redis": "dist/index.js"
   },
   "files": [
-    "build"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc && shx chmod +x build/*.js",
+    "build": "tsc && shx chmod +x dist/*.js",
     "prepare": "npm run build",
     "watch": "tsc --watch"
   },

src/redis/README.md

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -19,11 +21,14 @@ const redisClient = createClient({
     socket: {
         reconnectStrategy: (retries) => {
             if (retries >= MAX_RETRIES) {
-                console.error(`Maximum retries (${MAX_RETRIES}) reached. Giving up.`);
+                console.error(`[Redis Error] Maximum retries (${MAX_RETRIES}) reached. Giving up.`);
+                console.error(`[Redis Error] Connection: ${REDIS_URL}`);
                 return new Error('Max retries reached');
             }
             const delay = Math.min(Math.pow(2, retries) * MIN_RETRY_DELAY, MAX_RETRY_DELAY);
-            console.error(`Reconnection attempt ${retries + 1}/${MAX_RETRIES} in ${delay}ms`);
+            console.error(`[Redis Retry] Attempt ${retries + 1}/${MAX_RETRIES} failed`);
+            console.error(`[Redis Retry] Next attempt in ${delay}ms`);
+            console.error(`[Redis Retry] Connection: ${REDIS_URL}`);
             return delay;
         }
     }
@@ -233,26 +238,27 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 });
 
-// Start the server
-async function main() {
-    try {
-        // Set up Redis event handlers
-        redisClient.on('error', (err: Error) => {
-            console.error('Redis Client Error:', err);
-        });
+// Set up Redis event handlers
+redisClient.on('error', (err: Error) => {
+    console.error(`[Redis Error] ${err.name}: ${err.message}`);
+    console.error(`[Redis Error] Connection: ${REDIS_URL}`);
+    console.error(`[Redis Error] Stack: ${err.stack}`);
+});
 
-        redisClient.on('connect', () => {
-            console.error(`Connected to Redis at ${REDIS_URL}`);
-        });
+redisClient.on('connect', () => {
+    console.error(`[Redis Connected] Successfully connected to ${REDIS_URL}`);
+});
 
-        redisClient.on('reconnecting', () => {
-            console.error('Attempting to reconnect to Redis...');
-        });
+redisClient.on('reconnecting', () => {
+    console.error('[Redis Reconnecting] Connection lost, attempting to reconnect...');
+});
 
-        redisClient.on('end', () => {
-            console.error('Redis connection closed');
-        });
+redisClient.on('end', () => {
+    console.error('[Redis Disconnected] Connection closed');
+});
 
+async function runServer() {
+    try {
         // Connect to Redis
         await redisClient.connect();
 
@@ -261,26 +267,25 @@ async function main() {
         await server.connect(transport);
         console.error("Redis MCP Server running on stdio");
     } catch (error) {
-        console.error("Error during startup:", error);
-        await cleanup();
+        const err = error as Error;
+        console.error("[Redis Fatal] Server initialization failed");
+        console.error(`[Redis Fatal] Error: ${err.name}: ${err.message}`);
+        console.error(`[Redis Fatal] Connection: ${REDIS_URL}`);
+        console.error(`[Redis Fatal] Stack: ${err.stack}`);
+        await redisClient.quit().catch(() => {});
+        process.exit(1);
     }
 }
 
-// Cleanup function
-async function cleanup() {
-    try {
-        await redisClient.quit();
-    } catch (error) {
-        console.error("Error during cleanup:", error);
-    }
-    process.exit(1);
-}
-
 // Handle process termination
-process.on('SIGINT', cleanup);
-process.on('SIGTERM', cleanup);
+process.on('SIGINT', async () => {
+    await redisClient.quit().catch(() => {});
+    process.exit(0);
+});
 
-main().catch((error) => {
-    console.error("Fatal error in main():", error);
-    cleanup();
+process.on('SIGTERM', async () => {
+    await redisClient.quit().catch(() => {});
+    process.exit(0);
 });
+
+runServer();