Knowledge Base

Practical Guide: MCP-powered RAG for Complex Documents

This guide provides a hands-on implementation for using the Model Context Protocol (MCP) to power a Retrieval-Augmented Generation (RAG) application over complex, real-world documents.

The Challenge: Complex Documents

Standard RAG pipelines often struggle with documents that contain a mix of text, tables, images, and complex layouts. Our target document for this example is a multi-format PDF:

Example of a complex document with text, tables, and diagrams

The Technology Stack

  • MCP Client: Cursor IDE
  • MCP Server & Document Processing: EyelevelAI’s GroundX for its enterprise-grade parsing and search capabilities.

How It Works

The workflow is designed for seamless interaction between the developer and the knowledge base:

GIF demonstrating the workflow from Cursor IDE to the MCP server and GroundX
  1. The user interacts with the MCP client (Cursor IDE).
  2. The client connects to the local MCP server and selects a tool (e.g., search_document).
  3. The selected tool leverages the GroundX API to perform an advanced, context-aware search over the ingested documents.
  4. The search results are returned to the client, which uses them to generate an accurate, grounded response.

Implementation Details

The complete source code for this demonstration is available in this GitHub repository.

1. Setup the MCP Server

First, we set up a local MCP server using FastMCP and give it a descriptive name.

Screenshot of setting up the FastMCP server

2. Create the GroundX Client

GroundX provides the core document intelligence. You will need to get an API key and store it in a .env file.

Once the key is available, the client is initialized as follows:

Screenshot of Python code to set up the GroundX client

3. Create an Ingestion Tool

This MCP tool allows users to add new documents to the GroundX knowledge base directly from the client by providing a local file path.

Screenshot of the Python code for the document ingestion tool

4. Create a Search Tool

This tool exposes GroundX’s advanced search and retrieval capabilities. It takes a user query and returns the most relevant chunks from the indexed documents.

Screenshot of the Python code for the document search tool

5. Start the Server

The server is started using standard input/output (stdio) as the transport mechanism, which is ideal for integration with local IDEs like Cursor.

Screenshot of the Python code to start the server

6. Connect to Cursor

Finally, configure Cursor to connect to your local MCP server: 1. Navigate to Cursor → Settings → Cursor Settings → MCP. 2. Add your server’s command and start it.

Screenshot of adding and starting the MCP server in Cursor’s settings

You can now interact with your complex documents directly through the Cursor IDE, leveraging the powerful parsing and retrieval from GroundX.

Why This Approach Excels

Services like GroundX are purpose-built for enterprise-grade document parsing. They can intuitively chunk relevant content and understand the semantic meaning of text, images, and diagrams, converting unstructured data into a structured JSON format that LLMs can easily process.

Diagram showing how GroundX parses unstructured data into structured JSON

📝 Context Summary

This document provides a step-by-step tutorial on implementing a Retrieval-Augmented Generation (RAG) system designed to work with complex, real-world documents containing text, tables, and images. It demonstrates how to use a Model Context Protocol (MCP) server with tools like GroundX for advanced parsing and Cursor IDE as the client for interaction.

Table of Contents

Knowledge Topics

Let’s Connect

Ready to Build Your Own Intelligence Engine?

If you’re ready to move from theory to implementation and build a Knowledge Core for your own business, I can help you design the engine to power it. Let’s discuss how these principles can be applied to your unique challenges and goals.