Helm7

Find the right row, then everything connected to it.

Your Postgres, searchable by meaning and walkable as a graph, with one copy of the data. Each is a switch on the database, off until you turn it on, and every switch shows its plan and its price first.

Search that explains itself.

One call runs four stages in one SQL statement: an exact match on a key is pinned first, keyword search and vector search each take their best 200, and the two are fused with reciprocal rank fusion. The fusion happens after the candidates are joined back to your table under your app's own role, so a row it cannot see never moves the rank of one it can.

Find rows by meaning, words and relationships. POST /v1/products/:productId/databases/:databaseId/search
database_search {
  "table": "support.tickets",
  "query": "kettle arrived broken",
  "k": 10,
  "traverse": {
    "max_depth": 1
  },
  "explain": true
}
  1. Example
  2. tickets
Example data
  1. Exact

    0 candidates

    0.4 ms

  2. Words

    12 candidates

    1.1 ms

  3. Meaning

    200 candidates

    18 ms

  4. Fused

    10 of 41 visible

    2.3 ms

  5. Related

    17 rows

    6.0 ms

  • Refund for broken kettlewords #1 · meaning #2
  • Lid will not open after first boilmeaning #1
  • Order 10427, two items1 hop · via fk:tickets_order_id_fkey

Your foreign keys already are a graph.

A customer has orders, an order has tickets, a ticket mentions a product. Turn relationships on and a traversal follows those foreign keys from any row, as one recursive query with cycles cut, at most four hops, at most 50 neighbours per row and 500 rows, under a five second limit. Columns that point somewhere without a constraint become virtual foreign keys, and links no column holds go in an edges table. A model can suggest those links; none is followed until somebody approves it.

Everything connected to a row. POST /v1/products/:productId/databases/:databaseId/graph/traverse
database_graph_traverse {
  "start": {
    "table": "customers",
    "pk": "4182"
  },
  "max_depth": 2,
  "fanout": 20
}
Link two rows. POST /v1/products/:productId/databases/:databaseId/graph/edges
database_edge_upsert {
  "from": {
    "table": "tickets",
    "pk": "9b1e…"
  },
  "to": {
    "table": "products",
    "pk": "77"
  },
  "label": "mentions"
}

Read more in the Postgres graph database guide and how this compares with Apache AGE.

Agent memory is just your database.

An agent's memory is facts, their sources and how they connect. That is rows and foreign keys. One call creates memory.items, makes it searchable and turns relationships on, so an agent can find the right memory by meaning and then pull in everything linked to it, in the same database as the product it remembers, backed up with it and scoped by the same keys. No memory service to run, pay for or keep in sync.

Creates memory.items and plans it first
database_semantic_enable {
  "template": "agent_memory",
  "dry_run": true
}
Semantic start, then everything linked to it
database_search {
  "table": "memory.items",
  "query": "what did the customer say about invoices",
  "where": {
    "scope_id": "prd_7k2m9x4qw1nv8bz3ct6d"
  },
  "traverse": {
    "max_depth": 2
  }
}

When a hosted memory service is the better fit, and when it is not: agent memory on Postgres.

An MCP server for your company's public data.

Choose a table, the columns a tool may use and, if it needs one, a row filter. Helm7 publishes an MCP server your users and their agents can connect to, running as two database roles of its own that can read nothing a tool does not name. Public tools need no credential; tools for signed-in users take the session token from your app's own sign-in.

Publish an MCP server over your data. POST /v1/products/:productId/databases/:databaseId/mcp
database_mcp_create {
  "name": "Acme catalogue",
  "tools": [
    {
      "name": "search_products",
      "kind": "search",
      "table": "products",
      "columns": [
        "id",
        "name",
        "description",
        "price"
      ],
      "row_filter": "published = true"
    },
    {
      "name": "my_orders",
      "kind": "list",
      "table": "orders",
      "columns": [
        "id",
        "status",
        "total"
      ],
      "row_filter": "customer_id = $user.sub",
      "auth": "end_user"
    }
  ]
}
  • Grants are column by column. Narrow a tool and the column is revoked before the next request.
  • A write tool pins what its row filter says, so nobody can write a row as somebody else.
  • Every request is one transaction with the caller set, so your row level security applies on top.
  • The URL is yours to hand out. Take it down and its roles are dropped at once; the URL answers 404 within seconds.

A worked example: build an MCP server for your company's data.

What it does to your database.

Everything lives in a helm7 schema owned by a role of its own: your app can read it but not alter it, and turning the last switch off removes it and its roles. Triggers queue changed keys; a worker re-reads those rows within a minute, skips any whose text is unchanged, and writes 512-dimension half-precision vectors. Below 50,000 rows a table is scanned exactly, in tens of milliseconds; above that an HNSW index is built concurrently, one at a time per server. Dropped a trigger in a migration? It is put back, and the status says so. Read the pgvector semantic search guide for the detail, or the API reference for every operation.

Questions about search and relationships.

  • Does this copy my data into a vector database or a graph database?

    No. The graph is your tables: a hop is a join along a foreign key. Search adds one small side table per searchable table in a helm7 schema inside the same database, holding the primary key, a hash and a 512-dimension vector. Backups, restores and your own SQL see it like any other table.

  • What leaves my database?

    Only the text of the columns you choose to embed, sent to llm11, which embeds it with OpenAI text-embedding-3-small. Relationships send nothing anywhere. The plan says which columns before you turn anything on.

  • What does it cost?

    Embedding is billed at cost: $0.02 per million tokens. A table of 10,000 rows at about 200 tokens a row is about 2 million tokens, or roughly 4 cents, once; after that only changed rows are embedded. The vectors are about 1 KB a row, billed as database storage. Relationships and the MCP server are free.

  • Is this Apache AGE?

    No. AGE keeps a graph in its own vertex and edge tables and queries it in Cypher. Helm7 treats the tables you already have as the graph and compiles traversals to recursive SQL, so there is no second copy to keep in sync and no extension your host has to support.

  • Can my users query it without seeing everything?

    Yes, through the generated MCP server. Each tool names a table, the columns it may use and a row filter such as owner_id = $user.sub. It runs as a database role that holds column grants for exactly those columns, with the signed-in user set on every request, so your row level security applies too.