Lass KI-Agenten Excel-Modelle lesen, prüfen und bearbeiten, indem sie Workbooks parsen, Formeln auswerten und interaktive Workbook-Sessions verwalten.
Auch bekannt als basis1tech/basis-oss, mcp, @basis1/mcp
- Stars
- 0
- Tools
- 26
- Downloads, 30 Tage
- 1.539
- Neueste Version
- 0.3.2
- Letzter Commit
- 15. Nov. 2026
- Lizenz
- Apache-2.0
Was ist Basis MCP?
Lass KI-Agenten Excel-Modelle lesen, prüfen und bearbeiten, indem sie Workbooks parsen, Formeln auswerten und interaktive Workbook-Sessions verwalten. Er stellt 26 Tools bereit, etwa parse_workbook, submit_job, stream_job.
Zusammenfassung generiert aus dem README des Projekts
Über Basis MCP server
Basis ermöglicht es Entwicklern, die Claude, Cursor oder andere MCP-Clients nutzen, KI-Agenten mit komplexen Excel-Modellen interagieren zu lassen. Dieser Server erlaubt es Agenten, Workbooks zu parsen, Formeln auszuwerten und Abhängigkeiten über die Basis API zu verfolgen. Durch die Verbindung via lokaler Installation mit npx oder über einen remote gehosteten Endpoint können Nutzer KI-Modellen die Fähigkeit geben, Spreadsheet-Daten zu lesen, zu prüfen und zu bearbeiten.
Nutzer müssen einen Basis API-Key angeben, um auf die Engine zuzugreifen. Der Server unterstützt verschiedene Input-Methoden, darunter lokale Dateipfade, URLs oder Base64-Strings. Er bietet spezialisierte Tools für unterschiedliche Workflows, wie parse_workbook zum Extrahieren von Metadaten und Zelldaten, evaluate_formula zum Testen spezifischer Excel-Funktionen und recalc_workbook zur Berechnung von Werten in einer Datei. Für interaktivere Aufgaben verwaltet der Server Workbook-Sessions, die es einem Agenten ermöglichen, Inputs zu ändern, Sheets umzubenennen und definierte Namen zu verwalten, während eine stateful Verbindung zum Modell aufrechterhalten wird.
Was du damit machen kannst
- 1Interaktive Finanzsimulationen durchführenEin Agent kann eine Workbook-Session öffnen, um spezifische Input-Werte zu ändern und anschließend die daraus resultierenden berechneten Outputs auszulesen.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du Basis MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenBasis MCP in Claude Code installieren
$ claude mcp add --env 'BASIS_API_KEY=<YOUR_BASIS_API_KEY>' mcp -- npx -y @basis1/mcpBasis MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@basis1/mcp"
],
"env": {
"BASIS_API_KEY": "<YOUR_BASIS_API_KEY>"
}
}
}
}Basis MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"mcp": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@basis1/mcp"
],
"env": {
"BASIS_API_KEY": "<YOUR_BASIS_API_KEY>"
}
}
}
}Basis MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"mcp","type":"stdio","command":"npx","args":["-y","@basis1/mcp"],"env":{"BASIS_API_KEY":"<YOUR_BASIS_API_KEY>"}}'Basis MCP in Claude Desktop installieren
claude_desktop_config.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@basis1/mcp"
],
"env": {
"BASIS_API_KEY": "<YOUR_BASIS_API_KEY>"
}
}
}
}Basis MCP in Codex installieren
$ codex mcp add mcp --env 'BASIS_API_KEY=<YOUR_BASIS_API_KEY>' -- npx -y @basis1/mcpBasis MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.mcp] command = "npx" args = ["-y", "@basis1/mcp"] [mcp_servers.mcp.env] BASIS_API_KEY = "<YOUR_BASIS_API_KEY>"
Basis MCP in Gemini CLI installieren
$ gemini mcp add -s user -e 'BASIS_API_KEY=<YOUR_BASIS_API_KEY>' mcp npx -- -y @basis1/mcpBasis MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"mcp": {
"command": "npx",
"args": [
"-y",
"@basis1/mcp"
],
"env": {
"BASIS_API_KEY": "<YOUR_BASIS_API_KEY>"
}
}
}
}Von HostedMCP gestartet am 16. Nov. 2026
Wir haben diesen Befehl für @basis1/mcp 0.3.2 in einem isolierten Container ohne Netzwerk und ohne Schlüssel ausgeführt. Er hat geantwortet und 26 Tools gelistet.
Basis MCP tools 26
Vom Server mit tools/list gelesenparse_workbookNur lesendParse an .xlsx workbook (or a .csv/.tsv file, read as one sheet) in one call and return its full semantic NDJSON: one JSON record per line (workbook_meta, sheet, cell, edge, image, image_summary, audit), covering every cell's value and formula and the formula dependency edges. Use it to read a whole file without opening a session. For a large file, use submit_job so the call doesn't wait on the parse; to read a few cells or edit, use create_session; to compare two files, use diff_workbooks. Pass exactly one of url or base64 (up to 20 MB). Each call counts against the API key's parse quota and fails with quota_exceeded once it is used up, or with the parse error's code for a file that isn't a readable workbook. webhook_url, if set, also gets an HMAC-signed POST when the parse finishes.
submit_jobAktionStart an async parse of an .xlsx workbook (or a .csv/.tsv file) and return at once with a job handle {job_id, status: "processing", status_url, stream_url}. Use it instead of parse_workbook for large files or when you don't want to wait: call stream_job with wait_seconds to wait for the records (or status_only to just check). Every call starts a new job and counts against the API key's parse quota, so don't resubmit a file whose job is still running. Pass exactly one of url or base64 (up to 20 MB). webhook_url, if set, gets an HMAC-signed POST when the job finishes, so you can skip polling.
stream_jobNur lesendCheck on or read a parse job started by submit_job. By default it returns the job's NDJSON records once it has completed: the same output parse_workbook returns, one JSON record per line. Pass wait_seconds (up to 60) to wait that long for a job still processing; if it is still processing after that, the call fails with job_not_ready and the job's status, so call again. Pass status_only: true to get the status instead, without waiting: {job_id, status, created_at, updated_at, expires_at, bytes_in, records_out, stream_url, error}, where status is "processing", "completed" or "failed". A failed job returns its parse error, and an unknown or expired job_id, or one submitted with another API key, fails with not_found. Everything after `since` comes back in one result, with no paging; pass since to skip records you already have. parse_workbook returns its result directly and needs no job.
diff_workbooksNur lesendCompare two .xlsx (or .csv) files cell by cell and return the differences as JSON: {summary, added, removed, changed, format_changed}. Cells are matched on (sheet title, cell ref); changed covers value and formula changes, and format-only changes are listed separately. Use it to see what changed between two versions of a file, such as before and after an edit. For problems inside one workbook use audit_workbook; to undo edits in a session use restore_session. Provide exactly one of before_url/before_base64 and one of after_url/after_base64. Both files are parsed (up to 20 MB each) and count against the API key's parse quota; nothing is stored.
evaluate_formulaNur lesendEvaluate an Excel formula locally and return the computed result: a quick way to check what a formula returns on a few sample values before you put it in a workbook. Pass data as a map of cell references to values (e.g. {"A1": 100, "A2": true, "A3": "#N/A", "B1": "hello"}) and a formula string (e.g. "SUM(A1:A2)"). Values keep their Excel types, as in a workbook: true/false are logical cells (so SUM, AVERAGE and COUNT skip them in a range), a string that is exactly an error code (#N/A, #DIV/0!, #VALUE!, #REF!, #NAME?, #NUM!, #NULL!) is that error, and other strings are text. The formula is placed in row 1 of the first column right of your data, so don't reference that cell. Returns {formula, result, type, stats}, type being "number", "string", "boolean" or "error". A formula that evaluates to an Excel error returns type "error" with the code (#VALUE!, #N/A…) as a normal result; a formula that can't be parsed or uses an unsupported function is a tool error. Supports 297 Excel functions: math, financial (NPV, IRR, XIRR, PMT…), statistical, lookup, date/time, text, logical, and dynamic arrays (FILTER, SORT, UNIQUE, SEQUENCE…). Array expressions evaluate element by element inside SUMPRODUCT, LOOKUP, AGGREGATE, SMALL/LARGE, MATCH and INDEX. To check formulas that already live in a workbook, use create_session instead.
create_sessionAktionOpen a workbook in a session that the other workbook tools then use by session_id: the starting point for reading, editing, recalculating and exporting a model. Pass at most one of library_file_id (a file in your Library), base64 (raw .xlsx or .csv bytes) or url, or none for a blank workbook (the only kind add_sheet can extend). A .csv opens as one sheet, typed as Excel types it (numbers, TRUE/FALSE, YYYY-MM-DD dates, =formulas; leading-zero codes stay text), and exports as .xlsx. The workbook is recalculated on load, including formulas written by other tools without cached values, so opening a file you edited elsewhere is how you read back what its formulas compute (get_outputs, get_formula_range); change inputs with set_inputs. Returns {session_id, document_id, library_file_id, sheets: [{index, name}], defined_names, calc}. For a one-off recalculation of a file, use recalc_workbook instead; to try a formula without a file, use evaluate_formula. Each API key can hold 5 open sessions, and a session closes on its own after 30 minutes without a call. A sixth create_session fails with max_sessions and lists the open sessions; close one first. save_to_library keeps the workbook beyond the session.
close_sessionAktionEnd a session and discard its workbook: the session_id stops working and the session can't be reopened. Edits not saved with save_to_library (or downloaded with export_workbook) are lost, and its commit_session checkpoints go with it, so restore_session can't bring it back. Call it when you're done with a workbook, or to free a slot when create_session fails with max_sessions. Returns {closed: true}, plus unsaved: true and a hint when the workbook was edited since it was opened or last saved to the Library. An unknown, expired or already closed session_id fails with session_not_found, which lists the sessions still open. Sessions also close on their own after 30 minutes without a call.
list_sessionsNur lesendList the sessions open for this API key, to recover a session_id you've lost or to see how many are open before create_session. Returns {sessions: [{id, documentId, libraryFileId, createdAt, updatedAt, sheetCount, memBytes}]}, times in epoch milliseconds; closed and expired sessions are left out. Pass an id to any session tool, or to close_session to free a slot. Takes no arguments. Each API key can hold 5 open sessions, and a session closes on its own after 30 minutes without a call.
add_sheetAktionAdd an empty sheet at the end of a session's workbook and make it the active sheet (the one unqualified refs like "B4" point to). Only for sessions created blank (create_session with no file); on an imported workbook it fails, so work in its existing sheets with set_inputs instead. To retitle a sheet use rename_sheet; to remove one use delete_sheet. Returns {sheet_index, sheet_name, sheet_count}.
rename_sheetAktionRename a sheet in a session's workbook, found by its 0-based index (see the sheets list from create_session or inspect_model). Formulas, named ranges and validations that reference the sheet are rewritten to the new name, so results don't change; use it rather than add_sheet when you only need a different title. Excel's rules apply: 1-31 characters, none of : \ / ? * [ ], no leading or trailing apostrophe, unique ignoring case; a name that breaks them, or an index past the last sheet, fails with bad_request. Returns {sheet_index, previous_name, sheet_name}.
delete_sheetAktionDelete a sheet from a session's workbook, found by its 0-based index (see the sheets list from create_session or inspect_model), the way Excel does: formulas on other sheets that referenced it now read #REF! (Gone!A1 becomes #REF!A1) and evaluate to #REF!, a 3D range ending on it (Jan:Mar!B2) shrinks to the neighbouring sheet, names scoped to it are removed and names that pointed into it refer to #REF!. Sheets after it move down one index, so re-read indexes from the result before the next call. Works on imported and blank workbooks, and recalculates. It can't be undone: restore_session brings back other cells but not the sheet, so export_workbook or save_to_library first if you may need it. Returns {deleted: {sheet_index, sheet_name}, sheets: [{index, name}], active_sheet, formulas_broken (up to 200 cell refs), formulas_broken_count, names_removed, names_broken}. The last sheet, the last visible sheet or an index past the last sheet fails with bad_request and changes nothing. To retitle a sheet use rename_sheet; to empty one without breaking references, overwrite its cells with set_inputs.
set_inputsAktionWrite values or formulas into cells of a session and recalculate: the way to run a scenario on a model ("what if Revenue is 1.2M?"). Keys are defined names (e.g. "Revenue") or cell refs ("B4" on the active sheet, "Sheet1!A1"); values are numbers, booleans (logical TRUE/FALSE), error codes such as "#N/A", text, or a string starting with "=" to store a formula. Whatever the target cells held before is overwritten, so call commit_session first if you may want restore_session to undo it. The batch is all or nothing: a key that isn't a defined name or valid ref, or a formula that can't be stored, fails the call with invalid_input and no cell is written. Returns {applied, recalc, effects}: the cells written, recalc stats (with a warning for circular references that didn't converge) and each defined name whose value changed, with before and after. Read other results with get_outputs; to try a formula without touching the workbook use evaluate_formula; to create a name use define_variable.
| parse_workbook | Parse an .xlsx workbook (or a .csv/.tsv file, read as one sheet) in one call and return its full semantic NDJSON: one JSON record per line (workbook_meta, sheet, cell, edge, image, image_summary, audit), covering every cell's value and formula and the formula dependency edges. Use it to read a whole file without opening a session. For a large file, use submit_job so the call doesn't wait on the parse; to read a few cells or edit, use create_session; to compare two files, use diff_workbooks. Pass exactly one of url or base64 (up to 20 MB). Each call counts against the API key's parse quota and fails with quota_exceeded once it is used up, or with the parse error's code for a file that isn't a readable workbook. webhook_url, if set, also gets an HMAC-signed POST when the parse finishes. | Nur lesend |
| submit_job | Start an async parse of an .xlsx workbook (or a .csv/.tsv file) and return at once with a job handle {job_id, status: "processing", status_url, stream_url}. Use it instead of parse_workbook for large files or when you don't want to wait: call stream_job with wait_seconds to wait for the records (or status_only to just check). Every call starts a new job and counts against the API key's parse quota, so don't resubmit a file whose job is still running. Pass exactly one of url or base64 (up to 20 MB). webhook_url, if set, gets an HMAC-signed POST when the job finishes, so you can skip polling. | Aktion |
| stream_job | Check on or read a parse job started by submit_job. By default it returns the job's NDJSON records once it has completed: the same output parse_workbook returns, one JSON record per line. Pass wait_seconds (up to 60) to wait that long for a job still processing; if it is still processing after that, the call fails with job_not_ready and the job's status, so call again. Pass status_only: true to get the status instead, without waiting: {job_id, status, created_at, updated_at, expires_at, bytes_in, records_out, stream_url, error}, where status is "processing", "completed" or "failed". A failed job returns its parse error, and an unknown or expired job_id, or one submitted with another API key, fails with not_found. Everything after `since` comes back in one result, with no paging; pass since to skip records you already have. parse_workbook returns its result directly and needs no job. | Nur lesend |
| diff_workbooks | Compare two .xlsx (or .csv) files cell by cell and return the differences as JSON: {summary, added, removed, changed, format_changed}. Cells are matched on (sheet title, cell ref); changed covers value and formula changes, and format-only changes are listed separately. Use it to see what changed between two versions of a file, such as before and after an edit. For problems inside one workbook use audit_workbook; to undo edits in a session use restore_session. Provide exactly one of before_url/before_base64 and one of after_url/after_base64. Both files are parsed (up to 20 MB each) and count against the API key's parse quota; nothing is stored. | Nur lesend |
| evaluate_formula | Evaluate an Excel formula locally and return the computed result: a quick way to check what a formula returns on a few sample values before you put it in a workbook. Pass data as a map of cell references to values (e.g. {"A1": 100, "A2": true, "A3": "#N/A", "B1": "hello"}) and a formula string (e.g. "SUM(A1:A2)"). Values keep their Excel types, as in a workbook: true/false are logical cells (so SUM, AVERAGE and COUNT skip them in a range), a string that is exactly an error code (#N/A, #DIV/0!, #VALUE!, #REF!, #NAME?, #NUM!, #NULL!) is that error, and other strings are text. The formula is placed in row 1 of the first column right of your data, so don't reference that cell. Returns {formula, result, type, stats}, type being "number", "string", "boolean" or "error". A formula that evaluates to an Excel error returns type "error" with the code (#VALUE!, #N/A…) as a normal result; a formula that can't be parsed or uses an unsupported function is a tool error. Supports 297 Excel functions: math, financial (NPV, IRR, XIRR, PMT…), statistical, lookup, date/time, text, logical, and dynamic arrays (FILTER, SORT, UNIQUE, SEQUENCE…). Array expressions evaluate element by element inside SUMPRODUCT, LOOKUP, AGGREGATE, SMALL/LARGE, MATCH and INDEX. To check formulas that already live in a workbook, use create_session instead. | Nur lesend |
| create_session | Open a workbook in a session that the other workbook tools then use by session_id: the starting point for reading, editing, recalculating and exporting a model. Pass at most one of library_file_id (a file in your Library), base64 (raw .xlsx or .csv bytes) or url, or none for a blank workbook (the only kind add_sheet can extend). A .csv opens as one sheet, typed as Excel types it (numbers, TRUE/FALSE, YYYY-MM-DD dates, =formulas; leading-zero codes stay text), and exports as .xlsx. The workbook is recalculated on load, including formulas written by other tools without cached values, so opening a file you edited elsewhere is how you read back what its formulas compute (get_outputs, get_formula_range); change inputs with set_inputs. Returns {session_id, document_id, library_file_id, sheets: [{index, name}], defined_names, calc}. For a one-off recalculation of a file, use recalc_workbook instead; to try a formula without a file, use evaluate_formula. Each API key can hold 5 open sessions, and a session closes on its own after 30 minutes without a call. A sixth create_session fails with max_sessions and lists the open sessions; close one first. save_to_library keeps the workbook beyond the session. | Aktion |
| close_session | End a session and discard its workbook: the session_id stops working and the session can't be reopened. Edits not saved with save_to_library (or downloaded with export_workbook) are lost, and its commit_session checkpoints go with it, so restore_session can't bring it back. Call it when you're done with a workbook, or to free a slot when create_session fails with max_sessions. Returns {closed: true}, plus unsaved: true and a hint when the workbook was edited since it was opened or last saved to the Library. An unknown, expired or already closed session_id fails with session_not_found, which lists the sessions still open. Sessions also close on their own after 30 minutes without a call. | Aktion |
| list_sessions | List the sessions open for this API key, to recover a session_id you've lost or to see how many are open before create_session. Returns {sessions: [{id, documentId, libraryFileId, createdAt, updatedAt, sheetCount, memBytes}]}, times in epoch milliseconds; closed and expired sessions are left out. Pass an id to any session tool, or to close_session to free a slot. Takes no arguments. Each API key can hold 5 open sessions, and a session closes on its own after 30 minutes without a call. | Nur lesend |
| add_sheet | Add an empty sheet at the end of a session's workbook and make it the active sheet (the one unqualified refs like "B4" point to). Only for sessions created blank (create_session with no file); on an imported workbook it fails, so work in its existing sheets with set_inputs instead. To retitle a sheet use rename_sheet; to remove one use delete_sheet. Returns {sheet_index, sheet_name, sheet_count}. | Aktion |
| rename_sheet | Rename a sheet in a session's workbook, found by its 0-based index (see the sheets list from create_session or inspect_model). Formulas, named ranges and validations that reference the sheet are rewritten to the new name, so results don't change; use it rather than add_sheet when you only need a different title. Excel's rules apply: 1-31 characters, none of : \ / ? * [ ], no leading or trailing apostrophe, unique ignoring case; a name that breaks them, or an index past the last sheet, fails with bad_request. Returns {sheet_index, previous_name, sheet_name}. | Aktion |
| delete_sheet | Delete a sheet from a session's workbook, found by its 0-based index (see the sheets list from create_session or inspect_model), the way Excel does: formulas on other sheets that referenced it now read #REF! (Gone!A1 becomes #REF!A1) and evaluate to #REF!, a 3D range ending on it (Jan:Mar!B2) shrinks to the neighbouring sheet, names scoped to it are removed and names that pointed into it refer to #REF!. Sheets after it move down one index, so re-read indexes from the result before the next call. Works on imported and blank workbooks, and recalculates. It can't be undone: restore_session brings back other cells but not the sheet, so export_workbook or save_to_library first if you may need it. Returns {deleted: {sheet_index, sheet_name}, sheets: [{index, name}], active_sheet, formulas_broken (up to 200 cell refs), formulas_broken_count, names_removed, names_broken}. The last sheet, the last visible sheet or an index past the last sheet fails with bad_request and changes nothing. To retitle a sheet use rename_sheet; to empty one without breaking references, overwrite its cells with set_inputs. | Aktion |
| set_inputs | Write values or formulas into cells of a session and recalculate: the way to run a scenario on a model ("what if Revenue is 1.2M?"). Keys are defined names (e.g. "Revenue") or cell refs ("B4" on the active sheet, "Sheet1!A1"); values are numbers, booleans (logical TRUE/FALSE), error codes such as "#N/A", text, or a string starting with "=" to store a formula. Whatever the target cells held before is overwritten, so call commit_session first if you may want restore_session to undo it. The batch is all or nothing: a key that isn't a defined name or valid ref, or a formula that can't be stored, fails the call with invalid_input and no cell is written. Returns {applied, recalc, effects}: the cells written, recalc stats (with a warning for circular references that didn't converge) and each defined name whose value changed, with before and after. Read other results with get_outputs; to try a formula without touching the workbook use evaluate_formula; to create a name use define_variable. | Aktion |
Alle 26 Tools anzeigenWeniger Tools anzeigen
set_calc_settingsAktionTurn iterative calculation on or off for a session and recalculate. Needed for circular models (e.g. development pro formas where loan size depends on cost, which includes the loan's interest and fees): with it on, set_inputs re-converges the loop on every call. Saved with the session's next commit (restore_session to an earlier commit rolls it back) and written to the workbook, so an exported xlsx iterates in Excel too. Returns {calc, recalc}: the settings now in force and whether the model converged.
get_outputsNur lesendRead computed values from a session by defined name, cell or range: the way to check what a model's formulas return, e.g. after set_inputs. Pass names as defined names, cell refs ("B4", "Sheet1!B4") or ranges ("Sheet1!H2:H18", up to 2,000 cells, one entry per cell); omit names to read every defined name. Returns {values: {<name or ref>: {cell, type, value}}}; a cell holding an Excel error comes back with type "error" and its code, not as a tool failure, while a key that isn't a defined name or valid ref fails the call. Values only: for formula text use get_formula_range, and to see what feeds a value use trace_dependencies.
define_variableAktionCreate a defined name for a cell, or repoint an existing one, so set_inputs and get_outputs can use a readable key ("Revenue") instead of a cell ref. A name that already exists in the same scope is overwritten with the new target; no cell's value or formula changes. Names follow Excel's rules (start with a letter, _ or \, no spaces, not a cell ref) and invalid ones fail the call. Returns {name, refers_to, defined_names}, the last being every name after the change. To remove a name use delete_variable; to see the existing names first, use inspect_model.
delete_variableAktionDelete a defined name from a session's workbook, e.g. one you made with define_variable and no longer need. Only the name goes; the cell it pointed to keeps its value and formula. Match is by name, ignoring case, in workbook scope or, with scope_sheet, the name scoped to that sheet. A name still used by a formula is not deleted: the call fails with name_in_use and lists those cells, so rewrite them with set_inputs (or repoint the name with define_variable) first. A name that doesn't exist in that scope fails with not_found, and Excel's built-in names (print areas, filters) can't be deleted. restore_session doesn't bring a deleted name back; define_variable recreates it. Returns {deleted, scope_sheet, defined_names}, the last being every name left. To see the names first, use inspect_model.
inspect_modelNur lesendSummarize a session's structure: each sheet's index, name and used rows and columns, every defined name with its target, the iterative-calc settings, and counts of cells, memory, edit events and commits. Use it to find your way around a workbook before reading or editing it: sheet indexes for rename_sheet, delete_sheet and define_variable, names for get_outputs and set_inputs. include_edges adds every formula dependency edge, which is large on big models; to follow the chain from one cell use trace_dependencies instead. For errors, plugs and broken references use audit_workbook.
export_workbookNur lesendGet a session's workbook back as an .xlsx file with every formula's computed value saved in it. Recalculates first. Call this when you need the file itself: to give it to the user, or to read it with pandas, openpyxl (data_only=True) or any tool that is not Excel. Returns file_base64 and a summary of formula errors (#REF!, #DIV/0!, #NAME? with sheet and cell) and of anything that did not survive the save. Everything Basis does not model (styles, charts, images, data validation, defined names, comments, VBA) is carried over from the original file unchanged.
recalc_workbookNur lesendRecalculate an .xlsx file (or a .csv, returned as .xlsx) and return it with the computed values saved in every formula cell. Use this after you create or edit a workbook with openpyxl or any other library that writes formulas without results: those files have no cached values, so pandas, openpyxl (data_only=True) and other readers see empty cells until the file is recalculated. Replaces running LibreOffice recalc.py. Returns file_base64 plus a summary of formula errors (#REF!, #DIV/0!, #NAME?, #VALUE!... with sheet and cell) and of formulas Basis could not compute: fix those and call again. Styles, charts, images, data validation, defined names, comments and VBA are carried over unchanged. Pass exactly one of url or base64.
get_formula_rangeNur lesendRead the formulas and computed values of one cell or a rectangular range in a session: the way to check what a cell or a block of cells computes. Pass a single cell ("B4", "Sheet1!B4") or a range ("A1:D10"). Returns {worksheet, range, cell_count, cells: [{cell, formula, value, value_type}]}, with formula including its leading "=" (null for constants and empty cells) and value_type "number", "string", "boolean", "error" or "empty". Read a block in one call rather than cell by cell; to read values by defined name use get_outputs, and for the cells that feed one use trace_dependencies. Every cell in the rectangle is returned, up to 2,000 cells a call; a larger range fails with range_too_large, so read a big block in pieces. An unknown sheet or malformed range fails the call.
commit_sessionAktionCreate a named checkpoint of the session's current state, e.g. before a risky edit. Returns {commit_id, message, total_commits}; pass commit_id to restore_session to roll back. Every call adds a new checkpoint. Checkpoints live in the session only and are lost when it closes or expires; to keep one in the Library's version history, call save_to_library after it (the version takes this message as its name).
restore_sessionAktionRoll a session back to a checkpoint from commit_session: every cell edit made after it is undone, calc settings included, and the workbook is recalculated. Use it to throw away a what-if or a bad edit; it rewinds this session only and can't reopen a closed one. Returns {restored_to, cells_changed, calc, recalc}. A commit_id the session doesn't have fails the call. To compare two states without rolling back, export each with export_workbook and use diff_workbooks.
trace_dependenciesNur lesendFollow formula references from one cell in a session, breadth first, up to depth levels (1-5): direction "precedents" walks to the cells it reads, "dependents" to the cells that read it, and "both" (the default) does each. Returns {root, direction, max_depth, levels: [{depth, nodes: [{cell, formula, value, value_type}]}]} for one direction, or precedents and dependents (each a levels list) in place of levels for "both"; ranges are expanded to single cells and each cell is listed once per direction. Use it to explain where a number comes from, find the source of an error, or see what an input affects. For a cell's own formula use get_formula_range; for the whole graph at once use inspect_model with include_edges.
audit_workbookNur lesendCheck a session's whole workbook for modeling problems and return a JSON report: broken references, circular references and whether they converge, hardcoded plugs (a constant or odd formula breaking a run of consistent formulas), external links, volatile functions, hidden sheets and names, stale cached values, and a verification block comparing Basis's computed values with the ones Excel last saved. Recalculates first and changes nothing else. Use it as a health check before trusting or handing off a model; for structure only use inspect_model, for one value's lineage trace_dependencies, and to compare two files diff_workbooks.
save_to_libraryAktionSave the session's workbook to the user's Library for durable storage. If the session was loaded from the Library or was previously saved, this creates a new version of that file. Otherwise it creates a new Library file. Each save is a named version in the Library's history: pass `message`, or it takes the latest commit_session message since the last save. commit_session checkpoints themselves stay in the session, so save after each step you want kept as a version. Returns {library_file_id, version_id, name, message, created, noop}; noop is true when nothing changed since the last version. Open the file again later with create_session's library_file_id; list_library_files finds it.
list_library_filesNur lesendList the workbooks in the user's Library: the files this account owns, newest-updated first, including everything save_to_library saved. Use it to find a library_file_id to open with create_session, or to check that a save landed. Returns {files: [{library_file_id, name, size_bytes, created_at, updated_at, latest_version: {seq, message, created_at}}], truncated}, times in ISO 8601; latest_version is the newest saved version and its name. Pass query to match part of a file name (ignoring case) and limit for how many to return (1-200, default 50); truncated is true when more files match, so narrow the query or raise limit. Shared files and the trash are left out. Fails with library_unavailable when the Library isn't connected.
| set_calc_settings | Turn iterative calculation on or off for a session and recalculate. Needed for circular models (e.g. development pro formas where loan size depends on cost, which includes the loan's interest and fees): with it on, set_inputs re-converges the loop on every call. Saved with the session's next commit (restore_session to an earlier commit rolls it back) and written to the workbook, so an exported xlsx iterates in Excel too. Returns {calc, recalc}: the settings now in force and whether the model converged. | Aktion |
| get_outputs | Read computed values from a session by defined name, cell or range: the way to check what a model's formulas return, e.g. after set_inputs. Pass names as defined names, cell refs ("B4", "Sheet1!B4") or ranges ("Sheet1!H2:H18", up to 2,000 cells, one entry per cell); omit names to read every defined name. Returns {values: {<name or ref>: {cell, type, value}}}; a cell holding an Excel error comes back with type "error" and its code, not as a tool failure, while a key that isn't a defined name or valid ref fails the call. Values only: for formula text use get_formula_range, and to see what feeds a value use trace_dependencies. | Nur lesend |
| define_variable | Create a defined name for a cell, or repoint an existing one, so set_inputs and get_outputs can use a readable key ("Revenue") instead of a cell ref. A name that already exists in the same scope is overwritten with the new target; no cell's value or formula changes. Names follow Excel's rules (start with a letter, _ or \, no spaces, not a cell ref) and invalid ones fail the call. Returns {name, refers_to, defined_names}, the last being every name after the change. To remove a name use delete_variable; to see the existing names first, use inspect_model. | Aktion |
| delete_variable | Delete a defined name from a session's workbook, e.g. one you made with define_variable and no longer need. Only the name goes; the cell it pointed to keeps its value and formula. Match is by name, ignoring case, in workbook scope or, with scope_sheet, the name scoped to that sheet. A name still used by a formula is not deleted: the call fails with name_in_use and lists those cells, so rewrite them with set_inputs (or repoint the name with define_variable) first. A name that doesn't exist in that scope fails with not_found, and Excel's built-in names (print areas, filters) can't be deleted. restore_session doesn't bring a deleted name back; define_variable recreates it. Returns {deleted, scope_sheet, defined_names}, the last being every name left. To see the names first, use inspect_model. | Aktion |
| inspect_model | Summarize a session's structure: each sheet's index, name and used rows and columns, every defined name with its target, the iterative-calc settings, and counts of cells, memory, edit events and commits. Use it to find your way around a workbook before reading or editing it: sheet indexes for rename_sheet, delete_sheet and define_variable, names for get_outputs and set_inputs. include_edges adds every formula dependency edge, which is large on big models; to follow the chain from one cell use trace_dependencies instead. For errors, plugs and broken references use audit_workbook. | Nur lesend |
| export_workbook | Get a session's workbook back as an .xlsx file with every formula's computed value saved in it. Recalculates first. Call this when you need the file itself: to give it to the user, or to read it with pandas, openpyxl (data_only=True) or any tool that is not Excel. Returns file_base64 and a summary of formula errors (#REF!, #DIV/0!, #NAME? with sheet and cell) and of anything that did not survive the save. Everything Basis does not model (styles, charts, images, data validation, defined names, comments, VBA) is carried over from the original file unchanged. | Nur lesend |
| recalc_workbook | Recalculate an .xlsx file (or a .csv, returned as .xlsx) and return it with the computed values saved in every formula cell. Use this after you create or edit a workbook with openpyxl or any other library that writes formulas without results: those files have no cached values, so pandas, openpyxl (data_only=True) and other readers see empty cells until the file is recalculated. Replaces running LibreOffice recalc.py. Returns file_base64 plus a summary of formula errors (#REF!, #DIV/0!, #NAME?, #VALUE!... with sheet and cell) and of formulas Basis could not compute: fix those and call again. Styles, charts, images, data validation, defined names, comments and VBA are carried over unchanged. Pass exactly one of url or base64. | Nur lesend |
| get_formula_range | Read the formulas and computed values of one cell or a rectangular range in a session: the way to check what a cell or a block of cells computes. Pass a single cell ("B4", "Sheet1!B4") or a range ("A1:D10"). Returns {worksheet, range, cell_count, cells: [{cell, formula, value, value_type}]}, with formula including its leading "=" (null for constants and empty cells) and value_type "number", "string", "boolean", "error" or "empty". Read a block in one call rather than cell by cell; to read values by defined name use get_outputs, and for the cells that feed one use trace_dependencies. Every cell in the rectangle is returned, up to 2,000 cells a call; a larger range fails with range_too_large, so read a big block in pieces. An unknown sheet or malformed range fails the call. | Nur lesend |
| commit_session | Create a named checkpoint of the session's current state, e.g. before a risky edit. Returns {commit_id, message, total_commits}; pass commit_id to restore_session to roll back. Every call adds a new checkpoint. Checkpoints live in the session only and are lost when it closes or expires; to keep one in the Library's version history, call save_to_library after it (the version takes this message as its name). | Aktion |
| restore_session | Roll a session back to a checkpoint from commit_session: every cell edit made after it is undone, calc settings included, and the workbook is recalculated. Use it to throw away a what-if or a bad edit; it rewinds this session only and can't reopen a closed one. Returns {restored_to, cells_changed, calc, recalc}. A commit_id the session doesn't have fails the call. To compare two states without rolling back, export each with export_workbook and use diff_workbooks. | Aktion |
| trace_dependencies | Follow formula references from one cell in a session, breadth first, up to depth levels (1-5): direction "precedents" walks to the cells it reads, "dependents" to the cells that read it, and "both" (the default) does each. Returns {root, direction, max_depth, levels: [{depth, nodes: [{cell, formula, value, value_type}]}]} for one direction, or precedents and dependents (each a levels list) in place of levels for "both"; ranges are expanded to single cells and each cell is listed once per direction. Use it to explain where a number comes from, find the source of an error, or see what an input affects. For a cell's own formula use get_formula_range; for the whole graph at once use inspect_model with include_edges. | Nur lesend |
| audit_workbook | Check a session's whole workbook for modeling problems and return a JSON report: broken references, circular references and whether they converge, hardcoded plugs (a constant or odd formula breaking a run of consistent formulas), external links, volatile functions, hidden sheets and names, stale cached values, and a verification block comparing Basis's computed values with the ones Excel last saved. Recalculates first and changes nothing else. Use it as a health check before trusting or handing off a model; for structure only use inspect_model, for one value's lineage trace_dependencies, and to compare two files diff_workbooks. | Nur lesend |
| save_to_library | Save the session's workbook to the user's Library for durable storage. If the session was loaded from the Library or was previously saved, this creates a new version of that file. Otherwise it creates a new Library file. Each save is a named version in the Library's history: pass `message`, or it takes the latest commit_session message since the last save. commit_session checkpoints themselves stay in the session, so save after each step you want kept as a version. Returns {library_file_id, version_id, name, message, created, noop}; noop is true when nothing changed since the last version. Open the file again later with create_session's library_file_id; list_library_files finds it. | Aktion |
| list_library_files | List the workbooks in the user's Library: the files this account owns, newest-updated first, including everything save_to_library saved. Use it to find a library_file_id to open with create_session, or to check that a save landed. Returns {files: [{library_file_id, name, size_bytes, created_at, updated_at, latest_version: {seq, message, created_at}}], truncated}, times in ISO 8601; latest_version is the newest saved version and its name. Pass query to match part of a file name (ignoring case) and limit for how many to return (1-200, default 50); truncated is true when more files match, so narrow the query or raise limit. Shared files and the trash are left out. Fails with library_unavailable when the Library isn't connected. | Nur lesend |
Konfiguration
BASIS_API_KEYErforderlichSecretYour Basis API key, from https://api.basis1.tech
BASIS_BASE_URLBasis API base URL, to use a self-hosted server
| Name | Beschreibung | Typ |
|---|---|---|
| BASIS_API_KEY | Your Basis API key, from https://api.basis1.tech | ErforderlichSecret |
| BASIS_BASE_URL | Basis API base URL, to use a self-hosted server |
Automatisierte Checks
Geluften am 16. Nov. 2026Vollständiger Bericht →Unsere automatisierten Checks bestanden. Das ist kein Security-Audit: Lies den Code und gib dem Server nur den minimal notwendigen Zugriff. Wie die Checks funktionieren
- Source Repository verknüpft und erreichbarbasis1tech/basis-oss is public and reachablegithub.com/basis1tech/basis-oss ↗Bestanden
- Paket nennt dieses Repository als Quelle@basis1/mcp names basis1tech/basis-oss as sourcenpmjs.com/package/@basis1/mcp ↗Bestanden
- Build-Provenienz (Sigstore-Attestierung)Sigstore attestation for @basis1/mcpnpmjs.com/package/@basis1/mcp/v/0.3.2#provenance ↗Bestanden
- Open Source Lizenz (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Bestanden
- Commit oder Release im letzten JahrLast commit or release 2026-11-15github.com/basis1tech/basis-oss ↗Bestanden
- OpenSSF ScorecardNicht geprüft
- Package-Name ähnelt keinem populären PackageNo popular package one edit away from @basis1/mcpBestanden
- Keine kritischen Advisories im Paket oder seinen Abhängigkeitenthe package checked; no critical advisoryosv.dev ↗Bestanden
- Keine versteckten Anweisungen an das Modell26 tool descriptions and the README read; no override phrases, credential paths or hidden charactersBestanden
- Destruktive Tools sind markiertDestructive tools carry destructiveHintBestanden
- Remote-Endpoint beantwortet den MCP-Handshakeinitialize answered with protocol 2025-11-25 in 58 ms; tools/list returned 26 toolsBestanden
README
Auf GitHub ansehen@basis1/mcp
The Excel engine for AI agents. Let AI agents read, check and edit Excel models.
An MCP server for Basis. It lets Claude, Cursor and other MCP clients parse Excel workbooks, evaluate formulas, trace dependencies, and open a workbook as a session to change inputs and read results.
Every tool runs on the Basis API. You need a Basis API key and a network connection, and the workbooks you give a tool are uploaded to the Basis API at https://api.basis1.tech. See What gets uploaded.
Install
You need Node.js 20.19 or later and a Basis API key, which you create yourself in your account settings at basis1.tech/settings. Each snippet below starts the server with npx, which downloads the package the first time.
One-click install (you'll paste your API key afterwards in Cursor, or be asked for it in VS Code):
Claude Desktop
Open Settings → Developer → Edit Config and add this to claude_desktop_config.json, then restart Claude Desktop:
{
"mcpServers": {
"basis": {
"command": "npx",
"args": ["-y", "@basis1/mcp"],
"env": {
"BASIS_API_KEY": "your-api-key"
}
}
}
}
Claude Code
claude mcp add basis --env BASIS_API_KEY=your-api-key -- npx -y @basis1/mcp
Add --scope user to use it in every project, or --scope project to share it through the project's .mcp.json. In a shared file, write "BASIS_API_KEY": "${BASIS_API_KEY}" so each person's key comes from their own environment.
Cursor
Add this to ~/.cursor/mcp.json, or to .cursor/mcp.json in a project:
{
"mcpServers": {
"basis": {
"command": "npx",
"args": ["-y", "@basis1/mcp"],
"env": {
"BASIS_API_KEY": "your-api-key"
}
}
}
}
Other MCP clients
Configure a stdio server with the command npx and the arguments -y @basis1/mcp, and set BASIS_API_KEY in its environment. On Windows, if your client can't start npx directly, use the command cmd with the arguments /c npx -y @basis1/mcp.
Without installing anything: the hosted endpoint
The hosted endpoint is https://api.basis1.tech/mcp. Clients that support remote MCP servers can connect to it directly instead of running this package, in one of two ways: by signing in to Basis, or with an API key.
Sign in (Claude, Claude Desktop, Claude mobile, and other clients that support MCP authorization). No API key to copy:
- Claude (claude.ai, Desktop, mobile): open Customize → Connectors, choose Add custom connector, enter
https://api.basis1.tech/mcp, and select Connect. You'll be sent to basis1.tech to sign in (or create an account) and approve the connection. - Claude Code:
claude mcp add --transport http basis https://api.basis1.tech/mcp, then run/mcpin a session and pick basis to sign in. - Other clients: add
https://api.basis1.tech/mcpas a remote (streamable HTTP) server without anAuthorizationheader. The client finds the sign-in page by itself (OAuth 2.1 with PKCE, as the MCP authorization specification describes).
Your account's email must be confirmed before an app can connect. Listing the tools works before you sign in; the first tool call asks you to sign in. Connected apps share your account's free monthly allowance, and you can see and disconnect them in Settings.
API key. If your client supports custom headers, send your key instead:
{
"mcpServers": {
"basis": {
"type": "http",
"url": "https://api.basis1.tech/mcp",
"headers": { "Authorization": "Bearer your-api-key" }
}
}
}
In Claude Code: claude mcp add --transport http basis https://api.basis1.tech/mcp --header "Authorization: Bearer your-api-key".
It offers the same tools, except that it can't read files on your computer: pass a url or base64 instead of a path. This package adds path support by reading the file on your machine and uploading it for you.
Settings
| Variable | Default | What it does |
|---|---|---|
BASIS_API_KEY |
none (required) | Your Basis API key. Without it the server still starts, and every tool tells you the key is missing. |
BASIS_BASE_URL |
https://api.basis1.tech |
The Basis API to use, for example a self-hosted server. It must use https:// unless it points at localhost, so your key is never sent unencrypted. |
BASIS_MCP_MAX_FETCH_BYTES |
200000000 |
The largest workbook a tool will download when you pass a url. |
BASIS_TOKEN, the old name for the key, still works and logs a reminder to rename it.
If a setting is invalid, the server doesn't start: it writes what to fix to stderr, which your MCP client shows in its server logs (Claude Desktop: Settings → Developer, or ~/Library/Logs/Claude/mcp-server-basis.log on macOS). The server writes diagnostics only to stderr, because stdout carries the MCP protocol, and it never prints your key.
npx -y @basis1/mcp --help lists these settings, and --version prints the version.
Tools
Workbook inputs accept exactly one of path (a file on your computer), url or base64.
Parsing
parse_workbook: returns the workbook as NDJSON records (workbook_meta,sheet,cell,edge,image,image_summary,audit). Large files run as a background job and are polled to completion for you.submit_job: starts a parse job and returns its handle (job_id,status_url,stream_url) without waiting.stream_job: the NDJSON output of a finished job, optionally from recordsince.wait_seconds(up to 60) waits for a job that is still running;status_only: truereturns the job's status instead.diff_workbooks: cell-level differences between two workbooks: added, removed and changed cells (value and/or formula), with format-only changes listed separately. Takesbefore_*andafter_*inputs andinclude_format.
Formulas
evaluate_formula: evaluates one Excel formula against cell values you pass, for example{"formula": "NPV(0.08,A1:A5)", "data": {"A1": 100, ...}}. Values keep their Excel types:true/falseare logical cells and a string such as"#N/A"is that error, soSUM,AVERAGEandCOUNTtreat them as a workbook would. Supports 278 Excel functions, including financial, statistical, lookup and dynamic-array functions.
Recalculating a file
recalc_workbook: takes an.xlsx(path,urlorbase64) and returns it with computed values saved in every formula cell, plus the same error summary. Call it after you create or edit a workbook with openpyxl (or any library that saves formulas without results): without it, pandas, openpyxldata_only=Trueand other readers that are not Excel see empty cells. It replaces running LibreOffice'srecalc.py. Passoutput_pathto write the result on your computer; the same path as the input withoverwrite: truerecalculates a file in place. The file is uploaded for the calculation and not kept.
Both file-returning tools carry over what Basis does not model (styles, charts, images, data validation, conditional formats, defined names, comments, VBA in .xlsm) byte for byte. What cannot be kept is listed under summary.warnings: per-word formatting inside a cell's text, what-if data tables, and the cached results of multi-cell array formulas. Formulas Basis cannot compute are listed under summary.uncomputed instead of being saved blank without notice.
Workbook sessions. A session holds one workbook open on the Basis API so you can change it step by step.
create_session: opens a workbook frompath,url,base64or your Library (library_file_id), or starts a blank one. Optionalcalcturns on iterative calculation. A localpathtravels inside one request, so files over about 24 MB can't open as a session yet;parse_workbookhandles large files.list_sessions,close_session.set_inputs: sets values or formulas by defined name or cell reference, recalculates, and reports which named outputs changed.get_outputs: reads computed values by name, cell reference or range (Sheet1!H2:H18), or every defined name.define_variable: creates or retargets a defined name.delete_variable: deletes a defined name that no formula uses (it lists the formulas that still do).add_sheet: adds a sheet to a blank workbook.rename_sheet: renames a sheet; formulas, defined names and validations that point at it follow the new name.delete_sheet: deletes a sheet the way Excel does: formulas elsewhere that referenced it read#REF!, names scoped to it go, and later sheets move down one index. It lists the formulas and names that broke, refuses the last sheet, and can't be undone withrestore_session.set_calc_settings: turns iterative calculation on or off for circular models.inspect_model: sheets, defined names, calculation settings and statistics, optionally with the dependency graph.get_formula_range: formulas and values for one cell (B4) or a range (A1:D10), up to 2,000 cells a call.trace_dependencies: precedents, dependents or both for a cell, up to 5 levels deep.audit_workbook: a structural audit (errors, broken references, cycles, named ranges).commit_session,restore_session: named checkpoints and rollback.export_workbook: recalculates the session and returns it as an.xlsxwith every formula's computed value saved in the file, plus a summary of formula errors (#REF!,#DIV/0!,#NAME?with sheet and cell). Passoutput_pathto write the file on your computer instead of getting base64 back (overwrite: trueto replace an existing file).save_to_library: saves the workbook to your Basis Library as a new file or a new version.list_library_files: lists the workbooks in your Library, newest first, optionally filtered by name, so you can reopen one withcreate_session'slibrary_file_id.
Tool errors come back as a tool result with isError set and a JSON body {"code", "message", "status"}, for example missing_api_key, unauthorized, network_error, session_not_found or one of the API's error codes.
What gets uploaded
- Parsing and diffing: the workbook is sent to the Basis API. Parse jobs and their results are kept in the server's memory only and expire after 15 minutes.
- Formulas: the formula and the cell values you pass are sent to the Basis API.
- Sessions: the workbook is uploaded when you create the session and stays on the Basis API while you work. A session closes after 30 minutes without use, or when you call
close_session. So that sessions survive server restarts, their state is also checkpointed to private cloud storage, which deletes checkpoints within a day. - Library:
save_to_librarystores the workbook in your Library until you delete it. - Files on your computer: a tool reads a
pathyou pass and uploads that file's contents. It reads nothing else. - URLs: this package downloads a
urlyou pass toparse_workbook,submit_jobordiff_workbookson your machine and uploads the bytes. For sessions, the Basis API downloads the URL itself.
All traffic uses HTTPS, with your API key in the Authorization header. If your workbooks can't leave your machine, don't use this server with them.
Development
From a checkout of this repository:
(cd ../sdk && npm ci && npm run build) # @basis1/parse, linked as file:../sdk
npm ci
npm run build # typecheck, then bundle dist/index.js
npm test # unit, hosted forwarding and stdio handshake tests
npm run test:pack # pack, install in a temp dir, MCP handshake over stdio
To run your build against another Basis server, for example a self-hosted one:
BASIS_API_KEY=devtoken BASIS_BASE_URL=http://localhost:8080 node dist/index.js
How the package is built
dist/index.js is a single esbuild bundle that includes @modelcontextprotocol/sdk and zod (both MIT). As runtime dependencies they would install 95 packages (23 MB) on every first npx run, including web-server frameworks a stdio server never uses. Bundled, npx installs two packages and runs the exact versions we tested. Their license texts ship in dist/THIRD_PARTY_LICENSES.txt, and the build fails if a bundled package isn't permissively licensed.
@basis1/parse is a real runtime dependency, not bundled. In the repository it's file:../sdk. The release process rewrites that to ^<sdk version> before publishing, and scripts/check-publishable.mjs refuses a package that still has a local path.
Releasing
Releases are published by the maintainers. When a change touches both packages, the SDK is released first, then the MCP server, which depends on the published SDK version. version is kept in sync between package.json and server.json.
MCP Registry
server.json describes this server for the MCP Registry as tech.basis1/mcp, and mcpName in package.json links the npm package to it. The tech.basis1/ namespace belongs to the basis1.tech domain rather than a personal GitHub account, so the registry verifies it through DNS. Nothing is submitted automatically.
The maintainers list each release in the registry after the npm publish, signing in with mcp-publisher login dns --domain basis1.tech. The tech.basis1/ namespace is verified through a DNS record on basis1.tech.
License
Apache-2.0. See LICENSE.
Basis MCP Fragen
Wie füge ich Basis MCP zu Claude Code hinzu?
Führe claude mcp add --env 'BASIS_API_KEY=<YOUR_BASIS_API_KEY>' mcp -- npx -y @basis1/mcp in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich Basis MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Welche Tools bietet Basis MCP?
Er stellt 26 Tools bereit, darunter parse_workbook, submit_job, stream_job, diff_workbooks, evaluate_formula.
Was kann der Basis MCP server mit Excel-Dateien machen?
Er ermöglicht es KI-Agenten, Workbooks zu parsen, Formeln auszuwerten (unterstützt 278 Excel-Funktionen), Abhängigkeiten zu verfolgen und interaktive Sessions zu verwalten, um Inputs zu ändern und Ergebnisse auszulesen.
Benötige ich einen API-Key, um Basis zu nutzen?
Ja, du benötigst einen Basis API-Key, um die Tools auszuführen. Diesen kannst du in deinen Account-Einstellungen unter basis1.tech erstellen.
Wie werden meine lokalen Dateien behandelt?
Der Server liest die Datei unter dem von dir angegebenen Pfad und lädt den Inhalt zur Verarbeitung an die Basis API hoch; er liest nichts anderes auf deinem Computer aus.