# Linkup (AI Search & RAG) MCP

> Linkup (AI Search & RAG) connects your AI agents directly to real-time web intelligence. It lets you run semantic queries and pull clean, structured content from any URL or search result. Stop relying on stale data; use Linkup when your agent needs facts that changed minutes ago—like market prices, breaking news summaries, or the latest technical documentation.

## Overview
- **Category:** ai-frontier
- **Price:** Free
- **Tags:** rag, semantic-search, web-intelligence, llm-optimization, data-retrieval, real-time-data

## Description

Linkup connects your AI agents straight into real-time web data. You're done relying on training data that’s already stale; this setup gives you immediate access to facts—the kind that changed minutes ago, like stock quotes or breaking news summaries.

When you need actionable context, the system works through two main channels: `search_web` and `fetch_url`. You call **`search_web`** when you need current information pulled from multiple sources. This tool performs real-time web searches, giving you organized payloads that include titles, snippets, and source links right off the bat. When you're just looking for quick facts, use the 'fast' setting; it handles basic queries efficiently. But if you’re doing deep research—say, comparing technical specs across five different industry sites—you run `search_web` with the 'deep' limit. This mode synthesizes insights from numerous diverse web locations, building out a comprehensive picture that goes way beyond simple link lists.

**`fetch_url`** is what you use when you need to pull clean text directly from a single, specific website URL. It’s built tough; it bypasses the usual junk that breaks simpler scrapers, like complex JavaScript loops or basic bot protections. Instead of giving you messy HTML code full of ads and navigation menus, `fetch_url` strips all that noise away, leaving you with pure, readable content. You can target specific documentation pages or niche technical sites and ensure your agent gets the exact context it needs without having to wade through irrelevant fluff.

The combination means you're not just getting search results; you’re getting structured data ready for immediate use. Whether you need a quick fact check via `search_web`'s fast mode, or a detailed comparison across multiple sources using deep research, the platform handles it. If you know the exact page that holds the answer—a specific white paper or a product manual—you run `fetch_url`. The output is clean text that your agent can interpret immediately for RAG pipelines.

When you need to ground your agent's answers in current facts, this system delivers it. You don't have to worry about the model hallucinating based on old data because every piece of context comes from a live pull—either through targeted extraction or deep search synthesis. The tool ensures that even if a website changes its underlying code structure, you still get clean text and structured source links. It’s designed for maximum reliability when your agent's job depends on the information being current and accurate.

## Tools

### fetch_url
Extracts clean text from a specific website URL, bypassing common bot protections and complex JavaScript loops.

### search_web
Performs real-time web searches. You choose between 'fast' for basic facts or 'deep' for thorough research limits.

## Prompt Examples

**Prompt:** 
```
Search for the latest NVIDIA earnings report summary
```

**Response:** 
```
Searching the web… Based on the latest results from Linkup, NVIDIA reported Q4 revenue of $22.1 billion, up 265% year-over-year. Data center revenue hit a record $18.4 billion. Would you like me to fetch the full detailed analysis from one of the source articles?
```

**Prompt:** 
```
Extract the technical specifications from this documentation URL: [url]
```

**Response:** 
```
Fetching content… I've extracted the clean technical text. The system requirements include 16GB RAM, an NVIDIA RTX 30-series GPU, and Python 3.10+. I can provide the full list of API endpoints described in the doc as well.
```

**Prompt:** 
```
Deep search for 'AI agent security best practices 2024'
```

**Response:** 
```
Performing deep search… I've synthesized security insights from 12 diverse sources. Key best practices for 2024 include: 1) Strict tool-call sandboxing, 2) Human-in-the-loop for high-stakes actions, 3) Real-time prompt injection monitoring. Would you like a detailed breakdown of the sandboxing techniques?
```

## Capabilities

### Search for real-time facts
Use `search_web` to perform deep or fast searches and get immediate answers based on current web results.

### Extract content from a specific webpage
Run `fetch_url` to pull clean, readable text directly from any provided URL, bypassing bot defenses.

### Get structured search data
Receive organized payloads including titles and source links by calling the search tools.

### Deep research across multiple sources
Run `search_web` with 'deep' mode to synthesize insights from numerous diverse web locations.

## Use Cases

### Tracking breaking market news
A financial analyst needs the latest earnings summary for three different competitors. Instead of manually opening and reading multiple sites, they ask their agent to run `search_web` (deep mode). The agent synthesizes the key metrics from all sources in one response.

### Building a technical documentation chatbot
An engineer wants their AI assistant to answer questions about an API whose docs live on a specific, complex website. They use `fetch_url` on the main documentation page. The agent then grounds its answers using only that clean, extracted text.

### Verifying competitor claims
A market researcher needs to know if a competitor's claim about 'AI adoption rates in 2024' is accurate. They run `search_web` and ask the agent to cite its findings from diverse sources, getting multiple data points for comparison.

### Generating content based on external reports
A writer needs a summary of an academic paper found online. They use `fetch_url` on the PDF's source page. The agent extracts the core text, allowing the writer to generate accurate summaries without manual copy-pasting.

## Benefits

- Real-time answers are standard. Don't let your agent hallucinate dates or prices. Use `search_web` to pull fresh facts from the moment of query execution.
- Clean content extraction is automatic. When you run `fetch_url`, the system strips away navigation and ads, giving your AI pure text ready for RAG indexing.
- Search depth matters. Need a quick answer? Use 'fast' mode in `search_web`. Need to write a literature review? Switch to 'deep' mode for thorough sourcing.
- Structured data beats messy scraping. Both tools provide source URLs and titles, letting your agent know *where* the information came from.
- It works with what you already use. Connect Linkup to Claude, Cursor, or any MCP client to keep your workflow consistent.

## How It Works

The bottom line is: you give your AI an API key, and it gets live internet access for its responses.

1. Subscribe to this server and enter your Linkup API Key.
2. Your AI client sends a request, specifying whether it needs general facts (`search_web`) or content from one URL (`fetch_url`).
3. The server executes the tool call, retrieving real-time web data and passing clean context back to your agent.

## Frequently Asked Questions

**How does Linkup (AI Search & RAG) handle private or gated content?**
It cannot access content behind paywalls or requiring specific logins. It operates by scraping publicly available web pages, so the source must be indexed and viewable online.

**Is `fetch_url` better than general web search for documentation?**
Yes. If you have a direct URL to technical docs, use `fetch_url`. It guarantees clean text extraction from that single source, which is more reliable than synthesizing answers from multiple search snippets.

**What's the difference between 'fast' and 'deep' in search_web?**
Fast mode is for quick fact-checking on common topics. Deep mode performs a much broader, more thorough crawl across diverse sources, which you need for comprehensive research.

**Does Linkup (AI Search & RAG) only work with certain AI clients?**
No. As an MCP server, it connects to any compatible client that speaks the Model Context Protocol, including Cursor, Claude Desktop, and VS Code Copilot.

**When running `fetch_url`, what kind of API credentials do I need to pass?**
You must provide a valid Linkup API Key for authentication. This key authorizes your AI agent to run the complex web scraping processes through our platform. It's the single credential that allows your client (like Claude or Cursor) to execute the extraction.

**Does `search_web` output structured data, making it ready for a vector store?**
Yes, `search_web` retrieves more than just text. It delivers structured payloads that include titles, descriptive snippets, and source URLs. This format is specifically designed for seamless ingestion into vector databases.

**How does `fetch_url` handle modern Single Page Applications (SPAs) with complex JavaScript?**
It bypasses advanced bot protections by automatically executing complicated SPA JavaScript loops. This means the tool renders dynamic content that standard scraping methods often miss, ensuring you get clean text regardless of the site's complexity.

**Can I combine `search_web` and `fetch_url` in a single workflow?**
Absolutely. You first run `search_web` to identify high-relevance source URLs. Then, you pass the specific URL found during search directly into `fetch_url` for deep content extraction from that precise location.

**How can Linkup help my agent provide more up-to-date answers?**
Use the `linkup_search` tool to give your agent access to live web data. By performing semantic searches across the internet, your agent can retrieve the latest news, reports, and documentation, grounding its answers in current facts.

**Can I extract clean text from a specific URL for RAG?**
Yes. The `linkup_fetch` tool is specifically designed for content extraction. It renders the target page and returns a clean text version stripped of navigation and ads, making it ideal for feeding high-quality context to your agent.

**What is the difference between standard and deep search modes?**
Standard search focuses on rapid fact-finding and top results. Deep search performs a more comprehensive crawl across many more sources, which is better for complex research tasks that require diverse perspectives and detailed data.