Which integrations are available for this server?

Performs web searches using DuckDuckGo's search API, with support for general web searches and documentation-focused searches that prioritize technical domains. Intelligently reads and extracts content from GitHub pages with automatic code-focused parsing that retains headers, code blocks, and tables while stripping conversational text.

How do I use Nexus MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Nexus MCP Server search for the latest Python 3.12 release notes and extract just the code changes" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Nexus MCP Server

by rcdelacruz

Overview Schema Source Related Servers Score Discussions Admin

Python

Local

🌐 Nexus MCP Server

The Hybrid Search & Retrieval Engine for AI Agents.

Nexus is a local Model Context Protocol (MCP) server that combines the best features of Exa (semantic web search) and Ref (documentation-optimized reading). It provides your AI agent (Claude, Cursor, etc.) with the ability to search the web and extract surgical, token-efficient context from documentation without requiring external API keys.

✨ Features

1. Hybrid Search (`nexus_search`)

Nexus understands that searching for news is different from searching for API docs.

General Mode: Performs broad web searches (like Exa) to find articles, news, and general information.
Docs Mode: Automatically filters results to prioritize technical domains (readthedocs, github, stackoverflow, official documentation).

2. Intelligent Reading (`nexus_read`)

Nexus doesn't just dump HTML into your context window. It parses content based on intent.

General Focus: Cleans articles, removing ads, navigation bars, and fluff. Perfect for reading news or blog posts.
Code Focus: Aggressively strips conversational text, retaining only Headers, Code Blocks, and Tables. This mimics ref.tools, ensuring your model gets pure syntax without the noise.
Auto-Detect: Automatically switches to "Code Focus" when visiting technical sites like GitHub or API references.

3. Privacy & Cost

No API Keys Required: Uses DuckDuckGo for search and standard HTTP requests for retrieval.
Runs Locally: Your data stays on your machine until the cleaned context is sent to the LLM.

🛠️ Installation

Prerequisites

Python 3.10+

Quick Install

Option 1: Using pip (Simplest - Works Everywhere)

# Install directly from GitHub
pip install git+https://github.com/rcdelacruz/nexus-mcp.git

Option 2: Using uvx (Faster, Isolated)

First install uv if you don't have it:

# On macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# On Windows
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

Then use uvx (no separate installation needed):

uvx --from git+https://github.com/rcdelacruz/nexus-mcp.git nexus-mcp

Development Install

For local development or contributing:

Clone the repository:

git clone https://github.com/rcdelacruz/nexus-mcp.git
cd nexus-mcp

Install in development mode:

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install the package in editable mode
pip install -e .

For development with testing tools:

pip install -e ".[dev]"

⚙️ Configuration

Claude Code (CLI)

Option 1: Using pip (Simplest)

# First install the package
pip install git+https://github.com/rcdelacruz/nexus-mcp.git

# Add the server globally (available in all projects)
claude mcp add nexus --transport stdio --scope user -- nexus-mcp

# Verify installation
claude mcp list        # Should show: ✓ Connected

Option 2: Using uvx (Requires uv installation)

Make sure you have uv installed first (see Installation section above), then:

# Add the server globally (available in all projects)
claude mcp add nexus --transport stdio --scope user -- \
  uvx --from git+https://github.com/rcdelacruz/nexus-mcp.git nexus-mcp

# Verify installation
claude mcp list        # Should show: ✓ Connected

Option 3: Local Development Setup

If you cloned the repository for development:

# Navigate to nexus-mcp directory
cd /path/to/nexus-mcp

# Install dependencies first
python3 -m venv .venv
source .venv/bin/activate
pip install -e .

# Add the server to Claude Code (project scope)
claude mcp add nexus --scope project -- \
  $(pwd)/.venv/bin/python $(pwd)/nexus_server.py

# Verify installation
claude mcp list

Configuration Scopes:

--scope user - Available across all projects (recommended for GitHub install)
--scope project - Creates .mcp.json (shareable via git)
--scope local - Personal config in ~/.claude.json

Check server status:

claude mcp list        # Should show: nexus - ✓ Connected
/mcp                   # In conversation: shows available tools

Claude Desktop / Cursor

Config Location:

MacOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Option 1: Using pip (Simplest)

First install: pip install git+https://github.com/rcdelacruz/nexus-mcp.git

Then add to config:

{
  "mcpServers": {
    "nexus": {
      "command": "nexus-mcp"
    }
  }
}

Option 2: Using uvx (Requires uv installed)

Make sure uv is installed first (see Installation section), then add to config:

{
  "mcpServers": {
    "nexus": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/rcdelacruz/nexus-mcp.git",
        "nexus-mcp"
      ]
    }
  }
}

For local development:

If you cloned the repo and installed with pip install -e .:

{
  "mcpServers": {
    "nexus": {
      "command": "/ABSOLUTE/PATH/TO/.venv/bin/python",
      "args": ["/ABSOLUTE/PATH/TO/nexus_server.py"]
    }
  }
}

Replace /ABSOLUTE/PATH/TO/ with the actual path to your clone.

🚀 Usage

Once connected, simply prompt Claude naturally. Nexus handles the tool selection.

Verify It's Working

Check server connection:

claude mcp list
# Should show: nexus - ✓ Connected

# In a Claude Code conversation:
/mcp
# Should show nexus with 2 tools available

See VERIFICATION.md for detailed testing instructions.

Scenario 1: Technical Research (Ref Emulation)

User: "How do I use asyncio.gather in Python? Check the docs."

Nexus Action:
1. Search: nexus_search(query="python asyncio gather", mode="docs")
2. Read: nexus_read(url="docs.python.org/...", focus="code")
Result: The AI receives only the function signature and code examples, saving context window space.

Scenario 2: General Research (Exa Emulation)

User: "Search for the latest updates on the NVIDIA Blackwell chip."

Nexus Action:
1. Search: nexus_search(query="NVIDIA Blackwell updates", mode="general")
2. Read: nexus_read(url="techcrunch.com/...", focus="general")
Result: The AI reads a clean, ad-free summary of the news article.

🧠 Architecture

Nexus is built on the Model Context Protocol using the FastMCP Python SDK.

Component	Technology	Purpose
MCP Framework	`FastMCP`	Server implementation and tool registration
Search Backend	`DDGS` (DuckDuckGo)	Free web search without API keys
HTTP Client	`httpx`	Async HTTP requests with timeout handling
HTML Parsing	`BeautifulSoup4`	Intelligent content extraction
Doc Detection	Heuristic URL matching	Auto-detection of technical sites

Production Features

✅ Comprehensive Error Handling - All edge cases covered with graceful fallbacks

✅ Input Validation - URL format, parameter bounds, and mode validation

✅ Proper Logging - Structured logging instead of print statements

✅ Configurable Limits - Timeouts, content length, and result counts

✅ 85% Test Coverage - 19 comprehensive unit tests

✅ Type Hints - Full type annotations for better IDE support

✅ Dependency Management - Modern pyproject.toml configuration

🧪 Testing

Run the test suite:

# Activate virtual environment
source .venv/bin/activate

# Run all tests with coverage
pytest

# Run specific test file
pytest tests/test_nexus_server.py -v

# Run manual integration test
python test_manual.py

📊 Project Structure

nexus-mcp/
├── nexus_server.py      # Main MCP server implementation
├── tests/               # Comprehensive test suite
│   ├── __init__.py
│   └── test_nexus_server.py
├── test_manual.py       # Manual integration testing
├── pyproject.toml       # Project configuration & dependencies
├── LICENSE              # MIT License
├── README.md            # This file
└── .gitignore          # Git ignore rules

🤝 Contributing

Contributions are welcome! Please ensure:

All tests pass (pytest)
Code coverage remains above 80%
Follow existing code style and patterns
Add tests for new features

📄 License

MIT License - See LICENSE file for details. Free to use and modify.

Available Tools

2 tools

nexus_readA

Reads a URL with intelligent parsing logic.

Args:
    url: The URL to visit.
    focus:
        'general' = Returns clean article text (Exa style).
        'code'    = Returns only headers, code blocks, and tables (Ref style).
        'auto'    = Detects if it's a doc site and switches to 'code' mode.

Returns:
    Parsed and cleaned content from the URL.

ParametersJSON Schema

Name	Required	Description	Default
`url`	Yes
`focus`	No		auto

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the tool's parsing logic and return behavior ('Parsed and cleaned content from the URL'), which adds value beyond the input schema. However, it does not cover important aspects like error handling, rate limits, authentication needs, or performance characteristics, resulting in moderate transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized and well-structured, with a brief purpose statement followed by 'Args:' and 'Returns:' sections. Each sentence adds value without redundancy, making it easy to scan and understand. The formatting enhances readability without unnecessary verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity, no annotations, and an output schema present, the description is largely complete. It covers the purpose, parameters, and return value adequately. However, it could improve by addressing behavioral aspects like error cases or limitations, slightly reducing completeness for a tool with parsing logic.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains the 'url' parameter as 'The URL to visit' and details the 'focus' parameter with three modes ('general', 'code', 'auto'), including their effects. This fully compensates for the schema's lack of descriptions, providing clear semantics for both parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Reads a URL with intelligent parsing logic.' It specifies the verb ('Reads') and resource ('URL'), and distinguishes it from the sibling tool 'nexus_search' by focusing on parsing content from a given URL rather than searching. However, it doesn't explicitly differentiate from 'nexus_search' beyond the name, which slightly limits clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage through the 'focus' parameter options ('general', 'code', 'auto'), suggesting when to use different modes based on content type. However, it lacks explicit guidance on when to use this tool versus 'nexus_search' or other alternatives, and does not mention any prerequisites or exclusions, leaving usage context somewhat vague.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

nexus_searchA

A hybrid search tool combining Exa's breadth and Ref's specificity.

Args:
    query: The search term.
    mode: 'general' for broad web search (Exa style).
          'docs' to prioritize technical documentation (Ref style).
    max_results: Number of results to return (1-20).

Returns:
    Formatted search results with titles, URLs, and snippets.

ParametersJSON Schema

Name	Required	Default
`query`	Yes
`mode`	No	general
`max_results`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.3/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the hybrid nature of the search and the two modes, but doesn't mention rate limits, authentication requirements, or what happens with invalid inputs. The description adds some context but lacks comprehensive behavioral details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is perfectly structured and front-loaded: it starts with the core purpose, then clearly lists arguments with explanations, and ends with return information. Every sentence earns its place with no wasted words, making it highly efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which handles return value documentation) and the description provides good parameter semantics, it's mostly complete. However, for a search tool with no annotations, it could benefit from mentioning rate limits or authentication requirements to achieve full completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains what each parameter does: 'query' as the search term, 'mode' with specific explanations for 'general' and 'docs' options, and 'max_results' with its range constraint (1-20). This fully compensates for the schema's lack of descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'A hybrid search tool combining Exa's breadth and Ref's specificity.' It specifies the verb (search) and resource (web/technical documentation), and distinguishes it from its sibling 'nexus_read' by focusing on search rather than reading operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use different modes: 'general' for broad web search and 'docs' to prioritize technical documentation. However, it doesn't explicitly state when NOT to use this tool or mention alternatives beyond the mode selection, which prevents a perfect score.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

2 tool updatesDec 28, 2025
- First observednexus_read
- First observednexus_search

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A3.9/5.0

Scored 2026-04-18 07:45 across 2 tools

Disambiguation5/5

The two tools have clearly distinct purposes: 'nexus_read' fetches and parses content from a specific URL, while 'nexus_search' performs web searches based on a query. There is no overlap in functionality, and an agent can easily differentiate between them based on whether it needs to retrieve known content or discover new information.

Naming Consistency5/5

Both tools follow a consistent 'nexus_verb' naming pattern, using snake_case throughout. The verbs 'read' and 'search' are distinct and accurately describe their respective actions, creating a predictable and readable naming convention across the tool set.

Tool Count2/5

With only two tools, the server feels under-scoped for its apparent purpose of intelligent web content retrieval and search. This minimal set may limit agents' ability to perform more complex workflows, such as saving, organizing, or analyzing retrieved content, making it borderline too thin for practical use.

Completeness3/5

The tools cover basic retrieval (read) and discovery (search) functions, but there are notable gaps. For example, there is no tool for managing or storing fetched content, no way to interact with search results beyond viewing them, and no update or deletion capabilities, which could hinder agents in more advanced tasks.

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

agentsearch-mcp A
io.github.IsaiahDupree
LLM-ready web search + instant answers + URL-to-clean-text fetch for agents and RAG.
Search RAG Systems Browser Automation
31
Ninelayer
in.ninelayer
Agent-native search engine with live web research optimized for AI agents.
Search Agent Orchestration
2
Ragora A
io.github.mregmi
Search your knowledge bases from any AI assistant using hybrid RAG.
RAG Systems Search Knowledge & Memory
2
Parallel Search MCP AOAuth
ai.parallel
The best web search for your AI Agent
Search Agent Orchestration Browser Automation
216

Appeared in Searches

OpenAI's Web Retrieval Infrastructure

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/rcdelacruz/nexus-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

🌐 Nexus MCP Server

✨ Features

1. Hybrid Search (nexus_search)

2. Intelligent Reading (nexus_read)

3. Privacy & Cost

🛠️ Installation

Prerequisites

Quick Install

Development Install

⚙️ Configuration

Claude Code (CLI)

Claude Desktop / Cursor

🚀 Usage

Verify It's Working

Scenario 1: Technical Research (Ref Emulation)

Scenario 2: General Research (Exa Emulation)

🧠 Architecture

Production Features

🧪 Testing

📊 Project Structure

🤝 Contributing

📄 License

Available Tools

Output Schema

TDQS

Output Schema

TDQS

Tool Schema Changelog

TDQS

Resources

Looking for Admin?

Related MCP Connectors

Appeared in Searches

Latest Blog Posts

MCP directory API

1. Hybrid Search (`nexus_search`)

2. Intelligent Reading (`nexus_read`)