TallyPrime MCP Server

Talk to your TallyPrime accounting data using plain English — powered by Claude AI.

What is this?

If you've ever used TallyPrime, you know the drill — open the app, navigate through menus, set date ranges, find the right report, and read through dense numbers. It works, but it's not exactly conversational.

This project changes that.

TallyPrime MCP Server connects TallyPrime to Claude (Anthropic's AI assistant) using a protocol called MCP (Model Context Protocol). Once set up, you can simply ask Claude things like:

• "What are my outstanding receivables as of today?"

• "Create a sales invoice for ABC Traders for ₹50,000 with 18% GST"

• "Show me the P&L for FY 2025-26"

• "Which company is currently open in Tally?"

And Claude will fetch the answer directly from your TallyPrime data — no menu navigation needed.

Why do we need this?

TallyPrime is powerful, but it was designed for accountants who know exactly where every report lives. For everyone else — business owners, managers, founders — it can feel like a maze.

Here are the real problems this project solves:

Getting information is slow. To check outstanding receivables you need to open Tally, navigate to the right report, set the date, wait for it to load, and read through rows of numbers. With this project, you just ask. Claude fetches it in seconds.

You need to know Tally's language. Tally has its own terminology — voucher types, ledger groups, TDL reports. Most people just want answers, not a lesson in accounting software navigation.

Tally has no modern API. Unlike modern software, TallyPrime doesn't have a REST API or webhook system. It communicates over an old XML protocol called TDL. This project handles all of that complexity so you never have to think about it.

AI cannot access desktop software. Claude is a cloud-based AI — it has no way to open TallyPrime or read your data directly. This MCP server acts as the secure bridge between them.

Creating entries is repetitive. Typing the same kind of voucher every day — same ledgers, same format — is tedious. With this project you can describe the transaction in plain English and Claude creates it in Tally.

In short: this project removes the friction between your brain and your accounting data.

How it works

TallyPrime has a built-in Gateway Server that accepts XML requests on port 9000. This project acts as the bridge — it translates Claude's tool calls into the XML that TallyPrime understands, sends them, parses the response, and returns clean readable text back to Claude.

Architecture

┌─────────────────────────────────────────┐
│                  You                    │
│          (ask in plain English)         │
└──────────────────┬──────────────────────┘
                   │
       ┌───────────┴───────────┐
       │                       │
┌──────▼───────┐       ┌───────▼──────┐
│    Claude    │       │   Claude.ai  │
│   Desktop   │       │  (web/cloud) │
│ (stdio mode) │       │  (SSE mode)  │
└──────┬───────┘       └───────┬──────┘
       │    MCP Protocol       │
       └───────────┬───────────┘
                   │
┌──────────────────▼──────────────────────┐
│         TallyPrime MCP Server           │
│                                         │
│  ┌────────────┐   ┌─────────────────┐   │
│  │ server.py  │   │ server_http.py  │   │
│  │  (stdio)   │   │   (HTTP/SSE)    │   │
│  └─────┬──────┘   └────────┬────────┘   │
│        └─────────┬─────────┘            │
│                  │                      │
│      ┌───────────▼──────────────┐       │
│      │       17 MCP Tools       │       │
│      │  Company · Ledgers ·     │       │
│      │  Vouchers · Reports      │       │
│      └───────────┬──────────────┘       │
│                  │                      │
│   ┌──────────────┴──────────────┐       │
│   │                             │       │
│ ┌─▼────────────┐  ┌─────────────▼──┐   │
│ │tally_client  │  │  xml_builder   │   │
│ │ (HTTP calls) │  │ (TDL XML)      │   │
│ └──────────────┘  └────────────────┘   │
└──────────────────┬──────────────────────┘
                   │ XML over HTTP (port 9000)
        [Cloudflare Tunnel for cloud mode]
                   │
┌──────────────────▼──────────────────────┐
│        TallyPrime Gateway Server        │
│          (your Windows machine)         │
└──────────────────┬──────────────────────┘
                   │
┌──────────────────▼──────────────────────┐
│          Your accounting data           │
└─────────────────────────────────────────┘

Local mode (Claude Desktop): Everything runs on your machine. Claude Desktop launches the MCP server as a subprocess and communicates over stdio. Your Tally data never leaves your computer.

Cloud mode (Claude.ai): The MCP server runs on a cloud host. A Cloudflare Tunnel exposes your local TallyPrime to the internet securely so the cloud server can reach it.

Architecture Components Explained

Here is what each piece in the architecture diagram actually does and why it exists.

You

The starting point. You type a plain English question or instruction in Claude Desktop or Claude.ai. You don't need to know anything about XML, TDL, or how TallyPrime works internally.

Claude Desktop

Anthropic's official desktop app for Windows and Mac. It supports MCP servers — meaning it can launch local tools and connect to them. In this project, Claude Desktop reads claude_desktop_config.json and automatically starts the tallyprime-mcp server every time it opens. Communication happens over stdio (stdin/stdout) — completely local, no internet required.

Claude.ai (web)

The browser version of Claude at claude.ai. It can also connect to MCP servers, but only ones hosted on the internet. This is why the cloud mode requires a running HTTP server and a Cloudflare Tunnel.

server.py (stdio mode)

The entry point for Claude Desktop. When Claude Desktop launches tallyprime-mcp, this file is what runs. It uses FastMCP's stdio transport to read tool calls from Claude and send responses back. Think of it as the local receptionist — it receives Claude's requests and routes them to the right tool.

server_http.py (HTTP/SSE mode)

The entry point for Claude.ai cloud. It runs a lightweight web server using uvicorn and starlette, exposing three endpoints — /health, /sse, and /messages. Claude.ai connects via SSE (Server-Sent Events) — a persistent HTTP connection that stays open while Claude is working.

17 MCP Tools

Each tool is a Python function that Claude can call by name. Claude reads the tool's description and decides on its own when to use it and what parameters to pass. The tools are organized into four files — company.py, ledgers.py, vouchers.py, and reports.py. Every tool catches errors gracefully and returns a clean text response to Claude.

tally_client.py

The async HTTP client that actually talks to TallyPrime. It sends XML requests to http://localhost:9000, reads the response, and parses it into Python dictionaries. It also handles all the error scenarios — connection failures, timeouts, malformed XML, and TallyPrime error responses.

xml_builder.py

A library of functions that build TDL (Tally Definition Language) XML strings. TallyPrime only understands XML in a very specific format — this file knows all those formats so the rest of the code doesn't have to. Every Tally operation (get ledgers, create voucher, fetch report) has its own XML builder function here.

Cloudflare Tunnel

Only needed for cloud mode. TallyPrime runs on your local Windows machine behind a firewall — the internet can't reach it directly. Cloudflare Tunnel creates a secure outbound connection from your machine to Cloudflare's network, giving you a public URL (like https://xyz.trycloudflare.com) that forwards traffic to your local port 9000. Free to use, no account required for temporary tunnels.

TallyPrime Gateway Server

TallyPrime's built-in server that listens on port 9000. You enable it via F12 → Advanced Configuration → Enable ODBC Server. It accepts XML requests and responds with XML data from your active company. This is the only part of the architecture that Tally itself provides — everything else in this repo is built around it.

Your accounting data

The ledgers, vouchers, and reports stored in TallyPrime's database on your machine. This is what everything in this project is ultimately trying to make accessible through natural language.

The 17 MCP Tools

This project registers 17 tools that Claude can call. Each tool is a Python function with a name, description, and input parameters. Claude reads the descriptions and decides on its own which tool to use based on what you ask.

Company (1 tool)

Ledgers & Groups (4 tools)

Vouchers (6 tools)

Reports (6 tools)

Example prompts for each category

Company:
  "Which company is currently open in Tally?"

Ledgers:
  "Show me all ledgers"
  "Get details for ABC Traders ledger"
  "Create a ledger called XYZ Suppliers under Sundry Creditors"

Vouchers:
  "Show all sales vouchers for April 2025"
  "Create a sales invoice for ABC Traders for ₹50,000 + 18% GST dated today"
  "Record a payment of ₹15,000 from HDFC Bank to Office Rent"
  "Pass a journal entry: debit Depreciation, credit Machinery, ₹10,000"

Reports:
  "Get the P&L for FY 2025-26"
  "Show balance sheet as of 31 March 2026"
  "What are my outstanding receivables as of today?"
  "Show day book for last week"

What can it do?

Company

Ledgers & Groups

Vouchers

Reports

Project Structure

tallyprime-mcp/
├── src/
│   └── tallyprime_mcp/
│       ├── config.py           # Reads settings from .env file
│       ├── server.py           # Runs in Claude Desktop (stdio mode)
│       ├── server_http.py      # Runs in cloud for Claude.ai (HTTP/SSE mode)
│       ├── tally_client.py     # Talks to TallyPrime via XML over HTTP
│       ├── xml_builder.py      # Builds the XML requests TallyPrime understands
│       └── tools/
│           ├── company.py      # get_active_company
│           ├── ledgers.py      # ledger and group tools
│           ├── vouchers.py     # voucher read and create tools
│           └── reports.py      # financial report tools
├── .env.example                # Template for your configuration
├── .gitignore                  # Keeps .env and cache out of git
├── Dockerfile                  # For cloud deployment
├── pyproject.toml              # Package config and dependencies
└── README.md                   # This file

Requirements

• Python 3.11 or higher (tested on Python 3.14)

• TallyPrime 3.x or later running on Windows

• Claude Desktop (for local use) or a cloud server (for Claude.ai)

Installation

Step 1 — Clone the repo

git clone https://github.com/svharivinod/tallyprime-mcp
cd tallyprime-mcp

Step 2 — Install dependencies

pip install -e .

This installs everything: mcp, httpx, uvicorn, starlette, python-dotenv.

Step 3 — Create your .env file

copy .env.example .env   # Windows
cp .env.example .env     # Mac/Linux

Open .env and set your Tally URL:

TALLY_URL=http://localhost:9000
TALLY_TIMEOUT=30

TallyPrime Setup

TallyPrime needs its Gateway Server switched on before this project can talk to it.

1. Open TallyPrime

2. Press F12 → click Advanced Configuration

3. Set Enable ODBC Server → Yes

4. Confirm Port is 9000

5. Press Enter to save

To verify it's working, run:

python -c "import httpx; r = httpx.get('http://localhost:9000'); print(r.text)"

You should see: <RESPONSE>TallyPrime Server is Running</RESPONSE>

Connecting to Claude Desktop

Claude Desktop is Anthropic's desktop app that supports MCP servers. Download it from: https://claude.ai/download

Step 1 — Find or create the config file

• Windows: %APPDATA%\Claude\claude_desktop_config.json

• Mac: ~/Library/Application Support/Claude/claude_desktop_config.json

Step 2 — Add this configuration

{
  "mcpServers": {
    "tallyprime": {
      "command": "C:\\Users\\YOUR_USERNAME\\AppData\\Local\\Programs\\Python\\Python314\\Scripts\\tallyprime-mcp.exe",
      "env": {
        "TALLY_URL": "http://localhost:9000"
      }
    }
  }
}

To find the exact path of tallyprime-mcp.exe on your machine, run:

where.exe tallyprime-mcp

Step 3 — Restart Claude Desktop

Fully quit Claude Desktop (right-click system tray → Quit) and reopen it.

Step 4 — Verify

Click the + button in the chat input → Connectors → you should see tallyprime listed with a blue toggle.

Connecting to Claude.ai (Cloud Mode)

For Claude.ai to reach TallyPrime (which runs locally on Windows), you need to:

1. Expose TallyPrime via a tunnel

2. Run this server in HTTP/SSE mode

3. Connect Claude.ai to your server URL

Step 1 — Create a tunnel with Cloudflare

Install cloudflared from: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/

Then run on your Windows machine:

cloudflared tunnel --url http://localhost:9000

You'll get a URL like https://random-name.trycloudflare.com. Copy it.

Step 2 — Update your .env

TALLY_URL=https://random-name.trycloudflare.com
MCP_API_KEY=your-strong-random-secret
MCP_PORT=8000

Step 3 — Start the HTTP server

tallyprime-mcp-http

Step 4 — Connect Claude.ai

Go to Claude.ai → Settings → Integrations → Add MCP Server:

URL:   https://your-server-domain.com/sse
Token: your-strong-random-secret

Environment Variables

Date Format

All dates use YYYYMMDD format. Examples:

Known Issues and How We Solved Them

Building this wasn't completely straightforward. Here's what we ran into and how we fixed it — so you know what to do if you hit the same things.

TallyPrime returns invalid XML characters

Tally's XML responses sometimes contain control characters that Python's XML parser rejects. We solved this by cleaning the response with a regex before parsing:

clean = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f]', '', xml_text)

"List of Companies" report doesn't exist in TallyPrime

The List of Companies report name returns an error in TallyPrime. Instead, we use the List of Accounts request which includes SVCURRENTCOMPANY in its response headers — and extract the company name from there using regex.

Python 3.14 asyncio compatibility

Python 3.14 removed asyncio.get_event_loop() in the main thread. We fixed this by letting FastMCP handle its own event loop instead of setting one up manually.

Claude Desktop needs full path to the executable

Claude Desktop doesn't always inherit Windows PATH. Using just "command": "tallyprime-mcp" sometimes fails. The fix is to use the full path:

C:\\Users\\username\\AppData\\Local\\Programs\\Python\\Python314\\Scripts\\tallyprime-mcp.exe

Run where.exe tallyprime-mcp in PowerShell to find yours.

TallyClient context manager error

The MCP tools were failing with "Use TallyClient as an async context manager". We fixed send_xml() to create a temporary httpx client when called without a context manager, so tools work in both modes.

pip install -e . fails when Claude Desktop is running

Windows locks the .exe file when it's in use. The fix: kill Claude Desktop first with taskkill /F /IM "Claude.exe", then reinstall.

Cloud Deployment

Docker

docker build -t tallyprime-mcp .
docker run -d -p 8000:8000 \
  -e TALLY_URL=https://your-tunnel.trycloudflare.com \
  -e MCP_API_KEY=your-secret \
  tallyprime-mcp

Railway (easiest)

1. Push this repo to GitHub

2. Go to railway.app → New Project → Deploy from GitHub

3. Add environment variables: TALLY_URL, MCP_API_KEY

4. Railway auto-detects the Dockerfile and deploys

Security Notes

• Never commit your .env file — it's already in .gitignore

• Always set a strong MCP_API_KEY when running in cloud mode

• The .env.example file is safe to commit — it has no real values

• Your TallyPrime data never leaves your network in local/stdio mode

Tech Stack

License

MIT — free to use, modify and distribute.