By Shekhar — Founder, AgenticMarket. Tested on VS Code 1.115.1, Cursor 3.0.1, and Claude Desktop 0.9. Last updated April 2026.

You've followed the setup instructions perfectly. Your mcpServers config is syntactically flawless. You don't see any connection errors. But when you open your IDE and trigger Copilot or Cursor chat, the tools just aren't there.

This specific failure mode — where the server connects but tool discovery fails silently — is one of the most frustrating parts of working with the Model Context Protocol.

Quick win: run your endpoint through the MCP Playground first. It visualizes the entire handshake process, showing exactly what your server returns during the tools/list request.

If the server connects but tools are missing, one of three things is happening:

1. The Handshake Timeout (The server took too long to list its tools).
2. The JSON Schema Violation (The client rejected the tool definitions).
3. The IDE Client Limitation (You hit a tool count limit or are in the wrong mode).

Let's diagnose and fix each one.

1. The Handshake Timeout (Initialization Lag)

When an IDE connects to an MCP server, it immediately sends an initialize request followed by a tools/list request. The IDE expects a response fast.

If your server takes 5 seconds to load its dependencies, authenticate with a remote DB, or load a local ML model before it can respond to the tools/list request, the IDE simply gives up.

The Symptom: In Cursor's Output panel (MCP channel), you'll see the connection succeed, but no tools are registered. In Claude Desktop, you might find a timeout logged in the ~/Library/Logs/Claude/mcp*.log file.

The Fix: You must decouple tool discovery from heavy initialization.

Wrong (Python):

pythonCOPY
# The server blocks while heavy_init() runs
db = heavy_init()

@mcp.tool()
def query_db(sql: str):
    return db.query(sql)

Correct (Python):

pythonCOPY
# Delay heavy initialization until the tool is ACTUALLY called
db = None

@mcp.tool()
def query_db(sql: str):
    global db
    if db is None:
        db = heavy_init()
    return db.query(sql)

By making the initialization lazy, the server can immediately tell the IDE, "Yes, I have a query_db tool" in milliseconds, allowing the handshake to succeed.

2. The JSON Schema Violation

Every MCP tool must provide a JSON Schema describing its arguments. MCP clients strictly parse these schemas so they can pass them to the LLM. If your schema is malformed, the IDE will silently drop the tool.

Common Schema Mistakes

• Missing "type": "object" at the root. The arguments schema MUST have "type": "object". If you define a root string or array, it will be rejected.
• Using unsupported types. Sticking to standard JSON schema types (string, number, integer, boolean, array, object) is mandatory. If you accidentally leak a python-specific or typescript-specific type name into your schema, it fails.
• Incorrectly defining required properties. The required field must be an array of strings matching the property keys.

Wrong (TypeScript):

typescriptCOPY
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "search_web",
        description: "Search the web",
        // BUG: missing 'type: "object"' and 'properties'
        inputSchema: {
          query: { type: "string" }
        }
      }
    ]
  };
});

Correct (TypeScript):

typescriptCOPY
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "search_web",
        description: "Search the web",
        inputSchema: {
          type: "object",
          properties: {
            query: { type: "string", description: "The search query" }
          },
          required: ["query"]
        }
      }
    ]
  };
});

Note: If you use the FastMCP SDK in Python or the @modelcontextprotocol/sdk in TS, they usually handle schema generation automatically based on your function signatures. It's usually raw integrations that fall into this trap.

3. IDE Client Limitations & UI Toggles

Sometimes the server is perfect, but the IDE is hiding the tools from you.

Cursor's Tool Limit

Cursor has a rough limit on how much context it will dedicate to tools. If you have 5 different MCP servers loaded, and they expose 60 tools combined, Cursor will silently truncate the list.

• Try unloading other MCP servers in Cursor's settings.
• Check if your tools appear when it's the only server running.

VS Code's "Agent Mode"

In VS Code Copilot Chat, tools are strictly bound to the Agent Mode. If your chat is set to "Ask" mode (the default for simple Q&A), the tools panel will literally vanish, and the LLM will not make any tool calls.

• Look at the chat input box.
• Click the mode dropdown and switch it from Ask to Agent.
• Ensure the server has a green check mark in the MCP configuration tab.

The "Disabled by Default" Trap

In both Claude Desktop and Cursor, users can toggle individual tools off. It's surprisingly easy to accidentally click the toggle in the UI and disable a tool. Re-open your MCP server settings panel and double-check that the tools are checked explicitly as "Enabled".

The Ultimate Diagnostic Step

If you still can't get the tools to show up, the best way to isolate the issue is to call the server directly yourself using the MCP Inspector.

npx handles this beautifully:

bashCOPY
npx @modelcontextprotocol/inspector node path/to/your/server.js
# Or for python:
npx @modelcontextprotocol/inspector uvx your-server-command

The inspector runs a web interface on localhost:5173. Open it, connect to your server, and check the "Tools" tab.

• If the tools don't show up in the inspector, your code is broken. Check your tool decorators and schema.
• If the tools do show up in the inspector, but not in your IDE, the problem is your IDE config, environment PATH, or the initialization timeout.

Have a different issue? If your server is crashing completely (you see Error -32000), it's likely a config or stdout issue instead. Read the Complete Troubleshooting Guide.

I write about MCP tooling and the agentic AI developer ecosystem roughly twice a month. Subscribe to the AgenticMarket newsletter if that's useful.