Katana Manufacturing ERP MCP server
Commit Nov 13, 2026Lets an AI client interact with Katana Manufacturing ERP to search, modify, fulfill, and verify manufacturing data.
Also known as dougborg/katana-openapi-client
- Stars
- 3
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 13, 2026
- License
- MIT
What is Katana Manufacturing ERP MCP?
Katana Manufacturing ERP lets an AI client interact with Katana Manufacturing ERP to search, modify, fulfill, and verify manufacturing data.
Summary generated from the project's README
About Katana Manufacturing ERP MCP server
This ecosystem provides developers with tools to connect AI assistants to the Katana Manufacturing ERP. It includes a dedicated MCP server designed for integration with clients like Claude and Cursor, alongside full-featured Python and TypeScript SDKs. The MCP server offers a curated set of high-level tools that allow an AI to search, modify, fulfill, and verify manufacturing data directly through the model context protocol.
Users can set up the server locally by configuring a KATANA_API_KEY in their Claude Desktop configuration. The system handles complex API requirements automatically, including rate limiting, pagination, and request retries. While the Python and TypeScript clients provide access to every operation defined in the OpenAPI specification, the MCP server focuses on providing a streamlined tool surface for intelligent automation. It also features a SQLite-backed typed cache to manage state efficiently.
What you can do with it
- 1Manage manufacturing data via AIAn AI assistant can search for, modify, or fulfill manufacturing orders using high-level tools.
- 2Automate ERP workflows with PythonDevelopers can use the Python client to programmatically retrieve all products from the Katana API.
- 3Integrate Katana into web applicationsThe TypeScript client allows for type-safe interactions with the ERP within JavaScript or TypeScript environments.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
KATANA_API_KEYKATANA_BASE_URL
| Name | Description | |
|---|---|---|
| KATANA_API_KEY | — | |
| KATANA_BASE_URL | — |
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachabledougborg/katana-openapi-client is public and reachablegithub.com/dougborg/katana-openapi-client ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-09github.com/dougborg/katana-openapi-client ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubKatana Manufacturing ERP - API Ecosystem
Multi-language client ecosystem for the Katana Manufacturing ERP API. Production-ready clients with automatic resilience, rate limiting, and pagination.
Packages
| Package | Language | Version | Description |
|---|---|---|---|
| katana-openapi-client | Python | Full-featured API client with transport-layer resilience | |
| katana-mcp-server | Python | Model Context Protocol server for AI assistants | |
| katana-openapi-client | TypeScript | TypeScript/JavaScript client with full type safety |
Features Comparison
| Feature | Python Client | TypeScript Client | MCP Server |
|---|---|---|---|
| Automatic retries | Yes | Yes | Yes (via Python client) |
| Rate limit handling | Yes | Yes | Yes |
| Auto-pagination | Yes | Yes | Yes |
| Type safety | Full (Pydantic) | Full (TypeScript) | Full (Pydantic) |
| Sync + Async | Yes | Async only | Async only |
| Browser support | No | Yes | No |
| AI Integration | - | - | Claude, Cursor, etc. |
Quick Start
Python Client
pip install katana-openapi-client
import asyncio
from katana_public_api_client import KatanaClient
from katana_public_api_client.api.product import get_all_products
async def main():
async with KatanaClient() as client:
response = await get_all_products.asyncio_detailed(client=client)
products = response.parsed.data
print(f"Found {len(products)} products")
asyncio.run(main())
TypeScript Client
npm install katana-openapi-client
import { KatanaClient } from 'katana-openapi-client';
const client = await KatanaClient.create();
const response = await client.get('/products');
const { data } = await response.json();
console.log(`Found ${data.length} products`);
MCP Server (Claude Desktop)
pip install katana-mcp-server
Add to Claude Desktop config
(~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"katana": {
"command": "uvx",
"args": ["katana-mcp-server"],
"env": {
"KATANA_API_KEY": "your-api-key-here"
}
}
}
}
Configuration
All packages support the same authentication methods:
- Environment variable:
KATANA_API_KEY .envfile: Create withKATANA_API_KEY=your-key- Direct parameter: Pass
api_keyto client constructor
# .env file
KATANA_API_KEY=your-api-key-here
KATANA_BASE_URL=https://api.katanamrp.com/v1 # Optional
API Coverage
All clients provide access to the complete Katana API. The canonical endpoint surface is
the OpenAPI spec at docs/katana-openapi.yaml; the Python
and TypeScript clients are generated from it, and the MCP server wraps a curated subset
of high-level tools on top of the Python client.
- Python / TypeScript clients — every operation in the spec, with generated types for all request and response models.
- MCP server — a higher-level tool surface (search, modify, fulfill, verify, plus
preview/apply pairs for write operations); the live tool list is exposed via the
katana://help/toolsresource.
Project Structure
katana-openapi-client/ # Monorepo root
├── pyproject.toml # Workspace configuration (uv)
├── uv.lock # Unified lock file
├── docs/
│ ├── katana-openapi.yaml # OpenAPI 3.1.0 specification
│ ├── adr/ # Shared architecture decisions
│ └── *.md # Shared documentation
├── katana_public_api_client/ # Python client package
│ ├── katana_client.py # Resilient client with retries
│ ├── api/ # Generated API modules
│ ├── models/ # Generated data models
│ ├── models_pydantic/ # Generated pydantic models
│ └── docs/ # Package documentation
├── katana_mcp_server/ # MCP server package
│ ├── src/katana_mcp/
│ │ ├── server.py # FastMCP server
│ │ ├── tools/ # MCP tools
│ │ ├── resources/ # MCP resources
│ │ └── typed_cache/ # SQLite-backed typed cache
│ └── docs/ # Package documentation
└── packages/
└── katana-client/ # TypeScript client package
├── src/
│ ├── client.ts # Resilient client
│ └── generated/ # Generated SDK
└── docs/ # Package documentation
Documentation
Package Documentation
Each package has its own documentation in its docs/ directory:
- Python Client Guide — usage, response helpers, pagination, retries
- Python Client Cookbook — practical recipes
- OpenAPI Spec Authoring — 3.1 conventions, generator/regen lockstep, breaking-change markers
- MCP Server Architecture — MCP design patterns
- MCP Server Development — development workflow
- MCP Prefab UI — card builders and renderer pitfalls
- MCP Typed Cache — SQLite cache, FTS5, soft-state filtering
- TypeScript Client Guide — TypeScript usage
Architecture Decisions
Architecture Decision Records live under each package's docs/adr/ directory plus
shared monorepo ADRs under docs/adr/. Each ADR directory has a README.md index that
lists every ADR in that scope with its current status — those indexes are the canonical
list and stay current as ADRs are added or superseded.
- Shared / monorepo ADRs — cross-cutting decisions
- Python client ADRs — client package decisions
- MCP server ADRs — MCP package decisions
- TypeScript client ADRs — TS package decisions
Shared Documentation
- Contributing Guide — how to contribute
- uv Usage Guide — package manager guide
- Release Guide — release-please setup and release process
Development
Prerequisites
- Python 3.12+ for Python packages
- Node.js 18+ for TypeScript package
- uv package manager (install)
Setup
# Clone repository
git clone https://github.com/dougborg/katana-openapi-client.git
cd katana-openapi-client
# Install all dependencies
uv sync --all-extras
# Install pre-commit hooks
uv run pre-commit install
# Create .env file
cp .env.example .env # Add your KATANA_API_KEY
Common Commands
# Run all checks (lint, type-check, test)
uv run poe check
# Run tests
uv run poe test
# Format code
uv run poe format
# Regenerate Python client from OpenAPI spec
uv run poe regenerate-client
Commit Standards
Conventional commits drive per-package release-please versioning (bump type from the commit type; which package(s) bump from which paths the commit touches):
# Python client changes
git commit -m "feat(client): add new inventory helper"
git commit -m "fix(client): handle pagination edge case"
# MCP server changes
git commit -m "feat(mcp): add manufacturing order tools"
git commit -m "fix(mcp): improve error handling"
# Documentation only (no release)
git commit -m "docs: update README"
Use ! for breaking changes: feat(client)!: drop Python 3.11 support.
See RELEASE.md for details.
License
MIT License - see LICENSE for details.
Contributing
Contributions welcome! See CONTRIBUTING.md for guidelines.
Katana Manufacturing ERP MCP questions
How do I configure the MCP server for Claude Desktop?
You can add the server to your Claude Desktop config by installing the katana-mcp-server via pip and adding the command 'uvx' with the 'katana-mcp-server' argument and your KATANA_API_KEY in the environment section.
What kind of tools does the MCP server provide?
The MCP server provides a high-level tool surface including search, modify, fulfill, verify, and preview/apply pairs for write operations.