MCP Inspector: Complete guide to setup and usage

You’ve exposed your Celigo integrations as AI-callable tools through the Celigo MCP Server. The next step is to validate that those integrations behave correctly before connecting them to an AI agent or an LLM-powered workflow.

Without visibility into what your MCP server is actually exposing, debugging becomes reactive. Schema mismatches, failed tool invocations, authentication issues, and transport misconfigurations often surface only after an AI system attempts to execute a workflow. MCP Inspector solves this problem by providing a dedicated debugging and validation environment for MCP implementations.

MCP Inspector acts as a standard inspection client for the MCP ecosystem. Whether your server is built with Python or TypeScript SDKs, hosted remotely, or connected to enterprise data sources through Celigo, Inspector gives developers a way to test integrations before production deployment.

How MCP Inspector works: Understanding the integration validation architecture

MCP is an open protocol specification that enables AI systems and LLMs to interact with external tools, APIs, and integrations through standardized interfaces. Instead of hardcoding integrations into every AI implementation, MCP creates a consistent layer between AI agents and operational systems.

In enterprise environments, MCP sits between the integration layer and downstream AI applications. Celigo MCP Server exposes integrations as callable tools that AI agents can discover and invoke dynamically. This architecture allows developers to connect business workflows, APIs, and data sources to AI systems without custom orchestration logic for every implementation.

MCP Inspector functions as the validation layer within this architecture. It connects directly to MCP servers, reads schemas, tests tool calls, validates resources, and verifies transport behavior before an LLM or IDE-based coding assistant attempts to use those integrations.

Because MCP supports multiple SDK implementations across Python, Java, and TypeScript environments, Inspector provides a standardized interface for testing regardless of how the server was built.

Getting started with MCP Inspector

Requirements

Before starting MCP Inspector, confirm your environment is aligned with the supported runtime requirements. In enterprise integration environments, mismatched versions are a frequent source of silent MCP failures.

Requirements include:

• Node.js 18+ recommended
• macOS, Linux, or Windows
• Access to a running MCP server
• Valid authentication credentials if connecting to remote integrations

Most MCP SDK implementations support both Python and TypeScript development environments.

Quick start (UI mode)

UI mode provides a visual interface for validating what the Celigo MCP Server exposes before an AI agent initiates any orchestration workflow.

Start Inspector with:

npx @modelcontextprotocol/inspector

After launch, the Inspector UI opens in the browser. From there, teams can configure transports, authenticate sessions, inspect tools, and validate data sources exposed by the MCP server.

Connecting to your Celigo MCP Server

To connect Inspector to a Celigo MCP Server, configure an HTTP-based transport. Since Celigo-hosted MCP implementations run remotely, STDIO transport is not appropriate.

Example configuration:

npx @modelcontextprotocol/inspector https://your-server-url/mcp

For most enterprise implementations, HTTP transport ensures stable connectivity between Inspector and externally hosted integrations.

Inspecting locally developed servers

Teams building custom MCP implementations with Python or TypeScript SDKs can use Inspector locally during development.

Local inspection helps developers validate schemas, test integrations, and verify workflow behavior before exposing tools to production AI systems.

Running via Docker

Containerized environments often standardize MCP validation workflows through Docker.

Example:

docker run -p 6274:6274 -p 6277:6277 \
ghcr.io/modelcontextprotocol/inspector

Docker deployment supports repeatable validation workflows across development, staging, and CI/CD implementations.

Connecting and configuring your transport

Transport configuration is one of the most common causes of MCP connection failures.

STDIO vs SSE vs HTTP

STDIO transport works best for locally running MCP servers.

SSE and HTTP transports support remotely hosted implementations. For Celigo MCP Server deployments, HTTP-based transports are the correct choice because integrations are externally hosted.

Authentication and session tokens

When Inspector starts, the proxy generates a session token. This token authenticates requests between the Inspector client and MCP server.

A 401 error typically indicates:

• Missing bearer token
• Expired session
• Incorrect token configuration

Avoid using DANGEROUSLY_OMIT_AUTH in enterprise environments. Disabling authentication can expose integrations and connected data sources to unauthorized tool calls.

Key environment variables and flags

Common configuration variables include:

• CLIENT_PORT
• SERVER_PORT
• HOST
• MCP_PROXY_AUTH_TOKEN

These variables help teams customize Inspector implementations across environments.

Configuration file setup

Teams can define reusable MCP configurations in mcp.json.

Example:

{
 "servers": {
   "celigo": {
     "transport": "http",
     "url": "https://your-server-url/mcp"
   }
 }
}

Servers file export

Inspector supports exporting server configurations for use in Claude Code, Cursor, and other MCP-compatible IDE environments.

This simplifies collaboration between developers working across multiple MCP implementations.

Inspecting your Celigo MCP Server: Feature walkthrough

Celigo teams primarily use MCP Inspector to verify that integrations, schemas, and orchestration behavior align with AI agent expectations.

Server connection pane

The connection pane validates that the MCP handshake succeeds and confirms the server is reachable before testing integrations.

Tools tab

The Tools tab is the most important validation layer for enterprise MCP workflows.

Developers can:

• Inspect tool schemas
• Validate inputs and outputs
• Trigger manual tool calls
• Test integrations before production deployment

This is where schema mismatches between AI systems and exposed integrations usually surface.

Resources tab

The Resources tab validates which data sources and external systems are exposed through the MCP server.

Teams can confirm that downstream AI implementations only access intended resources.

Prompts tab

The Prompts tab allows teams to validate reusable prompt templates tied to orchestration workflows and LLM behaviors.

Notifications pane

The notifications pane surfaces real-time MCP events, failed tool calls, and downstream integration errors.

This provides visibility into orchestration failures before an AI agent encounters them.

CLI mode vs UI mode

For Celigo teams, UI mode supports interactive debugging while CLI mode supports automation.

When to use UI mode

Use UI mode for:

• Initial setup
• Schema validation
• Manual testing
• Interactive debugging

When to use CLI mode

Use CLI mode for:

• Automated testing
• CI/CD validation
• Batch implementations
• IDE integrations

Security considerations

When MCP servers expose integrations and APIs as callable tools, Inspector becomes part of the broader governance model.

Authentication

Authentication protects access to live integrations and orchestration workflows.

Use MCP_PROXY_AUTH_TOKEN to enforce authenticated access between Inspector and the MCP server.

Local-only binding

Inspector binds to localhost by default to prevent unauthorized access to integrations, APIs, and connected external systems.

Removing localhost restrictions can expose production orchestration workflows to external access.

DNS rebinding protection

DNS rebinding protections prevent malicious requests from triggering integrations or accessing connected data sources.

Configure ALLOWED_ORIGINS carefully as part of overall MCP governance controls.

Troubleshooting common issues

Inspector won’t connect to Celigo MCP Server

Common causes include:

• Wrong transport type
• Invalid server URL
• Server offline
• Using STDIO instead of HTTP

401 Unauthorized errors

Most 401 errors result from expired or missing bearer tokens.

Restart Inspector and reapply the session token.

Port conflicts on 6274 and 6277

Use CLIENT_PORT and SERVER_PORT to override conflicting ports.

Tool call returns unexpected output

Unexpected output usually indicates a schema mismatch between MCP implementations and AI agent expectations.

Use the Tools tab to inspect request and response payloads directly.

Celigo MCP Server and MCP Inspector: better together

The workflow is straightforward:

Build integrations in Celigo, expose them through the Celigo MCP Server, validate them with MCP Inspector, then connect AI agents with confidence.

Inspector gives teams a validation checkpoint before production deployment. Developers can verify schemas, authentication behavior, integrations, outputs, and error handling before any LLM or AI orchestration layer interacts with live systems.

Within broader agentic automation implementations, MCP Inspector acts as the quality gate between enterprise integrations and the AI systems invoking them.

Ready to expose your Celigo integrations to AI agents? Start with the Celigo MCP Server and use MCP Inspector to validate every tool before it goes live.