How to Give Claude Access to Your Company Documents

You can give Claude access to your company documents in four main ways: attach files to a conversation, group them in a project, connect a knowledge base through an MCP server, or call a knowledge-base API from your own tools. Uploads are fastest for a one-off question; an MCP-connected knowledge base is better when many people, many documents or many tools are involved. This guide walks through each option step by step, with the privacy trade-offs a US company should weigh before choosing.

The four options at a glance

Before going into the steps, it helps to see what each approach really does. The key difference is where your documents live and how Claude finds the relevant part: either the whole file is placed in the conversation, or a search system retrieves a few passages at question time.

Option 1: upload files directly into a conversation

The simplest way to give Claude access to files is to attach them to a message. You drop in a PDF policy or a Word contract, then ask your question. Claude reads the content as part of the conversation and can quote it back to you.

1. Open a new conversation in the Claude app.
2. Attach the file (PDF, Word, text and similar formats are commonly supported; check the official documentation for the current list and size limits for your plan).
3. Ask a precise question and request quotes: "Answer only from the attached handbook and quote the section you rely on."
4. Verify the quoted passages against the original before acting on them.

This works well for a single document you need to understand right now. It scales badly: every new conversation needs the files again, long documents consume much of the context window, and a colleague asking the same question next week has to repeat the whole process with possibly a different version of the file.

Option 2: use projects for a stable set of reference files

Depending on your offer, the Claude app lets you group conversations into projects with shared instructions and files. You add your reference material once, and every conversation in that project can use it. For a small team working on one client or one product, this is a real step up from repeated uploads.

Keep a few limits in mind. Storage, sharing with teammates and administrative controls vary by plan, so read the official documentation for your subscription rather than assuming. Projects also live inside one application: the same documents are not automatically available to Cursor, to an internal chatbot or to a script your operations team runs. And when a document changes, someone has to remember to replace it in every project that holds a copy.

Option 3: connect a knowledge base to Claude with MCP

The Model Context Protocol (MCP) is an open standard that lets an AI assistant call external tools. Instead of pasting documents into the chat, you connect Claude to a knowledge base that searches your corpus and returns only the relevant passages, with their sources. The documents stay in one place, and every MCP client (Claude, Cursor, ChatGPT and others) can query the same, current version.

Here is the exact procedure with Kopik, where a private base acts as your company's own retrieval backend.

1. Create a private base. Upload your PDFs, Word files, text or Markdown documents. Kopik extracts the text, splits it into passages and indexes it for hybrid search (full-text search plus semantic expansion of the keywords). Creating a base is free.
2. Create an API key in your dashboard. It starts with `kpk_` and is sent in the `Authorization: Bearer kpk_…` header.
3. Pick the URL. `https://kopik.io/api/mcp` exposes the whole catalog; `https://kopik.io/api/mcp?base=<slug>` targets a single base (each base page shows its own URL, and it works for private bases with your key).
4. Add the server to your client (commands below).
5. Ask a question and check the numbered source passages in the answer.

Claude Code

In a terminal, run: `claude mcp add --transport http kopik https://kopik.io/api/mcp --header "Authorization: Bearer kpk_…"`. If you use the single-base URL, keep quotes around it because zsh treats the `?` as a special character: `"https://kopik.io/api/mcp?base=<slug>"`.

Cursor and other MCP clients

Clients that read an `mcpServers` file (for Cursor, `.cursor/mcp.json`) take this block: `{ "mcpServers": { "kopik": { "url": "https://kopik.io/api/mcp", "headers": { "Authorization": "Bearer kpk_…" } } } }`. The server uses the stateless Streamable HTTP transport. For the Claude desktop and web apps, the way to add a remote MCP server depends on your plan and changes over time, so follow the official help pages.

Once connected, Claude sees three tools: `list_bases` (free, lists public bases, works without a key), `ask_base` (a written answer plus numbered source passages) and `search_base` (passages only, same price). On a single-base URL, the `base` argument is omitted. An optional `maxPriceCents` makes the call fail at no charge if a base costs more than you allow. Content coming back from a base is wrapped in `<kopik-untrusted>` tags, which helps the assistant treat it as data rather than instructions. The full walkthrough is in connecting a knowledge base to AI agents with MCP.

Option 4: call a knowledge-base API from your own tools

If the answers must appear somewhere other than a chat window (a support desk, an intranet page, a Slack bot, a nightly script), a REST API is the right layer. The same private base can be queried with the same `kpk_` key, so the internal bot and Claude read exactly the same documents. Questions to your own bases are free within reasonable use (200 a day); general limits are 20 questions per minute and 1,000 per day per user. The endpoints are documented on the developer page, and our guide on using a private knowledge base as RAG for AI agents shows typical setups.

Privacy and security trade-offs

Every option sends some document content to an AI service. The question is how much, to whom, and under which agreement. Run through this list with your security or compliance lead before rolling anything out:

• What leaves your perimeter. An upload sends the whole file; retrieval over MCP or an API sends only the passages relevant to each question. Less data in each prompt means less exposure.
• Regulated data. Protected health information under HIPAA, consumer data covered by state privacy laws such as the CCPA, or client material under NDA may require a signed agreement with every vendor involved. Check before uploading, not after.
• Vendor assurances. Ask each provider for its data retention and training policies, and for security reports such as SOC 2 where relevant. Plan settings and enterprise agreements often differ from consumer terms.
• Access control. Who can see which documents? A private base is visible only to its owner and their API keys; treat those keys like passwords, store them in a secrets manager and rotate them when someone leaves.
• Prompt injection. A document can contain text that tries to steer the assistant. Separate retrieved content from instructions (Kopik's untrusted tags do this) and keep a human in the loop for actions with consequences.
• Version control. Outdated copies scattered across chats and projects are a compliance risk in themselves. One maintained source is easier to audit.

When a hosted knowledge base beats file uploads

Uploads remain perfectly fine for occasional, personal questions. A hosted knowledge base becomes the better choice as soon as one of these is true:

• The corpus is larger than what fits comfortably in a conversation, or grows every month.
• Several people or teams ask questions about the same documents.
• You use more than one assistant or tool (Claude, Cursor, an internal bot) and want them all to read one source of truth.
• Answers must cite the exact passage so someone can check them.
• Documents change and stale copies would cause real mistakes.
• You want the same answers available from the website, the API and MCP.

A practical path is to start with uploads to test whether your documents answer the questions people actually ask, then move the corpus into a private base once the use case is proven. Nothing is lost: the same files are simply indexed once and served to every tool.