RoboSystems
Browse technical docs

Technical documentation

Get started

Every example here runs against the hosted API at https://api.robosystems.ai. RoboSystems is also open source, and the last two steps run it on your own machine or in your own AWS account. Each step links to the page that covers it in full.

Create an account and API key

Sign up, then create a key under Settings → API keys. A key can reach all your graphs or just one, and it is shown once, so put it in your environment straight away.

export ROBOSYSTEMS_API_KEY=rfs...

Full guide: Authentication & API Keys.

Make your first request

Send the key in the X-API-Key header. List the graphs you can reach, then query one with Cypher. A graph comes from Create Graph in the app, from connecting QuickBooks in RoboLedger, or from a subscription to the SEC repository, whose graph id is sec.

curl -H "X-API-Key: $ROBOSYSTEMS_API_KEY" https://api.robosystems.ai/v1/graphs
export GRAPH_ID=kg...   # a graphId from that list

curl -X POST "https://api.robosystems.ai/v1/graphs/$GRAPH_ID/query/cypher" \
  -H "X-API-Key: $ROBOSYSTEMS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "MATCH (n) RETURN labels(n) AS label, count(*) AS count"}'

Full guides: Quick Start and Querying the Analytical Graph.

Connect an MCP client

Every graph is a remote MCP server, and one address reaches all of them. Your client sends you to RoboSystems to sign in, and you choose the graph on the consent screen. There is no key to copy.

https://api.robosystems.ai/v1/mcp

It's a standard remote MCP server, so there is nothing to install: add the address as a connector in Claude, ChatGPT, Grok, Cursor, VS Code or any other MCP client, and sign in. In Claude Code it is one command:

claude mcp add --transport http robosystems https://api.robosystems.ai/v1/mcp

Scripts, CI and clients that can't sign in pin one graph in the URL and send an API key instead. Use your graph id, or sec for the public SEC repository.

URL:    https://api.robosystems.ai/v1/graphs/{GRAPH_ID}/mcp
Header: X-API-Key: <your API key>

Then ask in plain language. On the SEC repository:

  • “Show me this company's revenue for the last five years.”
  • “Compare gross margin across the last eight quarters.”
  • “Which filers mention goodwill impairment in their latest 10-K?”

On your own graph:

  • “What's blocking the month-end close?”
  • “Show me last quarter's income statement.”
  • “Which accounts are still unmapped?”
  • “Remember what we found about margins so we can pick it up next time.”
  • “Create a subgraph so we can try a different model without touching the main graph.”

Full guide: AI Operators & MCP.

Client libraries

  • Python: pip install robosystems-client (PyPI, GitHub)
  • TypeScript: npm install @robosystems/client (npm, GitHub)
  • MCP stdio bridge: @robosystems/mcp, for clients that only run local MCP servers (GitHub)
  • Integration template: connect your own data source from its own repository, through the public API, so it survives every upgrade and works against managed and self-hosted deployments alike (GitHub)

The SDKs are generated from the live OpenAPI spec. Full guide: Building Custom Integrations.

Run the stack locally

You need Docker, uv and just. One command starts the API, the graph database, PostgreSQL, Valkey and the orchestrator, and every example in these docs then works against http://localhost:8000 with the demo account's key. SEC filings are free locally: load the companies you want by ticker.

git clone https://github.com/RoboFinSystems/robosystems.git
cd robosystems
brew install uv just
just start               # the API answers at http://localhost:8000
just demo-user           # a demo account and API key, written to .local/config.json
just sec-load <TICKER>   # every available year for one company; add a year to load one

Full guides: Local Development and SEC XBRL Pipeline.

Deploy to your AWS account

A fork deploys itself with GitHub Actions and CloudFormation. GitHub signs in to AWS through OIDC, so no long-lived AWS credentials are stored in GitHub. Bootstrap creates the identity provider, the deploy roles, the container registry and the repository's variables.

aws configure sso --profile robosystems-sso
just bootstrap
just deploy prod

The API deploys private by default, reachable only from inside the VPC. Public mode puts it behind an internet-facing load balancer with TLS on your own domain. Full guide: Bootstrap Guide.

RoboSystems is an open-source, AI-native financial intelligence platform for accounting, financial reporting, and investment management. It unifies structured data, document search, and AI memory over a knowledge graph — transactions, facts, reporting elements, and the calculation structures that relate them are all nodes and edges, with the semantics preserved rather than flattened into rows you query around. On top of that graph it gives AI agents and analysts a ledger-grade system of record they can both query and operate — closing the books, producing reports, and analyzing portfolios across your own ledger, your holdings, and SEC public filings queryable alongside them. It powers RoboLedger and RoboInvestor.

Every tenant gets their own graph — not a row-level slice of a shared table, but a dedicated graph database on its own instance with a dedicated OLTP schema behind it. Your ontology, your taxonomies, and your calculation structures live in it as artifacts you can read, export, and take with you.

The platform is fork-ready. The repository ships full GitHub Actions CI/CD that deploys the CloudFormation infrastructure into your own AWS account — see the Bootstrap Guide to stand up a deployment of your own.

This wiki is the technical documentation for using, operating, and building on the platform. Its examples call the hosted API at https://api.robosystems.ai; to run the platform yourself, start with Local Development. It is organized by what you are doing: starting out, building on the API, connecting AI, querying the SEC repository, working with the RoboLedger and RoboInvestor extensions, the concepts underneath them, running your own stack, and hands-on demos.

Which docs do you need? To use RoboSystems, RoboLedger or RoboInvestor through Claude, ChatGPT or any MCP client, start with the product guides: robosystems.ai/docs/guides, roboledger.ai/docs and roboinvestor.ai/docs. To build on the platform or run it yourself, you are in the right place. For one endpoint's exact request and response, see the API reference.

Start Here

Orientation: which docs you need, a first authenticated call, the vocabulary, and the system design.

  • Quick Start - From a new account to your first authenticated query and a connected AI client
  • Core Concepts - The vocabulary: graphs, tiers, blocks, operators, operational vs analytical
  • Architecture Overview - System design and components

Build on the API

The contracts every integration relies on, and the core graph surface.

Connect AI, Documents & Search

The MCP server, the operators, and the document and memory planes.

Shared Repositories (SEC)

Platform-managed public datasets you subscribe to and query.

RoboLedger & RoboInvestor

The per-graph extensions: typed reads, command writes, and the workflows built on them.

Concepts in Depth

The financial-content model underneath the products. Each concept page has a reference page behind it.

Run It Yourself

Running, deploying, and operating your own stack.

Demos

Hands-on walkthroughs against a local stack.

Reference

Support