Use AI to Read & Write Excel Files, without leaking sensitive business data

In a previous guide, we walked through how to give a locally-running AI full access to your filesystem and PDFs — all without sending anything to a commercial AI cloud service like ChatGPT or Claude. If you haven’t read that yet, it’s worth starting there, since this guide builds directly on that foundation.

Today we’re going a step further. We’re going to connect your local AI to Excel spreadsheets — so it can read data, write new sheets, build reports, and reason across your workbooks — and also give it the ability to read Word documents, PowerPoint presentations, and OpenDocument files from LibreOffice. All of it running on your own machine, with no data leaving your network.

The tools we’ll use are free, open-source, and take about ten minutes to set up. One of them is even published by Microsoft itself.

What you’ll install, and why two tools instead of one

If you search for an AI tool that reads Excel files, writes formulas, handles Word documents, and understands PowerPoint slides all in one package — you won’t find it. That’s not how this ecosystem works. Instead, you combine small, focused tools that each do one thing really well. That’s actually a strength, not a limitation, because each component is actively maintained by people who care specifically about that format.

Here’s what we’re installing and what each one brings:

The short version: use excel-mcp-server when you want the AI to actually work inside a spreadsheet — reading values, writing data, creating sheets, building formulas. Use markitdown-mcp when you want to read the contents of any Office or document file and reason about it — even if you just need to pull the text out of a Word contract or a PowerPoint deck.

Prerequisites

Before we start, make sure you have:

• LM Studio installed and running with at least one model loaded. If you haven’t set this up yet, the previous guide covers it from scratch.
• Python 3.10 or later. Open a terminal ( Win + R → type cmd → Enter) and run python --version to check. If it’s not installed, download it from python.org — make sure to tick “Add Python to PATH” during installation.
• Node.js — needed for the previous guide’s tools, likely already installed. Run node --version to confirm.

That’s it. No Microsoft Excel license required. No Office subscription. These tools work entirely independently of any installed Office software.

1. Install uv — the Python package runner

Both MCP servers we’re installing are Python-based, and they run best through a tool called uv. If you’ve used npx for Node.js packages, uv is the same idea for Python — it downloads and runs packages on demand, keeps everything isolated, and avoids the usual headaches of Python environment management.

To install uv on Windows, open a terminal and run:

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

Close and reopen your terminal after installation, then verify it worked:

uvx --version

You should see a version number. If the command isn’t found, you may need to add uv’s install directory to your PATH — it installs to C:\Users\YourName\.local\bin\ by default, and Windows will tell you during installation if a PATH update is needed.

Tip: uv is significantly faster than pip and handles dependency conflicts automatically. Once you’ve used it, you’ll probably never go back to plain pip for running tools.

2. Add the Excel MCP server to LM Studio

The excel-mcp-server is a Python package with over 3,500 GitHub stars that gives your AI full read/write access to Excel workbooks. It supports everything you’d expect — reading cell values and formulas, writing data, creating new sheets, building charts, setting up pivot tables, applying conditional formatting, and managing named tables. No Excel installation required; it uses the openpyxl library under the hood.

Open your LM Studio MCP configuration file. On Windows it lives at:

C:\Users\YourName\.lmstudio\mcp.json

Replace YourName with your actual Windows username. Open it in any text editor (Notepad works fine, though VS Code or Notepad++ will give you JSON syntax highlighting). You’ll see an existing mcpServers block. Add the following entry inside it, alongside any servers you already have:

"excel": {
"command": "C:\\Users\\YourName\\.local\\bin\\uvx.exe",
"args": ["excel-mcp-server", "stdio"]
}

Important — backslashes in JSON: In JSON files, every backslash in a Windows path must be written as two backslashes ( \\ ). A single backslash will cause a parse error and the server won’t load. So C:\Users\ becomes C:\\Users\\ . Double-check this, especially if you paste the path from Windows Explorer.

To find the exact path to your uvx.exe , open a terminal and run:

where uvx

It will print something like C:\Users\YourName\.local\bin\uvx.exe . Use that exact path, with the double backslashes, in your config.

Your mcp.json should now look something like this (other entries trimmed for clarity):

{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "C:\\", "E:\\"]
},
"excel": {
"command": "C:\\Users\\YourName\\.local\\bin\\uvx.exe",
"args": ["excel-mcp-server", "stdio"]
}
}
}

3. Add the MarkItDown MCP server

markitdown-mcp is an official Microsoft open-source project. Its job is deceptively simple: take any document file and convert it to clean Markdown text. That sounds modest until you look at the format list. It handles DOCX, PPTX, XLSX, XLS, PDF, HTML, CSV, XML, images (with OCR), audio files (with speech transcription), ZIP archives, EPubs, and even YouTube URLs. As long as there’s text in the file, MarkItDown will pull it out.

For AI document work, this is enormously useful. You can ask your local model to summarise a Word contract, extract the action items from a PowerPoint slide deck, compare two versions of a report, or answer questions about any document in your archive — all without those files ever leaving your machine.

Add it to the same mcp.json file, inside mcpServers :

"markitdown": {
"command": "C:\\Users\\YourName\\.local\\bin\\uvx.exe",
"args": ["markitdown-mcp"]
}

When calling this tool, you’ll reference files using the file:/// URI format. For example, to read a Word document at E:\Documents\contract.docx , you’d pass:

file:///E:/Documents/contract.docx

Notice the forward slashes here — that’s the URI standard, not Windows path notation. The tool handles the conversion internally, so you just need to use that format when pointing it at a file.

Tip: If you also set up the filesystem MCP from the previous guide, you can ask the AI to find a file first using the filesystem tool, then pass that path to markitdown to read it. Combining tools this way is where local AI really starts to feel powerful.

After adding both entries, your complete mcpServers block should look similar to this:

{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "C:\\", "E:\\"]
},
"excel": {
"command": "C:\\Users\\YourName\\.local\\bin\\uvx.exe",
"args": ["excel-mcp-server", "stdio"]
},
"markitdown": {
"command": "C:\\Users\\YourName\\.local\\bin\\uvx.exe",
"args": ["markitdown-mcp"]
}
}
}

Save the file.

4. Restart LM Studio and verify

Fully close LM Studio and reopen it — a regular reload isn’t always enough for MCP config changes to take effect. Once it’s back up, start a new chat and look for the MCP tools indicator, usually a wrench icon or a tool count shown near the input field. If you see excel and markitdown listed, the servers connected successfully.

Try a quick test. Ask your model something like:

Create a new Excel file at C:\Users\YourName\Desktop\test.xlsx with a sheet called "Summary" and three columns: Date, Item, and Amount.
Add three example rows of data.

If it works, you’ll find the file on your Desktop when the AI confirms it’s done. Open it in Excel or LibreOffice to verify the contents — you should see a properly formatted spreadsheet, created entirely by your local AI without any cloud involvement.

For MarkItDown, try:

Read the file at file:///C:/Users/YourName/Documents/some-report.docx and give me a two-paragraph summary.

Swap in any actual document path you have. If the server is working, you’ll get a summary based on the real contents of that file.

What you can actually do with this

Once these tools are running, a few use cases become immediately practical that weren’t possible before with a local model.

Spreadsheet analysis and reporting

Point the AI at a workbook and ask it to summarise trends, flag anomalies, calculate totals across sheets, or generate a monthly report sheet from raw data. Because excel-mcp-server gives the AI write access, it doesn’t just describe what it would do — it actually does it. You ask for a pivot table, it builds one.

Contract and document review

Drop a folder of Word documents — supplier contracts, service agreements, HR policies — and ask the AI to extract key terms, compare clauses, or flag anything that differs from a standard template. With MarkItDown handling the text extraction, the AI works from the actual document content rather than a summary you typed out.

Cross-format data extraction

Many businesses have data trapped in old formats — XLS files from the early 2000s, ODT reports from LibreOffice, PPT presentations that contain financial tables, PDF exports from accounting software. MarkItDown handles all of these. You can ask the AI to find values across a dozen different file types and consolidate them into a single clean spreadsheet, without opening a single file yourself.

Automated document generation

Give the AI a dataset and ask it to produce a formatted Excel report — with headers, styled columns, summary rows, and conditional formatting to highlight outliers. excel-mcp-server supports all of this, and you can describe the output in plain language without writing a single line of Python or VBA.

Why this matters for business document workflows

Most companies run their operations on spreadsheets and Office documents. Budgets, project plans, client records, inventory lists, HR files, board reports — it’s all living in XLSX and DOCX files on shared drives or local machines. And most of that data never gets properly analysed because it would take too long to do manually, and uploading it to a commercial AI service is either off-limits by policy, uncomfortable for compliance reasons, or simply inadvisable when the data is sensitive.

The setup in this guide turns that situation on its head. Your AI lives where your data already lives — on your own hardware — and it can work across your entire document library without ever touching an external server.

For small and medium businesses, this is a genuine productivity shift. A business owner can ask their local AI to go through last year’s invoices, summarise payment patterns, and produce an Excel summary — a task that might take an admin a day — and get it done in minutes. An operations manager can have the AI review a stack of supplier contracts and flag any that include auto-renewal clauses. A financial analyst can have it consolidate data from a dozen regional spreadsheets into a single consolidated view.

None of this requires a cloud subscription, an API key, or a data processing agreement. The documents stay exactly where they already are, and the AI works with them directly.

For businesses in regulated sectors — healthcare, finance, legal, public services — this isn’t just a convenience. It’s often the only way to use AI on production data at all, without triggering compliance concerns. GDPR, NDA obligations, sector-specific data handling rules, and straightforward competitive sensitivity all point in the same direction: the AI needs to come to the data, not the other way around.

Taking it further with custom AI

The two-tool setup in this guide is a solid foundation that works well out of the box. But if you’re thinking about applying this kind of capability at a business level — across a team, integrated with your existing systems, with proper access controls and reliable performance — there’s considerably more to architect.

Choosing the right local model matters, because some are substantially better at structured data tasks than others. Setting up a retrieval layer means the AI can answer questions across hundreds of spreadsheets and documents at once, not just the one you’re currently pointing it at. And connecting these tools to your actual business workflows — your CRM, your ERP, your project management system — is where the real efficiency gains happen.

These are the kinds of custom AI deployments we design and build at Shambix.

If you’re a developer, this guide gives you everything you need to keep going on your own. If you represent a business that’s looking at this and thinking about what a production-grade version might look like — one that’s reliable, secure, and actually integrated into how your team works — we’d welcome a conversation.

Private & Compliant AI for your Business
without leaking sensitive documents

At Shambix, we design and deploy custom AI systems that run entirely on your own infrastructure. Document intelligence, knowledge bases, agent workflows, compliance-ready — built around your data, your rules, and your existing systems.

No data leaving your network. Privacy compliant.

Explore our AI services

or email info@shambix.com

Please enable JavaScript in your browser to complete this form.

Name *

First

Last

Name Privacy budget

Email *

Message

Project budget— Budget range (optional) —Under 5.000 €MediumLargeNot sure yet

We work with flexible budgets, and welcome all kinds of projects, small to massive. It helps us tailor the best solution to your specific needs.

Privacy Consent *

• I have read the Privacy Policy and I consent to having Shambix store my submitted information so they can respond to my inquiry. *

Submit