GeniffyDocs
Changelog Log In Get a key

People

Geniffy files what it learns under the people and things it is about. Three calls read it back that way: profile() for what is true about someone, brief() for what to read before dealing with them, and graph() for what connects to what.

profile: what is true about someone

card = mem.profile("Priya Nair")
for trait in card["lasting"]:
    print(trait["statement"])

lasting holds what stays true about them, and current what is going on just now. Each item has the sentence it rests on (statement), what it is about (topic, such as employer or job_title), the group it falls in (bucket, such as work or preferences), since when it has held, and clash when two memories disagree about it. grouped lists the memory ids under each bucket, and memories counts them.

{
  "subject": "priya nair",
  "lasting": [
    { "fact_id": 115, "topic": "employer", "bucket": "work", "value": "Lumen Labs",
      "statement": "Priya Nair works at Lumen Labs.", "since": "2026-10-05T03:50:55+00:00",
      "until": null, "clash": false, "inference": false, "corroborations": 1 }
  ],
  "current": [],
  "grouped": { "work": [115, 114, 111], "preferences": [113] },
  "memories": 4
}

Your own sections

A profile is grouped into 13 built-in sections, such as work, health and preferences. Add your own, and a memory goes in it when one of its keywords appears in it, or its topic is one of the section's. On your plain client a section is for every one of your users; on a client bound to one user, for that user only.

client.sections.create("billing", keywords=["invoice", "refund", "plan"], description="Plans and invoices")
client.space("customer_42").sections.create("allergies", topics=["diet"])
client.sections.list()          # yours first, then the built-in ones, each with whom it applies to

A section with a built-in one's name replaces it. Sent again under its name, a section is updated, and profiles regroup within a minute or so. Over HTTP: GET, POST and DELETE /v1/profile/sections.

brief: what to read first

brief = mem.brief("Priya Nair", limit=20)

The memories about someone, newest and most load-bearing first, each with where it came from, up to limit (1 to 200, default 60). total counts them, and summary is a short paragraph about them when there is enough to write one, or null.

graph: who is who, and how they connect

g = mem.graph()

nodes are the people, companies, projects, products and places the memory knows, each with its type (person, organization, project, product, place, or thing while it is not known yet) and how many memories are about it. The memory's owner is one node, you, however the memories name them.

edges are lasting relations a memory states, read from from: Arjun Rao works at Ringg. A line holds only while its memory does, so when Arjun moves to another company the line moves with him, and an event ("met Omar at the summit") stays a memory, never a line. Every edge carries the ids of the memories behind it.

{ "from": "12", "to": "15", "label": "works at", "memory_ids": [111], "current": true }
  • What changed. GET /v1/graph?history=true adds the lines that no longer hold, each with current: false and until, the day it stopped.
  • The same one twice. Two records that may be one person (Priya, and later Priya Nair) are listed in possible_duplicates and never merged on a name alone. POST /v1/graph/duplicates/{id} with {"same": true} merges them under the fuller name, and {"same": false} keeps them apart for good. A merge can be undone with POST /v1/graph/merges/{merge_id}/undo. A company under another legal form (Haptik, Haptik Inc.) is one company from the start.
  • Older memories. Memories added before types existed are sorted once, the first time the graph is read, and typing is true until that is done, usually within a minute.

See GET /v1/graph for every field.

All three read one memory: yours, or the space the client is bound to.

Last updated November 2, 2026