Account, vocabulary and memory

Two scopes act on the account the token belongs to:

• account:read (Account, See balance and settings): the balance, the settings, the vocabulary and Lobbe’s memory.
• account:write (Account, Change settings): three settings, the vocabulary, and editing or deleting memory notes.

The account

GET /account:

curl https://app.lobbe.ai/api/v1/account \
  -H "Authorization: Bearer $LOBBE_TOKEN"

{
  "schemaVersion": 1,
  "owner": { "type": "user", "id": "USER_ID", "displayName": "Sara" },
  "wallet": { "balanceMinutes": 312 },
  "settings": {
    "speakerNamingMode": "FORCE_ON",
    "memoryLearningEnabled": true,
    "summaryEmailEnabled": false,
    "uiLocale": "fa"
  }
}

• Never the phone number or the email address. displayName is the owner’s name, or null when no name was set: a phone number is never sent in its place.
• wallet.balanceMinutes is the balance in minutes. It doesn’t take out meetings whose transcript isn’t ready yet: see Running short.
• settings.uiLocale is the app’s language. A token reads it but can’t change it.

Settings

PATCH /account/settings changes three settings, the same ones as in the app’s Account:

Field	In the app	Values
speakerNamingMode	Name speakers	FORCE_ON (Ask), AUTO (Ask, but don’t wait) or FORCE_OFF (Auto-guess): see Speaker naming
memoryLearningEnabled	Learn from new meetings, in Lobbe’s memory	true or false. false stops the learning only: the notes already kept are still used
summaryEmailEnabled	Email me after each meeting	true or false. Each new Lobbe is emailed to the owner with its PDF, never again when it is made again, and never while the account has no email address (only the app sets one)

curl -X PATCH https://app.lobbe.ai/api/v1/account/settings \
  -H "Authorization: Bearer $LOBBE_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "speakerNamingMode": "AUTO" }'

• Send one, two or all three. A field you leave out keeps its value.
• Nothing else. A body with any other field, uiLocale included, answers 400 VALIDATION and nothing is written, not even the fields that were right. So does an empty body.
• The answer is the whole account, as GET /account gives it.
• A meeting reads the naming setting when its transcript is ready, so a change applies to the meetings whose transcript is ready after it.

Everything else about the account (the name, phone number, email, password, sign-in sessions, Delete audio after the Lobbe, the language) stays in the app: see What no token can do.

Vocabulary

The vocabulary (My vocabulary in the app) is the names and terms transcription should recognize: up to 100 of them.

• GET /account/keyterms reads it, as { "schemaVersion": 1, "keyterms": […] }.
• PUT /account/keyterms replaces it: send the whole new list. To add one term, read the list, add it, and write the list back.

rm -f keyterms.json new.json
curl -sS --fail-with-body https://app.lobbe.ai/api/v1/account/keyterms \
  -H "Authorization: Bearer $LOBBE_TOKEN" -o keyterms.json || cat keyterms.json
jq -e '{ keyterms: ((.keyterms | arrays) + ["Kubernetes"]) }' keyterms.json >new.json &&
  curl -sS --fail-with-body -X PUT https://app.lobbe.ai/api/v1/account/keyterms \
    -H "Authorization: Bearer $LOBBE_TOKEN" \
    -H "Content-Type: application/json" \
    -d @new.json

If the read fails, jq -e finds no list and the write never runs: a failed read can’t wipe the list.

The rules

• Each term is trimmed, and its runs of spaces become one.
• Then: at most 100 terms; each 1 to 49 characters and at most 5 words; none containing <, >, {, }, [, ] or \; and no term twice.
• A list that breaks a rule answers 400 VALIDATION and nothing is written. message names the first problem: empty, too_long, too_many_words, forbidden_chars or duplicate, or, for more than 100 terms, says so in words.

Where it is used

• A meeting in no series is transcribed with the account’s vocabulary.
• A meeting in a series uses the series’ own words first, then the account’s when the series has inheritAccountKeyterms: true, up to 100 terms in all: see Series.
• Each meeting keeps the words it was sent with, so a new list changes only later meetings.
• A meeting that uses vocabulary costs more. Writing the list spends nothing, but each later meeting that uses it carries the vocabulary surcharge: see What spends. A meeting sent with useKeyterms=off uses none, and pays none.

Memory

Lobbe learns a few things from your meetings, about you, the people you meet with and your terms, and keeps them as notes (Lobbe’s memory in the app). It reads them as background when it writes a Lobbe and when it answers an Ask, so they come out more accurate.

Reading it

GET /account/memory:

{
  "schemaVersion": 1,
  "memoryEnabled": true,
  "items": [
    {
      "id": "ITEM_ID",
      "category": "PEOPLE",
      "text": "Reza leads the Android team.",
      "meetingCount": 4,
      "pinned": false
    }
  ]
}

• category is the note’s section: ABOUT_YOU (About you), PEOPLE (People you meet with) or TERMS (Your terminology).
• meetingCount is how many meetings it was learned from.
• pinned is true once the owner, or a token, edited it.
• While memory is switched off in Lobbe, memoryEnabled is false and items is empty.

Editing and deleting

• PATCH /account/memory/{id} with { "text": "…" } rewrites one note and answers { "schemaVersion": 1, "item": … }. The text is trimmed, and must be at least 1 character and within the app’s limit for a note: longer answers 400 VALIDATION. A text another note in the same section already has answers 409 MEMORY_DUPLICATE.
• DELETE /account/memory/{id} deletes one note for good and answers { "schemaVersion": 1, "id": "ITEM_ID", "deleted": true }. A later meeting may teach it again.
• An id that isn’t one of your notes answers 404.
• While memory is switched off, both answer 409 MEMORY_DISABLED: a write never pretends to work.

curl -X DELETE https://app.lobbe.ai/api/v1/account/memory/ITEM_ID \
  -H "Authorization: Bearer $LOBBE_TOKEN"

An edited note is pinned, and goes into everything

Editing a note pins it. From then on Lobbe never rewrites or removes it, and it goes into every Lobbe and every Ask made for you, until someone deletes it.

So a token with account:write can put any text, up to the note limit, into everything Lobbe writes for you. Give account:write only to a tool you trust. Every change a token makes shows in its activity in Connections, and you can read and delete every note in the app: Account, then Lobbe’s memory.

To stop Lobbe learning new notes, set memoryLearningEnabled to false. That doesn’t stop the notes already kept from being used: to stop one, delete it.

Note

Sending meetings, creating and editing series, changing settings, search and Ask through a token are being switched on gradually. If the form in Connections doesn’t offer a scope, it isn’t available to your account yet.