erpnext-mcp 0.1.0__py3-none-any.whl

erpnext_mcp/client.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+import json
+from typing import Any
+
+import httpx
+
+
+class ERPNextClient:
+    def __init__(self, url: str, api_key: str, api_secret: str):
+        self.base_url = url.rstrip("/")
+        self.headers = {
+            "Authorization": f"token {api_key}:{api_secret}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        if self._client is None or self._client.is_closed:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=self.headers,
+                timeout=30.0,
+            )
+        return self._client
+
+    async def close(self):
+        if self._client and not self._client.is_closed:
+            await self._client.aclose()
+
+    async def _request(self, method: str, path: str, **kwargs) -> Any:
+        client = await self._get_client()
+        resp = await client.request(method, path, **kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    # --- CRUD ---
+
+    async def get_list(
+        self,
+        doctype: str,
+        fields: list[str] | None = None,
+        filters: Any = None,
+        or_filters: Any = None,
+        order_by: str | None = None,
+        limit_start: int = 0,
+        limit_page_length: int = 20,
+    ) -> list[dict]:
+        params: dict[str, Any] = {
+            "limit_start": limit_start,
+            "limit_page_length": limit_page_length,
+        }
+        if fields:
+            params["fields"] = json.dumps(fields)
+        if filters:
+            params["filters"] = json.dumps(filters)
+        if or_filters:
+            params["or_filters"] = json.dumps(or_filters)
+        if order_by:
+            params["order_by"] = order_by
+
+        result = await self._request("GET", f"/api/resource/{doctype}", params=params)
+        return result.get("data", [])
+
+    async def get_doc(self, doctype: str, name: str, fields: list[str] | None = None) -> dict:
+        params = {}
+        if fields:
+            params["fields"] = json.dumps(fields)
+        result = await self._request("GET", f"/api/resource/{doctype}/{name}", params=params)
+        return result.get("data", {})
+
+    async def create_doc(self, doctype: str, data: dict) -> dict:
+        result = await self._request("POST", f"/api/resource/{doctype}", json={"data": json.dumps(data)})
+        return result.get("data", {})
+
+    async def update_doc(self, doctype: str, name: str, data: dict) -> dict:
+        result = await self._request("PUT", f"/api/resource/{doctype}/{name}", json={"data": json.dumps(data)})
+        return result.get("data", {})
+
+    async def delete_doc(self, doctype: str, name: str) -> dict:
+        result = await self._request("DELETE", f"/api/resource/{doctype}/{name}")
+        return result
+
+    # --- Methods ---
+
+    async def call_method(self, method: str, http_method: str = "GET", **kwargs) -> Any:
+        if http_method.upper() == "POST":
+            result = await self._request("POST", f"/api/method/{method}", json=kwargs)
+        else:
+            result = await self._request("GET", f"/api/method/{method}", params=kwargs)
+        return result
+
+    # --- Document workflow ---
+
+    async def submit_doc(self, doctype: str, name: str) -> dict:
+        doc = await self.get_doc(doctype, name)
+        doc["docstatus"] = 1
+        return await self.call_method(
+            "frappe.client.submit",
+            http_method="POST",
+            doc=json.dumps(doc),
+        )
+
+    async def cancel_doc(self, doctype: str, name: str) -> dict:
+        return await self.call_method(
+            "frappe.client.cancel",
+            http_method="POST",
+            doctype=doctype,
+            name=name,
+        )
+
+    async def get_count(self, doctype: str, filters: Any = None) -> int:
+        params: dict[str, Any] = {"doctype": doctype}
+        if filters:
+            params["filters"] = json.dumps(filters)
+        result = await self.call_method("frappe.client.get_count", **params)
+        return result.get("message", 0)
+
+    async def get_report(self, report_name: str, filters: Any = None) -> Any:
+        params: dict[str, Any] = {"report_name": report_name}
+        if filters:
+            params["filters"] = json.dumps(filters)
+        return await self.call_method("frappe.desk.query_report.run", **params)
+
+    async def search_link(self, doctype: str, txt: str, filters: Any = None, page_length: int = 20) -> list:
+        params: dict[str, Any] = {
+            "doctype": doctype,
+            "txt": txt,
+            "page_length": page_length,
+        }
+        if filters:
+            params["filters"] = json.dumps(filters)
+        result = await self.call_method("frappe.desk.search.search_link", **params)
+        return result.get("message", result.get("results", []))
+
+    async def get_doctype_meta(self, doctype: str) -> dict:
+        result = await self.call_method("frappe.client.get_list", doctype="DocField", filters=json.dumps({"parent": doctype}), fields=json.dumps(["fieldname", "fieldtype", "label", "reqd", "options"]), limit_page_length="0")
+        return result.get("message", [])
+
+    # --- Inventory & Trading helpers ---
+
+    async def get_stock_balance(
+        self, item_code: str | None = None, warehouse: str | None = None,
+    ) -> list[dict]:
+        filters: dict[str, Any] = {}
+        if item_code:
+            filters["item_code"] = item_code
+        if warehouse:
+            filters["warehouse"] = warehouse
+        result = await self._request(
+            "GET", "/api/resource/Bin",
+            params={
+                "fields": json.dumps(["item_code", "warehouse", "actual_qty", "reserved_qty", "ordered_qty", "projected_qty"]),
+                "filters": json.dumps(filters),
+                "limit_page_length": 0,
+            },
+        )
+        return result.get("data", [])
+
+    async def get_item_price(
+        self, item_code: str, price_list: str | None = None,
+    ) -> list[dict]:
+        filters: dict[str, Any] = {"item_code": item_code}
+        if price_list:
+            filters["price_list"] = price_list
+        result = await self._request(
+            "GET", "/api/resource/Item Price",
+            params={
+                "fields": json.dumps(["item_code", "price_list", "price_list_rate", "currency", "uom"]),
+                "filters": json.dumps(filters),
+                "limit_page_length": 0,
+            },
+        )
+        return result.get("data", [])
+
+    async def make_mapped_doc(self, method: str, source_name: str) -> dict:
+        result = await self.call_method(
+            method, http_method="POST", source_name=source_name,
+        )
+        return result.get("message", result)
+
+    async def get_party_balance(self, party_type: str, party: str) -> Any:
+        result = await self.call_method(
+            "erpnext.accounts.utils.get_balance_on",
+            http_method="GET",
+            party_type=party_type,
+            party=party,
+        )
+        return result.get("message", 0)
+
+    async def get_stock_ledger(
+        self, item_code: str | None = None, warehouse: str | None = None,
+        limit: int = 50,
+    ) -> list[dict]:
+        filters: dict[str, Any] = {}
+        if item_code:
+            filters["item_code"] = item_code
+        if warehouse:
+            filters["warehouse"] = warehouse
+        result = await self._request(
+            "GET", "/api/resource/Stock Ledger Entry",
+            params={
+                "fields": json.dumps(["item_code", "warehouse", "posting_date", "qty_after_transaction", "actual_qty", "voucher_type", "voucher_no"]),
+                "filters": json.dumps(filters),
+                "order_by": "posting_date desc, posting_time desc",
+                "limit_page_length": limit,
+            },
+        )
+        return result.get("data", [])

erpnext_mcp/server.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+import json
+import os
+from typing import Any
+
+from dotenv import load_dotenv
+from fastmcp import FastMCP
+
+from .client import ERPNextClient
+
+load_dotenv()
+
+mcp = FastMCP(
+    "ERPNext",
+    instructions="MCP Server for ERPNext REST API - CRUD, reports, workflow operations",
+)
+
+_client: ERPNextClient | None = None
+
+
+def get_client() -> ERPNextClient:
+    global _client
+    if _client is None:
+        url = os.environ.get("ERPNEXT_URL", "http://ct.erp")
+        api_key = os.environ["ERPNEXT_API_KEY"]
+        api_secret = os.environ["ERPNEXT_API_SECRET"]
+        _client = ERPNextClient(url, api_key, api_secret)
+    return _client
+
+
+# ── CRUD ──────────────────────────────────────────────
+
+
+@mcp.tool()
+async def list_documents(
+    doctype: str,
+    fields: list[str] | None = None,
+    filters: str | None = None,
+    or_filters: str | None = None,
+    order_by: str | None = None,
+    limit_start: int = 0,
+    limit_page_length: int = 20,
+) -> list[dict]:
+    """List documents of a given DocType with optional filtering, sorting and pagination.
+
+    Args:
+        doctype: ERPNext DocType name (e.g. "Sales Order", "Customer")
+        fields: List of field names to return. Defaults to ["name"].
+        filters: JSON string of filters, e.g. '{"status": "Open"}' or '[["status","=","Open"]]'
+        or_filters: JSON string of OR filters
+        order_by: Sort expression, e.g. "creation desc"
+        limit_start: Pagination offset
+        limit_page_length: Number of records to return (max 100)
+    """
+    f = json.loads(filters) if filters else None
+    of = json.loads(or_filters) if or_filters else None
+    return await get_client().get_list(
+        doctype, fields=fields, filters=f, or_filters=of,
+        order_by=order_by, limit_start=limit_start, limit_page_length=limit_page_length,
+    )
+
+
+@mcp.tool()
+async def get_document(doctype: str, name: str, fields: list[str] | None = None) -> dict:
+    """Get a single document by DocType and name.
+
+    Args:
+        doctype: ERPNext DocType name
+        name: Document name/ID
+        fields: Optional list of fields to return
+    """
+    return await get_client().get_doc(doctype, name, fields=fields)
+
+
+@mcp.tool()
+async def create_document(doctype: str, data: str) -> dict:
+    """Create a new document.
+
+    Args:
+        doctype: ERPNext DocType name
+        data: JSON string of field values, e.g. '{"customer_name": "Test", "customer_type": "Individual"}'
+    """
+    return await get_client().create_doc(doctype, json.loads(data))
+
+
+@mcp.tool()
+async def update_document(doctype: str, name: str, data: str) -> dict:
+    """Update an existing document.
+
+    Args:
+        doctype: ERPNext DocType name
+        name: Document name/ID
+        data: JSON string of fields to update
+    """
+    return await get_client().update_doc(doctype, name, json.loads(data))
+
+
+@mcp.tool()
+async def delete_document(doctype: str, name: str) -> dict:
+    """Delete a document.
+
+    Args:
+        doctype: ERPNext DocType name
+        name: Document name/ID
+    """
+    return await get_client().delete_doc(doctype, name)
+
+
+# ── Reports ───────────────────────────────────────────
+
+
+@mcp.tool()
+async def run_report(report_name: str, filters: str | None = None) -> Any:
+    """Execute an ERPNext report.
+
+    Args:
+        report_name: Name of the report
+        filters: Optional JSON string of report filters
+    """
+    f = json.loads(filters) if filters else None
+    return await get_client().get_report(report_name, filters=f)
+
+
+@mcp.tool()
+async def get_count(doctype: str, filters: str | None = None) -> int:
+    """Get document count for a DocType with optional filters.
+
+    Args:
+        doctype: ERPNext DocType name
+        filters: Optional JSON string of filters
+    """
+    f = json.loads(filters) if filters else None
+    return await get_client().get_count(doctype, filters=f)
+
+
+@mcp.tool()
+async def get_list_with_summary(
+    doctype: str,
+    fields: list[str] | None = None,
+    filters: str | None = None,
+    order_by: str | None = None,
+    limit_page_length: int = 20,
+) -> dict:
+    """Get a list of documents along with total count.
+
+    Args:
+        doctype: ERPNext DocType name
+        fields: Fields to return
+        filters: Optional JSON string of filters
+        order_by: Sort expression
+        limit_page_length: Number of records
+    """
+    f = json.loads(filters) if filters else None
+    client = get_client()
+    docs = await client.get_list(doctype, fields=fields, filters=f, order_by=order_by, limit_page_length=limit_page_length)
+    count = await client.get_count(doctype, filters=f)
+    return {"data": docs, "total_count": count}
+
+
+# ── Workflow ──────────────────────────────────────────
+
+
+@mcp.tool()
+async def submit_document(doctype: str, name: str) -> dict:
+    """Submit a submittable document (e.g. Sales Invoice).
+
+    Args:
+        doctype: ERPNext DocType name
+        name: Document name/ID
+    """
+    return await get_client().submit_doc(doctype, name)
+
+
+@mcp.tool()
+async def cancel_document(doctype: str, name: str) -> dict:
+    """Cancel a submitted document.
+
+    Args:
+        doctype: ERPNext DocType name
+        name: Document name/ID
+    """
+    return await get_client().cancel_doc(doctype, name)
+
+
+@mcp.tool()
+async def run_method(method: str, http_method: str = "POST", args: str | None = None) -> Any:
+    """Call a server-side method (whitelisted API).
+
+    Args:
+        method: Dotted method path, e.g. "frappe.client.get_list" or "erpnext.selling.doctype.sales_order.sales_order.make_delivery_note"
+        http_method: GET or POST (default POST)
+        args: Optional JSON string of keyword arguments
+    """
+    kwargs = json.loads(args) if args else {}
+    return await get_client().call_method(method, http_method=http_method, **kwargs)
+
+
+# ── Helpers ───────────────────────────────────────────
+
+
+@mcp.tool()
+async def list_doctypes(module: str | None = None, is_submittable: bool | None = None, limit: int = 100) -> list[str]:
+    """List all available DocType names.
+
+    Args:
+        module: Optional module filter (e.g. "Selling", "Stock", "Accounts")
+        is_submittable: Optional filter for submittable doctypes only
+        limit: Max results (default 100)
+    """
+    filters: dict[str, Any] = {}
+    if module:
+        filters["module"] = module
+    if is_submittable is not None:
+        filters["is_submittable"] = int(is_submittable)
+    docs = await get_client().get_list(
+        "DocType", fields=["name"], filters=filters or None,
+        order_by="name asc", limit_page_length=limit,
+    )
+    return [d["name"] for d in docs]
+
+
+@mcp.tool()
+async def search_link(doctype: str, txt: str, filters: str | None = None, page_length: int = 20) -> list:
+    """Search for link field values (autocomplete).
+
+    Args:
+        doctype: DocType to search in
+        txt: Search text
+        filters: Optional JSON string of filters
+        page_length: Max results
+    """
+    f = json.loads(filters) if filters else None
+    return await get_client().search_link(doctype, txt, filters=f, page_length=page_length)
+
+
+@mcp.tool()
+async def get_doctype_meta(doctype: str) -> list:
+    """Get field definitions for a DocType.
+
+    Args:
+        doctype: ERPNext DocType name
+    """
+    return await get_client().get_doctype_meta(doctype)
+
+
+# ── Inventory & Trading ──────────────────────────────
+
+
+@mcp.tool()
+async def get_stock_balance(item_code: str | None = None, warehouse: str | None = None) -> list[dict]:
+    """Get real-time stock balance from Bin.
+
+    Args:
+        item_code: Optional item code to filter
+        warehouse: Optional warehouse to filter
+    """
+    return await get_client().get_stock_balance(item_code=item_code, warehouse=warehouse)
+
+
+@mcp.tool()
+async def get_item_price(item_code: str, price_list: str | None = None) -> list[dict]:
+    """Get item prices from Item Price records.
+
+    Args:
+        item_code: Item code to look up
+        price_list: Optional price list name to filter (e.g. "Standard Selling")
+    """
+    return await get_client().get_item_price(item_code, price_list=price_list)
+
+
+@mcp.tool()
+async def make_mapped_doc(method: str, source_name: str) -> dict:
+    """Create a new document mapped from an existing one (document conversion).
+
+    Common methods:
+    - erpnext.selling.doctype.quotation.quotation.make_sales_order (Quotation → Sales Order)
+    - erpnext.selling.doctype.sales_order.sales_order.make_delivery_note (Sales Order → Delivery Note)
+    - erpnext.selling.doctype.sales_order.sales_order.make_sales_invoice (Sales Order → Sales Invoice)
+    - erpnext.stock.doctype.delivery_note.delivery_note.make_sales_invoice (Delivery Note → Sales Invoice)
+    - erpnext.buying.doctype.purchase_order.purchase_order.make_purchase_receipt (PO → Purchase Receipt)
+    - erpnext.buying.doctype.purchase_order.purchase_order.make_purchase_invoice (PO → Purchase Invoice)
+
+    Args:
+        method: Dotted path of the mapping method
+        source_name: Name/ID of the source document
+    """
+    return await get_client().make_mapped_doc(method, source_name)
+
+
+@mcp.tool()
+async def get_party_balance(party_type: str, party: str) -> Any:
+    """Get outstanding balance for a Customer or Supplier.
+
+    Args:
+        party_type: "Customer" or "Supplier"
+        party: Party name/ID
+    """
+    return await get_client().get_party_balance(party_type, party)
+
+
+@mcp.tool()
+async def get_stock_ledger(item_code: str | None = None, warehouse: str | None = None, limit: int = 50) -> list[dict]:
+    """Get stock ledger entries (inventory transaction history).
+
+    Args:
+        item_code: Optional item code filter
+        warehouse: Optional warehouse filter
+        limit: Max records to return (default 50)
+    """
+    return await get_client().get_stock_ledger(item_code=item_code, warehouse=warehouse, limit=limit)
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

erpnext_mcp/types.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from typing import Any
+from pydantic import BaseModel, Field
+
+
+class ERPNextResponse(BaseModel):
+    data: Any = None
+    message: Any = None
+    exc: str | None = None
+    exc_type: str | None = None
+
+
+class ListFilters(BaseModel):
+    filters: dict[str, Any] | list[list] | None = None
+    fields: list[str] | None = None
+    order_by: str | None = None
+    limit_start: int = 0
+    limit_page_length: int = 20
+    or_filters: dict[str, Any] | list[list] | None = None
+
+
+class DocumentResponse(BaseModel):
+    name: str
+    doctype: str | None = None
+    data: dict[str, Any] = Field(default_factory=dict)

erpnext_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: erpnext-mcp
+Version: 0.1.0
+Summary: MCP Server for ERPNext REST API
+Project-URL: Homepage, https://github.com/ching-tech/erpnext-mcp
+Project-URL: Repository, https://github.com/ching-tech/erpnext-mcp
+Project-URL: Issues, https://github.com/ching-tech/erpnext-mcp/issues
+Author: Ching-Tech
+License: MIT License
+        
+        Copyright (c) 2025 Ching-Tech
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: api,erp,erpnext,frappe,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Description-Content-Type: text/markdown
+
+# ERPNext MCP Server
+
+MCP (Model Context Protocol) server for ERPNext REST API, built with [FastMCP](https://github.com/jlowin/fastmcp) and Python.
+
+## Features
+
+- **CRUD** — List, get, create, update, delete documents
+- **Workflow** — Submit and cancel submittable documents
+- **Reports** — Run ERPNext query reports
+- **Schema** — Inspect DocType field definitions, list all DocTypes
+- **Inventory** — Stock balance, stock ledger, item prices
+- **Trading** — Document conversion (e.g. Quotation → Sales Order), party balance
+- **Helpers** — Link search (autocomplete), document count, generic method calls
+
+## Requirements
+
+- Python >= 3.11
+- [uv](https://docs.astral.sh/uv/) (recommended) or pip
+- ERPNext instance with API key/secret
+
+## Setup
+
+```bash
+# Clone the repo
+git clone <repo-url> && cd erpnext-mcp
+
+# Create .env file
+cat > .env << 'EOF'
+ERPNEXT_URL=https://your-erpnext-instance.com
+ERPNEXT_API_KEY=your_api_key
+ERPNEXT_API_SECRET=your_api_secret
+EOF
+
+# Install dependencies
+uv sync
+```
+
+## Run
+
+```bash
+set -a && source .env && set +a && uv run erpnext-mcp
+```
+
+## Available Tools
+
+| Tool | Description |
+|---|---|
+| `list_documents` | List documents with filters, sorting, pagination |
+| `get_document` | Get a single document by name |
+| `create_document` | Create a new document |
+| `update_document` | Update an existing document |
+| `delete_document` | Delete a document |
+| `submit_document` | Submit a submittable document |
+| `cancel_document` | Cancel a submitted document |
+| `run_report` | Execute an ERPNext report |
+| `get_count` | Get document count with optional filters |
+| `get_list_with_summary` | List documents with total count |
+| `run_method` | Call any whitelisted server-side method |
+| `search_link` | Link field autocomplete search |
+| `list_doctypes` | List all available DocType names |
+| `get_doctype_meta` | Get field definitions for a DocType |
+| `get_stock_balance` | Real-time stock balance from Bin |
+| `get_stock_ledger` | Stock ledger entries (inventory history) |
+| `get_item_price` | Item prices from price lists |
+| `make_mapped_doc` | Document conversion (e.g. SO → DN) |
+| `get_party_balance` | Outstanding balance for Customer/Supplier |
+
+## MCP Client Configuration
+
+Add to your MCP client config (e.g. Claude Desktop `claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "erpnext": {
+      "command": "uv",
+      "args": ["--directory", "/path/to/erpnext-mcp", "run", "erpnext-mcp"],
+      "env": {
+        "ERPNEXT_URL": "https://your-erpnext-instance.com",
+        "ERPNEXT_API_KEY": "your_api_key",
+        "ERPNEXT_API_SECRET": "your_api_secret"
+      }
+    }
+  }
+}
+```
+
+## Project Structure
+
+```
+src/erpnext_mcp/
+├── server.py   # MCP tool definitions (FastMCP)
+├── client.py   # ERPNext REST API client (httpx async)
+└── types.py    # Pydantic models
+```
+
+## License
+
+MIT

erpnext_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+erpnext_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+erpnext_mcp/client.py,sha256=TqkXXrTDiFXe6Py2E5BQNMsjlJ_I_ScmuCZjnE7nBkE,7923
+erpnext_mcp/server.py,sha256=G1kak-VkrevAKRvB5TmzdG8pE2oP_PfQZlXyPvcqVjQ,10372
+erpnext_mcp/types.py,sha256=MC7H3f1BgpvIbWDwXSv1uFwH8nTD0BMiiqnHypsutk8,643
+erpnext_mcp-0.1.0.dist-info/METADATA,sha256=mu7E_t0WIutfRRocWDyeeoJoeXBXFJteNUXRDc8-uyo,5119
+erpnext_mcp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+erpnext_mcp-0.1.0.dist-info/entry_points.txt,sha256=AbRXtSJhFq6PLmqKjNYkFjcKFjQwvkiTI8QAhqqAsps,56
+erpnext_mcp-0.1.0.dist-info/licenses/LICENSE,sha256=M_cHb60t6PxhBL25Y_hbvWe8WaUxG1y5xh5qoWNIlYU,1067
+erpnext_mcp-0.1.0.dist-info/RECORD,,

erpnext_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

erpnext_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+erpnext-mcp = erpnext_mcp.server:main

erpnext_mcp-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ching-Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.