Documentation

How to use BIKO memory, skills, rules, API keys and MCP. Sign in to create keys and open your workspace.

One shared memory. Any AI tool.

BIKO stores context that should outlive a single chat: facts, decisions, reusable skills and rules. People and agents retrieve the same records with source, author and time. It is a context layer — not a chatbot and not an autonomous agent builder.

Memory

What you know — compact events, decisions and corrections, linked to folders.

Skills

How you work — reusable Markdown procedures with revision history.

Rules

What to respect — versioned policies and structured checks. Text alone is not enforcement.

How it works

  1. 1

    Capture

    Create a folder, then save a fact or decision with a summary, tags and source. Add a skill or rule when needed.

  2. 2

    Store

    Records persist in managed PostgreSQL through server-side validation. BIKO stores small JSON fields and Markdown, not a large file archive.

  3. 3

    Review

    Open Review to see unread memory, skills and rules. Keep what should stay. Delete what should not. An edit makes an item unread again.

  4. 4

    Retrieve

    Search matches words in saved content. Folder context collects decisions, recent events, skills and active rules. Results are bounded and carry sources.

  5. 5

    Reuse

    Copy a context bundle into an AI tool, or call the REST API / MCP from a connector. Write outcomes or corrections back into BIKO when useful.

Retrieval uses full-text matching and recency, not embeddings or AI-written summaries. BIKO does not automatically read your chats or run your skills.

Example flows

Copy a prompt into a connected client. Each flow names a starter skill. Full set: Prompt library.

Connect

Confirm the workspace over MCP after you add the server in your client.

skill: connect-biko

Follow the BIKO skill connect-biko.

Connect my BIKO workspace over MCP at https://connectbiko.com/mcp. Call biko_status, tell me which workspace I can reach, and remind me I do not need to say BIKO for ordinary memory questions.

Save to the right folder

Resolve the folder before writing a decision or fact.

skill: resolve-project

Follow the BIKO skills resolve-project and record-decision.

Remember this for the team. Resolve the correct folder first, then write a short summary another teammate can read later. Return the stored source id.

MCP: https://connectbiko.com/mcp

Retrieve

Search shared memory and cite source ids.

skill: use-workspace-memory

Follow the BIKO skill use-workspace-memory.

Search our shared memory for what we already know about this, cite source ids, and say if nothing matches. Do not invent decisions.

MCP: https://connectbiko.com/mcp

Draft

Write from stored context, skills and rules.

skill: follow-team-skill

Follow the BIKO skills use-workspace-memory, follow-team-skill and respect-rules.

Draft from stored folder context only. Search first, load matching skills and rules, cite source ids, and say what was missing.

MCP: https://connectbiko.com/mcp

Review

Check rules or inspect what was just saved.

skill: respect-rules

Follow the BIKO skill use-workspace-memory.

Show me the most recent memory items you can find, with source ids and which folder each belongs to. If something looks wrong, say so. I will keep or delete items in the BIKO Review inbox.

MCP: https://connectbiko.com/mcp

MCP URL used in these prompts: https://connectbiko.com/mcp. Resolve the folder with list_projects before writing memory that belongs to one.

Ways to connect

1. Copy context (no code)

Open a folder → Context. Optionally add a task, retrieve, then copy Markdown or JSON into ChatGPT, Claude, Cursor or anywhere else. Manual handoff: retrieve again when your records change.

Sign in to open folders

2. REST API (your scripts & servers)

Create a personal API key, then call HTTPS endpoints with a bearer token. Good for custom agents, cron jobs, backends and any tool that can send HTTP. There is no automatic ChatGPT / Claude / Lovable plug-in for REST — you wire the requests.

API key guide

3. MCP (AI clients that support it)

Nine tools at https://connectbiko.com/mcp. The client signs in as your BIKO account; access follows workspace membership. Use this for ChatGPT, Claude, Cursor or any Streamable HTTP MCP client. Separate from the REST API.

MCP setup

Create and use an API key

Personal keys let you connect tools to your workspace. They are not shared across other members’ workspaces.

  1. 1

    Open Settings

    Go to Settings → API keys. You must be signed in as an invited member.

  2. 2

    Create a key

    Give it a clear name (for example “Cursor script”). You can have up to five active keys.

  3. 3

    Copy the secret once

    BIKO shows the full key only at creation. Store it in your tool’s secrets or a password manager. If you lose it, revoke and create another.

  4. 4

    Call the API

    Send Authorization: Bearer <your-key> to https://connectbiko.com/api/public/v1/…. Start with /status to confirm the key works.

  5. 5

    Revoke when done

    If a key leaks or a tool is retired, revoke it in Settings. Calls with that key then return 401.

Keep keys private. Never put them in a public repo, a shared context bundle, a URL, or browser JavaScript.

Scope. A key reaches every folder in your workspace. It does not reach other workspaces.

Writes. Personal keys may create events and execution logs in your workspace. Treat that like write access to your memory.

Sign in to open Settings

Key count and workspace status appear after you sign in. They are not shown on this public page.

REST API reference

JSON over HTTPS. Base path: https://connectbiko.com/api/public/v1

Authentication

Authorization: Bearer biko_…your-key…

Missing or invalid keys return 401. Rate limits return 429 with Retry-After.

1. Check the key

curl "https://connectbiko.com/api/public/v1/status" \
  --header "Authorization: Bearer $BIKO_API_KEY"

Expect JSON with ok: true, auth: "user", and your workspace_id.

2. Retrieve context for a folder

curl --get "https://connectbiko.com/api/public/v1/context" \
  --header "Authorization: Bearer $BIKO_API_KEY" \
  --data-urlencode "project_id=$PROJECT_ID" \
  --data-urlencode "task=write status update" \
  --data-urlencode "limit=15"

Get $PROJECT_ID from the app (folder URL) or from GET /projects.

3. Search memory

curl --get "https://connectbiko.com/api/public/v1/search" \
  --header "Authorization: Bearer $BIKO_API_KEY" \
  --data-urlencode "q=pricing decision" \
  --data-urlencode "limit=20"

4. Write a memory event

curl "https://connectbiko.com/api/public/v1/events" \
  --header "Authorization: Bearer $BIKO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "event_type": "decision",
    "summary": "Chose weekly digest over daily for client updates",
    "project_id": "'"$PROJECT_ID"'",
    "tags": ["comms"]
  }'

Common event_type values include decision, fact, correction and related memory kinds used in the app. Optional header X-Biko-Actor adds a short label in provenance only; the authenticated key still owns the call.

Endpoints

GET/status

Confirm your key works. Returns workspace id and whether writes are allowed.

GET/projects

List folders in your workspace (API path still says projects).

GET/projects/<uuid>

One folder with related overview data.

GET/search?q=…

Full-text search across memory. Optional project_id, limit, kinds.

GET/context?project_id=<uuid>&task=…

Bounded context bundle for an agent or handoff (decisions, events, skills, rules).

GET/skills

List skills. Append /<slug-or-id> for Markdown body and versions.

GET/rules?active_only=true

List rules. Optional project_id filter.

GET/events

List memory events. Optional q, event_type, project_id, limit.

POST/rules/<uuid>/check

Validate a JSON sample against a rule: {"sample":{…}}. Does not control an agent.

POST/events

Write a memory event into your workspace (personal keys allowed).

POST/executions

Log an agent run as an execution outcome (personal keys allowed).

Errors

  • 401 — missing or invalid API key
  • 400 — validation error (bad JSON or fields)
  • 404 — unknown path or record
  • 413 / 414 — body or query too large
  • 429 — too many requests; wait and retry

MCP connector

Hosted Streamable HTTP server. The client opens BIKO’s sign-in and consent screens (OAuth). After approval, tools run as your account and row-level security decides what they can see. MCP does not accept API keys. Use REST when you control the HTTP calls yourself.

MCP URL

https://connectbiko.com/mcp

You need a granted BIKO account. There is no public ChatGPT or Claude store listing yet. Add this URL as a custom connector in each client.

Tools

biko_status

Confirm the signed-in workspace and what it holds.

list_projects

List folders so you can pass project_id on writes.

search_context

Full-text search across memory, skills and rules.

get_project_context

Bounded folder bundle: decisions, recent events, skills and active rules.

write_event

Save one memory event (fact, decision or correction). Pass project_id when a folder matches.

record_execution

Log what an agent actually did.

list_skills

List skills the caller can see.

get_skill

Read one skill body by slug or id.

list_rules

List rules. Optional folder filter.

ChatGPT

Add the hosted server from chatgpt.com. ChatGPT on mobile cannot add a custom MCP server. After the same account has it on the web, Chat or Work on mobile can use that installed plugin.

  1. 1

    Open Plugins

    On chatgpt.com open Plugins. Select + then Add custom MCP server.

  2. 2

    Paste the URL

    Use the MCP URL below. Authentication: OAuth. Accept the risk warning and create the plugin.

  3. 3

    Sign in

    Connect a granted BIKO account. Approve the consent screen. Install the plugin.

  4. 4

    Ask in plain language

    Once connected, ChatGPT can search memory, fetch folder context, read skills and rules or write a memory event. You do not have to say BIKO. It will not attach the plugin to every unrelated chat.

ChatGPT MCP URL

https://connectbiko.com/mcp

A ZIP plugin package can also be uploaded as a draft. That is not a public listing until OpenAI review succeeds.

Claude

On claude.ai, Claude Desktop, Cowork and Claude mobile, add a custom connector. Claude reaches the public /mcp URL from Anthropic’s cloud. Team and Enterprise owners may need to add the connector for the organization first.

  1. 1

    Open Connectors

    Go to Customize → Connectors. Add a custom connector (Custom → Web, or Add custom connector on Pro and Max).

  2. 2

    Name and URL

    Name it BIKO. Paste the MCP URL. Continue past the detected auth settings.

  3. 3

    Authentication

    Choose Sign in now or Sign in when needed. For the OAuth client, use Register automatically or Claude’s published identity. Do not add an API key header. MCP is OAuth only.

  4. 4

    Connect

    Add the connector, then Connect. Sign in as a granted BIKO account and approve consent.

Claude MCP URL

https://connectbiko.com/mcp

Claude Code

From a terminal (not inside a Claude Code chat). The client will open BIKO sign-in when it connects.

Claude Code command

claude mcp add --transport http biko https://connectbiko.com/mcp

Or put this in the project .mcp.json. Claude Code needs "type": "http" on a URL entry.

Claude Code JSON

{
  "mcpServers": {
    "biko": {
      "type": "http",
      "url": "https://connectbiko.com/mcp"
    }
  }
}

Cursor

Cursor reads an mcp.json file and can complete OAuth in the browser. Put the snippet in the project at .cursor/mcp.json, or globally at ~/.cursor/mcp.json. You can also paste it from Cursor Settings → MCP.

Cursor mcp.json

{
  "mcpServers": {
    "biko": {
      "url": "https://connectbiko.com/mcp"
    }
  }
}
  1. 1

    Save the file

    Project config is shared with the repo. Global config applies to every project on this machine. If the same name appears in both, the project file wins.

  2. 2

    Connect

    In Cursor Settings → MCP, enable BIKO and connect. Sign in as a granted BIKO account and approve consent.

  3. 3

    Use it

    Ask Agent about stored decisions, folder context, skills or rules. Leave the JSON without an Authorization header. Cursor should use OAuth, not an API key.

Custom clients

Any MCP client that speaks Streamable HTTP can use the same URL. The server answers 401 without a token and advertises OAuth so the client can register (DCR) and send the user through BIKO sign-in.

MCP URL

https://connectbiko.com/mcp

Generic mcpServers JSON

{
  "mcpServers": {
    "biko": {
      "url": "https://connectbiko.com/mcp"
    }
  }
}

JSON with explicit HTTP type

{
  "mcpServers": {
    "biko": {
      "type": "http",
      "url": "https://connectbiko.com/mcp"
    }
  }
}

Transport. Streamable HTTP at https://connectbiko.com/mcp. This is not a local stdio process.

Auth. OAuth with dynamic client registration. Do not put a BIKO API key in headers. Keys belong on the REST API only.

Identity. Tools run as the signed-in member. They cannot reach a workspace that person does not belong to.

If the client cannot do MCP. Use the REST API with a personal key, or copy a folder context bundle from the app.

Current limits

  • Invite-only accounts; no public self-serve signup into a workspace.
  • API keys are workspace-wide for that member, not per-project ACLs.
  • No ChatGPT or Claude store listing yet. Add the hosted MCP URL as a custom connector. REST has no marketplace plug-in.
  • MCP is OAuth only. A personal API key will not authenticate /mcp.
  • Backups with tested restore, monitoring and an independent security review are not finished — avoid highly sensitive data until they are.