DevLens MCP
Provides web search capabilities via DuckDuckGo to fetch real-time information, documentation, and technical snippets from the internet.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@DevLens MCP Deep dive into current best practices for OAuth2 in Python apps"
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.
DevLens MCP
The MCP Server I Built to Kill Alt-Tab. Clean, fast web context, right in your IDE.
Like most developers, I was sick of context-switching between VS Code and the browser for documentation. That was my core frustration. So, I built DevLens: an open-source MCP server because I was curious and wanted a custom solution that was more lightweight than existing tools.
The goal is simple: give your workspace AI (Copilot, Claude, etc.) web access that is structured and token-efficient. DevLens delivers twelve specialized tools via a three-layered architecture built for power and easy deployment.
What is MCP and DevLens's Role?
The MCP (Model Context Protocol) is the standard that lets your AI assistant call external tools (web search, scraping) to act beyond its training data. It gives the AI real-world and real-time ..power.
DevLens's Role is to be the most efficient implementation for web research. DevLens handles the intelligence (Smart Orchestration) and formats the results into clean Markdown. This ensures your workspace AI receives the precise context it needs without the clutter or high token cost of raw HTML.
Related MCP server: Crawl4AI MCP Server
Why DevLens (Solving the Flow Problem)
DevLens is built on two principles to solve context loss: Technical Composability and Token Efficiency.
Built for the Developer Workflow
The Problem Solved: No more useless switching between browser and editor. Your coding flow stays intact.
The Technical Edge: Our layered architecture uses simple primitives that combine powerfully. This means more precise and less costly workflows than existing "monolithic" solutions.
LLM Context Optimal: Our clean, token-optimized Markdown output is about 70% smaller than raw HTML. This is the secret for fast, accurate AI results in your chat.
Seamless IDE Integration: Designed to pair perfectly with VS Code Copilot and GitHub Copilot. Web research is injected directly into your editor.
Deployment Ready: Use it locally for your own work, or deploy it on a server to share with others.
Smart Orchestration — The system chooses the best tool sequence, automatically.
Zero Configuration — Install, run. Done.
Developer Personas & Use Cases
Persona | Problem Solved (The Pain) | DevLens Solution (The Win) |
Nina, the Frontend Developer | Needs a quick fix (e.g., that one CORS config snippet) but hates opening 5 Stack Overflow tabs. | Uses suggest_workflow or search_web + summarize_page to get the validated code snippet instantly in chat. Flow maintained. |
Kenji, the Staff Engineer | Must compare three serverless vendors for an architecture decision. Needs a single, definitive data dump. | Uses deep_dive to fetch, aggregate, and analyze complex data concurrently. The LLM receives the full, pre-processed report. |
Sarah, the DevOps Specialist | Has to manually check third-party deployment guides every week for silent, breaking changes. | Uses monitor_changes to passively track content hashes on critical docs, sending an alert only when something actually changes. |
Tools
DevLens gives you 12 specialized tools—think of it like a camera bag of lenses. Pick one, or let the smart system auto-select:
Layer | Metaphor | Focus | Tools |
Primitives | Basic Lenses | Precision & Reliability | search_web, scrape_url, crawl_docs, summarize_page, extract_links |
Composed | Multi-Lens Systems | Convenience & Aggregation | deep_dive, compare_sources, find_related, monitor_changes |
Meta | Auto-Focus Intelligence | Guidance & Optimization | suggest_workflow, classify_research_intent, get_server_docs |
Quick Start (Seriously, It's Fast)
Prerequisites
Python 3.12 or newer
uv package manager
Installation
# Clone the repository
git clone https://github.com/Y4NN777/devlens-mcp.git
cd devlens-mcp
# Install dependencies
uv sync
# Run the server (STDIO mode)
uv run python -m devlens.serverConfiguration du client MCP
Claude Desktop
Add this to claude_desktop_config.json:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonLinux:
~/.config/claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Option 1: Using launch script (Recommended - Cross-Platform)
{
"mcpServers": {
"devlens": {
"command": "/absolute/path/to/devlens-mcp/launch_mcp.sh",
"args": []
}
}
}Option 2: Direct uv command
{
"mcpServers": {
"devlens": {
"command": "uv",
"args": ["run", "python", "-m", "devlens.server"],
"cwd": "/absolute/path/to/devlens-mcp"
}
}
}VS Code Copilot (Recommended - Cross-Platform)
Create .vscode/mcp.json in your workspace:
{
"servers": {
"devlens": {
"command": "/absolute/path/to/devlens-mcp/launch_mcp.sh",
"args": []
}
}
}Note: The launch_mcp.sh script is cross-platform and automatically:
Detects your OS (Linux/macOS/Windows)
Locates
uvinstallation (checks~/.local/bin/uv,~/.cargo/bin/uv, or system PATH)Uses the correct Python from
.venv(.venv/bin/pythonon Unix,.venv/Scripts/python.exeon Windows)No manual configuration needed!
Other MCP Clients
Use STDIO transport:
uv run python -m devlens.serverVerify Installation
Test the server is working:
# Test basic functionality
uv run python -c "from devlens.server import mcp; print('DevLens server loaded successfully')"Usage Examples
Manual Tool Usage
# Simple search
search_web("FastAPI tutorial", limit=5)
# Scrape with metadata
scrape_url("https://docs.python.org", include_metadata=True)
# Multi-source research
deep_dive("Python async best practices", depth=5, parallel=True)
# Compare perspectives
compare_sources("FastAPI vs Flask", ["url1", "url2"])Smart Orchestration
# Let DevLens recommend the workflow
suggest_workflow("How to integrate payment API in Burkina Faso?")
# Returns:
# - Primary intent: quick_answer (50% confidence)
# - Workflow: [search_web(limit=3), scrape_url]
# - Suggested parameters optimized for intent
# - Fallback strategies if tools failWith Context
# Provide known URLs to skip search
context = ResearchContext(known_urls=["https://docs.stripe.com"])
suggest_workflow("Stripe payment integration guide", context)
# DevLens adapts:
# - Skips search (URLs already known)
# - Goes straight to crawl_docs or scrape_url
# - Optimizes parameters based on intentArchitecture
DevLens uses a simple, effective layered architecture—the smart bits guide the reliable bits.
Meta Layer (Intelligence) -> suggests workflows
Composed Layer (Convenience) -> combines primitives
Primitive Layer (Reliability) -> uses adapters
External Services (The Actual Internet)
Key Design Principles:
Composability — Tiny tools that handle huge tasks.
Intelligence at the Edges — Smart brain decides, reliable primitives execute.
Token Optimization — Maximum context, minimum token cost.
Fail Explicitly — No silent failures. We tell you exactly what broke.
Developer Velocity First — If it doesn't make you faster, we don't build it.
See ARCHITECTURE.md for the deep dive.
Library Stack (The Ingredients)
Layer | Library | Purpose | Framework |
MCP | fastmcp | MCP protocol implementation | |
Scraping | crawl4ai | JavaScript-enabled web scraping | |
Search | ddgs | DuckDuckGo search (no API key) | |
HTTP | httpx | Fallback HTTP client | |
Validation | pydantic | Input/output schemas |
Features
Intelligent Scraping
Exponential backoff retry (because the internet is flaky)
Metadata extraction (+41% information density)
Smart filtering (skips all the login/signup/spam garbage)
Markdown conversion (clean text for the AI)
Content change detection via hashing
Multi-Source Research
Parallel content fetching (3x faster)
Domain diversity filtering
Comparative analysis across sources
Progress tracking with success/failure reporting
Smart Orchestration
7 research intent patterns (e.g., quick_answer, deep_research, comparison)
Dynamic workflow generation based on context
Parameter optimization (limits/depths automatically set for intent)
Fallback strategies when tools fail
LRU cache for insane speed (200 entries)
Context Awareness
Tracks known URLs (no redundant searches)
Records failed tools (so the AI doesn't try the same thing twice)
Adapts workflows based on research state
Performance (Proof We Aren't Lying)
Tool | Duration | Cost | Notes |
search_web | 1-2s | Low | DuckDuckGo API |
scrape_url | 2-5s | Low | Single page fetch |
crawl_docs | 10-60s | High | Multi-page crawling (big tasks take big time) |
deep_dive | 5-15s | Medium | Parallel scraping |
suggest_workflow | <50ms | Minimal | LRU cached |
Documentation
REQUIREMENTS.md — Project scope and technical requirements
ARCHITECTURE.md — Software architecture and design philosophy
TOOLS.md — Comprehensive tool reference with examples
Philosophy
The DevLens Philosophy: Make the hard stuff simple and fast.
Composability — Build with small, focused primitives that combine
Intelligence at the Edges — Smart brain, reliable hands
Developer Velocity — If setup takes more than 5 minutes, it's too much.
Token Economy — Efficiency is currency.
Fail Explicitly — We tell you when something breaks.
Context-Aware — It remembers what happened.
Read the full philosophy in ARCHITECTURE.md.
Examples (In Action)
Quick Answer
Query: "What is FastAPI?"
-> suggest_workflow thinks: quick_answer (50%)
-> Workflow: search_web(limit=3) -> scrape_url
-> Result: Fast answer from the top source. Done.
Deep Research
Query: "Comprehensive guide to mobile payments in Africa"
-> suggest_workflow thinks: deep_research (75%)
-> Workflow: search_web(limit=10) -> deep_dive(depth=10, parallel=true)
-> Result: Multi-source aggregated report, ready for planning.
Documentation Learning
Query: "FastAPI documentation" + known_url
-> suggest_workflow thinks: documentation (80%)
-> Workflow: crawl_docs(max_pages=25) (skips search, goes straight to the docs)
-> Result: Complete documentation with TOC.
Comparison Research
Query: "Compare FastAPI vs Flask"
-> suggest_workflow thinks: comparison (65%)
-> Workflow: search_web -> scrape_url (parallel) -> compare_sources
-> Result: Side-by-side analysis ready for your pull request.
Contributing
Contributions welcome! Keep it simple:
Add, don't modify — New tools over changing existing ones
Document why — Explain your design choices
Test everything — All tools must have validation tests
Keep it simple — Clarity over cleverness
License
MIT License - See LICENSE for details.
Name origin: DevLens = A developer's lens for viewing the web. Different tools are different lenses (wide-angle, macro, zoom), with smart auto-focus (orchestration) that picks the right lens automatically.
Available Tools
12 toolsget_server_docsA
Get documentation about the WebDocx MCP server.
Provides guidance on server capabilities, tool usage, workflows, and best practices.
Args: topic: Documentation topic - 'overview', 'tools', 'workflows', 'orchestration', or 'examples'
Returns: Formatted documentation for the requested topic.
Inputs: topic. Returns: result
tool_classify_research_intentB
Classify the research intent of a query.
Analyzes a query to determine the user's research goal (quick answer, deep research, documentation, comparison, discovery, or monitoring). Returns confidence scores for each detected intent.
Args: query: Research question or task description.
Returns: Dictionary with primary and secondary intents with confidence scores.
Inputs: query (required). Returns: object
tool_compare_sourcesB
Compare information across multiple sources.
Analyzes differences and similarities between sources.
Args: topic: Topic being compared. sources: List of URLs (2-5) to compare.
Returns: Comparison report with common topics and differences.
Inputs: topic (required), sources (required). Returns: result
tool_crawl_docsA
Crawl multi-page documentation.
Follows same-domain links to build combined docs.
Args: root_url: Starting URL. max_pages: Max pages to crawl (1-20, default 5).
Returns: Combined Markdown with table of contents.
Inputs: root_url (required), max_pages. Returns: result
tool_deep_diveC
Research a topic from multiple sources.
Searches and scrapes multiple pages to build a report.
Args: topic: Topic to research. depth: Number of sources (1-10, default 3).
Returns: Aggregated research report.
Inputs: topic (required), depth. Returns: result
tool_extract_linksA
Extract all links from a page.
Useful for discovering navigation structure and resources.
Args: url: URL to extract links from. filter_external: Only return same-domain links (default True).
Returns: Organized list of internal and external links.
Inputs: url (required), filter_external. Returns: result
tool_monitor_changesB
Check if a page has changed.
Tracks content modifications over time.
Args: url: URL to monitor. previous_hash: Previous content hash to compare against.
Returns: Change detection report with content hash.
Inputs: url (required), previous_hash. Returns: result
tool_scrape_urlA
Scrape content from a URL as Markdown.
Args: url: URL to scrape.
Returns: Markdown content with source attribution.
Inputs: url (required). Returns: result
tool_search_webB
Search the web using DuckDuckGo.
Args: query: Search query string. limit: Maximum results (1-20, default 5).
Returns: List of results with title, url, snippet.
Inputs: query (required), limit. Returns: result
tool_suggest_workflowB
Suggest optimal research workflow for a query.
Analyzes the query and recommends the best tools and workflow to answer it. Uses smart intent classification and dynamic workflow generation.
Args: query: Research question or task description. known_urls: Optional list of already known URLs (default None).
Returns: Dictionary with intent, workflow steps, and suggested parameters.
Inputs: query (required), known_urls. Returns: object
tool_summarize_pageB
Get a quick overview of a page.
Extracts headings and key sections.
Args: url: URL to summarize.
Returns: Page summary with sections.
Inputs: url (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 12 tools
Most tools have distinct purposes, but some overlap exists. For example, tool_deep_dive and tool_crawl_docs both involve multi-page content aggregation, which could cause confusion. However, descriptions clarify that tool_deep_dive focuses on researching a topic across sources, while tool_crawl_docs is for building combined documentation from a single domain, helping to differentiate them.
The naming is mostly consistent with a 'tool_' prefix followed by a descriptive verb_noun pattern, such as tool_scrape_url and tool_summarize_page. However, get_server_docs deviates by using 'get_' instead of 'tool_', breaking the pattern. This minor inconsistency slightly reduces the overall naming uniformity.
With 12 tools, the count is well-scoped for a research and documentation server. Each tool appears to serve a specific function in the research workflow, from intent classification to content scraping and monitoring, without feeling excessive or insufficient for the domain's needs.
The tool set provides comprehensive coverage for research and documentation tasks. It includes intent classification, web searching, content scraping, summarization, comparison, change monitoring, and workflow suggestion, covering the full lifecycle from query analysis to report generation with no obvious gaps.
Maintenance
Related MCP Connectors
Driflyte MCP server which lets AI assistants query topic-specific knowledge from web and GitHub.
Web search API and MCP server for developers building AI agents.
One MCP server for all web data. Scrape, search, crawl, and AI research in one install.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
AlicenseDqualityDmaintenanceAn MCP server that enables AI clients like Cursor, Windsurf, and Claude Desktop to access web content in markdown format, providing web unblocking and searching capabilities.266 npm60MIT- FlicenseNot gradedqualityDmaintenanceA locally-hosted MCP server that provides AI assistants with advanced web crawling capabilities, including structured data extraction, deep site crawling, and page screenshots. It enables users to convert single or multiple URLs into clean Markdown content for processing by LLMs without requiring external API keys for basic features.-
- AlicenseAqualityBmaintenanceAn MCP server that enables AI assistants to fetch web content in multiple formats (HTML, JSON, text, Markdown) with intelligent content extraction, chunk management, and browser automation support.6152 npm15MIT
- FlicenseNot gradedqualityDmaintenanceMCP server that enables AI agents to search the web and extract clean Markdown content, with support for JavaScript rendering, structured data extraction, and screenshots.2-