Cisco Nso MCP Server

🚀 Cisco NSO MCP Server

An implementation of the Model Context Protocol (MCP) server for Cisco NSO (Network Service Orchestrator), enabling AI-driven network automation through natural language interaction.

🚀 Quick Start

This package offers a standalone MCP server for Cisco NSO, written in Python. It can be installed using pip and run as a command-line tool. It exposes the capabilities of Cisco NSO to MCP tools and services, which can be consumed by any MCP-compatible client.

# Install the package
pip install cisco-nso-mcp-server

# Run the server
cisco-nso-mcp-server

✨ Features

What is MCP?

Model Context Protocol (MCP) is an open protocol that standardizes the way AI models interact with external tools and services. MCP implementations offer:

• Tool Definition: Structured definition of how AI models can use tools.
• Tool Discovery: A mechanism for models to discover available tools.
• Tool Execution: A standard method for models to invoke tools and receive results.
• Context Management: Efficient transfer of context between tools and models.
• Framework Independence: Compatibility with multiple AI frameworks such as OpenAI, Anthropic, and Google Gemini.
• Interoperability: A common language for communication between AI systems and external tools.

Flexibility of MCP

Although the primary use case of MCP is integration with LLMs, MCP and similar tool frameworks (like Smithery) are LLM-agnostic - they are simply APIs for specific protocols. This means you can:

• Use Directly: Utilize them directly in any application without an LLM.
• Control via an Integration Layer: Let an LLM control them through an integration layer.
• Mix the Two Approaches: Combine the two approaches according to specific requirements and use cases.

This flexibility makes MCP tools valuable beyond just LLM applications, serving as a general-purpose tool for communication between tools and services.

📦 Installation

Installation Steps

Install using pip:

pip install cisco-nso-mcp-server

Running the Server

Run the MCP server:

cisco-nso-mcp-server

📚 Documentation

Configuration Options

The MCP server supports two transport types: stdio and sse.

Standard Configuration

By default, the server uses stdio transport. If you want to change the transport type or the host and port for SSE transport, refer to the following commands:

Run the server with standard configuration

cisco-nso-mcp-server --transport stdio

Change the host and port for SSE transport

cisco-nso-mcp-server --transport sse --host 0.0.0.0 --port 8000

Environment Variable Priority

The values of environment variables override the default values but are overridden by command-line arguments.

Connecting to the Server

Standard Input/Output Transport (stdio)

For stdio transport, you need to start the server process and communicate via stdin and stdout:

from mcp import ClientSession, StdioServerParameters
from contextlib import AsyncExitStack

async def connect():
    exit_stack = AsyncExitStack()
    server_params = StdioServerParameters(
        command="cisco-nso-mcp-server",
        args=[],
        env=None
    )
    
    stdio_transport = await exit_stack.enter_async_context(stdio_client(server_params))
    stdio, write = stdio_transport
    session = await exit_stack.enter_async_context(ClientSession(stdio, write))
    await session.initialize()
    
    # Now you can use the session to call tools and read resources
    return session

SSE Transport

For SSE transport, you can connect to the server via a standard HTTP client:

from mcp import ClientSession, SSEServerParameters
from contextlib import AsyncExitStack

async def connect():
    exit_stack = AsyncExitStack()
    server_params = SSEServerParameters(
        url="http://localhost:8000",
        headers={"Authorization": "Bearer YOUR_TOKEN"}
    )
    
    sse_transport = await exit_stack.enter_async_context(sse_client(server_params))
    session = await exit_stack.enter_async_context(ClientSession(sse_transport))
    await session.initialize()
    
    # Now you can use the session to call tools and read resources
    return session

🔧 Technical Details

The MCP server leverages Python's asynchronous programming capabilities to efficiently handle network operations:

• Asynchronous Function Definition: All tool functions are defined as coroutines using async def.
• Non-blocking I/O: Network calls to Cisco NSO are wrapped in asyncio.to_thread() to prevent blocking the event loop.
• Concurrent Processing: Multiple tool calls can be processed simultaneously without waiting for previous operations to complete.
• Error Handling: Asynchronous try/except blocks capture and properly format errors from network operations.

📄 License

MIT License