Cognitia AI
Documentation
Everything you need to know about using Cognitia AI, connecting your tools, and getting the most out of your AI assistant.
Product Overview
For Consumers
For Developers
For Businesses
For Consumers
For Developers
For Businesses
Getting Started
Start HereCreate Your Account
Visit the login page and create your account using one of three methods:
Google Sign-In -- One-click sign up with your Google account. Fastest way to get started.
iCloud Sign-In -- Sign up with your Apple ID for seamless iCloud integration.
Email & Password -- Create an account with any email address and a secure password.
All new accounts start with a free tier. No credit card required.
Connect Your First Integration
After signing in, navigate to the sidebar and connect your first service. We recommend starting with Gmail as it unlocks both email and calendar capabilities:
Click the Email & Calendar button in the sidebar
Select Gmail and authorize Cognitia to access your account
Once connected, you can ask Cognitia to search and recall your emails and Google Calendar
Send Your First Message
Navigate to the Chat page and start a conversation. Cognitia adapts to natural language -- just tell it what you need:
"Summarize my unread emails from today"
"What meetings do I have this week?"
"Search the web for the latest AI news"
"What did I spend on dining this month?"
Integrations Guide
MCP & backups
What is MCP & backups?
MCP & backups is where you install Cognitia as a memory MCP server in other apps and import assistant memory (ChatGPT, Claude, Gemini). Other apps call Cognitia’s MCP endpoint. Connecting generic remote MCP servers from Cognitia is turned off.
Key highlights:
Available to all subscription tiers
No additional cost beyond LLM credits
Use Cognitia from any MCP client
MCP Memory Layer
NewWhat's new
Recently shippedRecent additions to the memory layer and Memory Explorer:
Five-tool external MCP — Hosts get unified_memory_agent (Ask: context + optional evidence), unified_memory_retrieve (profile + scored entities, facts, and edges; optional evidence), origin-grant config, unified_memory_store, and unified_memory_forget. Specialty identity/temporal tools stay first-party.
Identity review queue — Approve or dismiss newly discovered identities before they join your graph.
Memory-conditioned image generation — Temporarily disabled. Returns in Q4 as multimodal memory (photos/video → identity), not a general image studio.
Photo identify — Upload a photo to find matching people already in your memory.
Retract a stored note — Call unified_memory_forget with the source_id from store. This does not delete a person or another client's notes. Forgetting a person is in Memory Explorer.
Manual & reviewed merge — Merge duplicate entities manually or from the merge-candidate review queue.
Device files — Browse and search files indexed from your connected devices.
What is the MCP Memory Layer?
The MCP Memory Layer lets you use the personal memory you've built with Cognitia from any external MCP-compatible client — including Cursor, Claude Desktop, Claude Code, Windsurf, and more. Your knowledge graph, conversation history, emails, files, financial data, social media, and multimodal identity data are all accessible through a single unified endpoint.
Instead of your memory being locked inside Cognitia, external AI agents can query it as context. For example, a coding agent in Cursor could retrieve your project-related knowledge, or Claude Desktop could recall your preferences and recent conversations.
Memory layers available:
Knowledge Graph
Entities & relationships
Temporal facts & timeline
Time travel (as-of / since)
Behavioral profile
Store new knowledge
Retract a stored note
Data Sources
Email search
Financial data
Social media
Cloud files
Multimodal (Pro)
Face recognition
Voice identification
Visual object matching
Quick Start
Connecting takes one step — add the Cognitia MCP endpoint URL to your client. OAuth handles everything else automatically.
Cursor / Claude Desktop / Claude Code
Add this to your MCP client configuration file:
{ "mcpServers": { "cognitia-memory": { "url": "https://www.cognitia-ai.com/api/mcp" } } }
Add the configuration above to your MCP client settings.
On first connection, your client opens a browser window. Log into Cognitia if prompted.
On the consent screen, choose fidelity for the five origin groups, then click Allow Access.
Done. The external client now has access under those origin groups. Token refresh is automatic.
Authentication
Cognitia's MCP server supports OAuth 2.1 with PKCE, the same industry-standard protocol used by Notion, Linear, and other MCP services. Clients that support OAuth (Cursor, Claude Desktop, Claude Code) handle the entire flow automatically.
OAuth 2.1 (automatic)
No tokens or API keys to manage. The client handles login, consent, token exchange, and automatic refresh. You just add the URL and approve the connection once.
Personal API key
For automation, scripts, or clients where you want a credential that does not expire every hour. Keys start with cog_usr_ and are sent the same way: Authorization: Bearer YOUR_KEY.
Create and revoke keys under MCP & backups → Personal API key. You can have up to five active keys; store them like any secret and revoke them if they leak.
Available Tools
External OAuth clients and personal API keys may call the six memory tools below, plus unified_memory_list for counts and complete lists. Specialty tools (identity search, memory_as_of / memory_diff, share cards) stay on the first-party app session.
Which tool to call
Call unified_memory_agent_config action=list once per session. Use unified_memory_retrieve for people, facts, or a profile. Use unified_memory_agent for a written answer, today's inbox, or calendar — set include_evidence when you will cite. Store only text the user asked to remember, and keep source_id. Call unified_memory_forget with that source_id to retract it. Do not invent tools that are not listed. Personal initialize also returns these instructions plus memory.ask / memory.retrieve / memory.remember / memory.forget prompts and cognitia://status / cognitia://profile.
Ask memory. Send a natural-language query; the server returns one synthesized context string. Use for freshness, mail, calendar, or a written answer — not to list entities. Pass include_evidence: true to attach evidence for sources the answer actually used. Each item includes snippet, locator, and an open URL only when a provider permalink or signed file exists. Use as_of / since as ISO 8601. Optional focus pins the answer to one person or place name. hydrate_from re-opens sources from this client's recent evidence[]. Personal Ask may read official live APIs internally. Responses do not include entities, facts, or signals. This tool cannot store or delete.
Example queries: "What do I know about Project Atlas?", "Find my recent emails about the budget meeting", "What are my current goals?"
Retrieve graph (no LLM). Use at session start or when you will reason over structs. Send query, entity, or entity_id (graph UUID from a prior retrieve), plus optional as_of / since, origins, limit, entity_types / fact_types / relation_types, threshold. Returns compiled profile plus scored entities, facts, and edges — no synthesized answer and no live inbox. entities[] include id; edges include source_id / target_id. query ranks the graph; it does not parse time or names into structured fields. include_evidence: true attaches used-source evidence for the returned slice plus extract artifacts of returned graph rows. Evidence items are Ask-shaped. Personal retrieve is 2 credits, or 4 with evidence.
Memory access + status. Call action: "list" once per session to see origin grants ( off / kg / raw on the five groups email, finance, social, storage, mcp_companion), multimodal_query, local_files, and last_ingest_at by internal source family (null when Cognitia has no sync stamp — mcp and chat are usually null). updatedAt is the permission row, not ingest time. Use action: "update" with origin_grants. kg is synthesized graph only; raw adds vectors and live APIs. Default is raw for every group.
Remember a note the user asked to save — not a chat dump. Queue text (origin mcp). Returns queued and source_id after the raw row is written; embedding and graph extraction continue in the background. Keep source_id. This tool cannot delete. Call unified_memory_forget with that source_id to retract this note. Company API-key clients cannot write.
Retract a note this client stored. Pass source_id from unified_memory_store. Tombstones that artifact and facts from that write. Cannot undo. Does not delete a person.
Agent action ledger. mode=record saves what this agent did (intent, target, outcome, counterparty, instruction) as a pending or final row keyed on run_id; a later write for the same run replaces it. mode=query returns what any connected agent already did, filtered by query, app, counterparty, outcome, since, as_of, and limit (1–100). Rows are attributed to this client. Ask and Retrieve never read the ledger, and Store is for notes, not actions.
JSON Schemas for these tools, the evidence object, and agent actions are published under Apache-2.0 at /spec
First-party only
Identify-a-photo, person media galleries, memory_as_of / memory_diff, and shareable memory cards remain available in the Cognitia app and first-party sessions. They are not on the external MCP allowlist. Voice generation and ChatGPT-style image generation are turned off.
Tool Permissions & Consent
When a new client connects via OAuth, you choose how much of each origin group that app may see. Each client has its own grants. Change them later from MCP & backups or by calling unified_memory_agent_config.
Every group has a fidelity: off (hidden), kg (synthesized graph only), or raw (graph plus vectors and live APIs). Default is raw. Writes from connected apps land in MCP & Companion.
Origin groups (5)
Email, Finance, Social (social, chat, backups, calendar, contacts, imported history), Storage (cloud files, photos, health, uploads), MCP & Companion (app sync, device companion, connected-app writes).
Fidelity
off — hide this group. kg — graph facts only. raw — graph plus stored memory and live APIs for accounts you connected.
Optional capability
search_local_files follows MCP & Companion at Detailed (companion raw). search_by_identity is first-party Pro only — not an OAuth grant.
The host never picks sub-tools. An inner Ask agent searches granted origins inside unified_memory_agent.
Managing Connected Apps
Go to MCP & backups to see all external apps that have been granted access to your memory layer. Each connected app shows:
App name and connection date
Number of active sessions
Last used date
Click Revoke to immediately disconnect an app and invalidate all its tokens. The app will need to re-authorize through the OAuth flow to regain access.
Credit Billing
Query prices are explained in Understanding Cognitia query costs.
Internal calls from the Cognitia web and mobile apps are not double-billed — credit deduction only applies when the request comes from an external OAuth client.
A rate limit of 60 requests per minute is applied per user across all MCP endpoints to prevent abuse.
Technical Architecture
When an external client calls unified_memory_agent, the request flows through several layers:
Authentication — The MCP endpoint validates an OAuth access token ( cog_at_… ) or personal API key ( cog_usr_… ), extracting the user ID and client ID. Session JWTs are not accepted; they are for first-party apps (iOS) only.
Rate Limit Check — A sliding-window counter ensures the user hasn't exceeded 60 requests/minute.
Caller Scoping & Config Lookup — The server enforces a caller-scope allowlist at the MCP boundary: external OAuth clients only see and can call unified_memory_agent, unified_memory_retrieve, unified_memory_agent_config, unified_memory_store, and unified_memory_forget. tools/list is filtered to match. It then loads per-client origin grants.
Agent Execution — Personal Ask runs an inner agent over the origins you granted. The host never sees those internal tools.
Tool Execution — Graph and vector search run on granted origins; live APIs run when those origins are raw. Store writes a raw mcp/note row and finishes embed + extract in the background.
Billing — Total input and output tokens from all LLM calls are accumulated. Credits are calculated and deducted (external OAuth clients only).
Personal Ask returns a synthesized context string and, when requested, evidence for sources the answer actually used — not entities, facts, signals, or every retrieved hit. Token usage metadata is stripped before the response reaches the client.
API Endpoints
All endpoints are served from the base URL https://www.cognitia-ai.com/api/mcp. The server speaks JSON-RPC 2.0 at a single endpoint. Personal OAuth and API-key clients use prompts/* and resources/* (filtered to memory.* and cognitia://status / cognitia://profile). Company API-key clients stay tools-only.
MCP Protocol (JSON-RPC 2.0)
/api/mcp/jsonrpc
JSON-RPC endpoint (all MCP methods)
OAuth 2.1 Endpoints
/.well-known/oauth-authorization-server
Server metadata (RFC 8414)
/api/mcp/oauth/register
Dynamic client registration
/api/mcp/oauth/authorize
Authorization (redirects to consent)
/api/mcp/oauth/token
Token exchange and refresh
/api/mcp/oauth/connected-apps
List connected apps
/api/mcp/oauth/connected-apps
Revoke app access
OAuth 2.1 Flow Detail
The authorization flow follows the OAuth 2.1 Authorization Code grant with PKCE (S256). Most MCP clients handle this automatically — the details below are for client developers and advanced users.
Discovery — The client fetches /.well-known/oauth-authorization-server to discover endpoints and supported capabilities.
Client Registration — The client registers itself via POST /api/mcp/oauth/register with its name and redirect URIs. Returns a client_id.
Authorization — The client generates a PKCE code_verifier/code_challenge pair and redirects the user to the authorization endpoint with response_type=code, code_challenge_method=S256, and the code_challenge.
Consent — The user logs into Cognitia (if not already), sets Off / High-level / Detailed on Email, Finance, Social, Storage, and MCP & Companion, and clicks Allow Access.
Code Exchange — The server redirects back to the client with an authorization code. The client exchanges it at POST /api/mcp/oauth/token with the code_verifier.
Token Response — Returns an access token (1 hour TTL) and refresh token (90 day TTL). The client uses the access token in the Authorization: Bearer header for all MCP requests.
Refresh — When the access token expires, the client exchanges the refresh token at the token endpoint for a new access/refresh token pair. Refresh tokens are rotated on each use.
Token Formats
OAuth access token — 64-character hex, 1-hour TTL, stored as SHA-256 hash
OAuth refresh token — 64-character hex, 90-day TTL, rotated on each use
Personal API key — long-lived, revocable, for scripts or clients without OAuth
Input & Output Schemas
unified_memory_agent — Input
{ "query": "string (required) — natural language query", "as_of": "string (optional) — ISO 8601 instant; view the knowledge graph as it existed at this point in time", "since": "string (optional) — ISO 8601 instant; restrict to what is new or changed at/after this time. Combine with as_of to ask 'what changed between X and Y'", "include_evidence": "boolean (optional) — attach evidence[] for sources the answer used (not every retrieved hit)", "focus": "string (optional) — person/place name to pin", "hydrate_from": [{ "source_type": "email", "source_id": "...", "chunk_index": 0 }] }
unified_memory_agent — Output
{ "success": true, "context": "The user …", "evidence": [ { "origin": "storage", "source_label": "Google Drive", "source_type": "google_drive", "source_id": "drive-1", "title": "Lease.pdf", "snippet": "Page 2 names Ada as tenant.", "locator": { "chunk_index": 2, "page": 2 }, "occurred_at": "2025-10-05T18:00:00.000Z", "participants": [], "open": { "kind": "provider_url", "url": "https://...", "label": "Open original" } } ] }
unified_memory_retrieve — Input
{ "query": "string — ranking / search text (or entity / entity_id)", "entity": "string — name, not an id (or query / entity_id)", "entity_id": "string — graph UUID from a prior retrieve", "include_evidence": "boolean (default false)", "origins": ["email", "social"], "as_of": "ISO 8601 (optional)", "since": "string (optional)", "until": "string (optional) — alias for as_of", "limit": "number (default 20, max 100)", "entity_types": ["person"], "fact_types": ["event"], "relation_types": ["works_at"], "threshold": "number 0–1 (default 0, off)" }
unified_memory_retrieve — Output
{ "success": true, "profile": "compiled body_text…", "entities": [ { "id": "uuid", "name": "...", "type": "person", "mentionCount": 5, "lastSeen": "2026-02-19T...", "score": 0.81 } ], "facts": [ { "type": "state", "subject": "...", "predicate": "...", "object": "...", "validAt": "...", "confidence": 0.95, "score": 0.74 } ], "edges": [ { "source": "Ada", "relation": "works_at", "target": "Acme", "score": 0.55, "source_id": "uuid", "target_id": "uuid" } ], "evidence": [ { "origin": "email", "source_label": "Email", "source_type": "email", "source_id": "...", "title": "...", "snippet": "...", "locator": { "chunk_index": 0, "page": null }, "occurred_at": "2026-01-15T...", "participants": [], "open": { "kind": "provider_url", "url": "https://...", "label": "Open original" } } ] } (evidence is omitted unless include_evidence is true)
unified_memory_agent_config — Input (list)
{ "action": "list" }
unified_memory_agent_config — Output (list)
{ "originGrants": { "email": "raw", "finance": "kg", "social": "raw", "storage": "raw", "mcp_companion": "raw" }, "multimodal_query": false, "updatedAt": "2026-02-19T...", "local_files": { "granted": true, "indexed": true }, "origins": { "email": { "last_ingest_at": "2026-02-19T..." }, "mcp": { "last_ingest_at": null } } }
unified_memory_agent_config — Input (update)
{ "action": "update", "origin_grants": { "email": "kg", "social": "off", "mcp_companion": "raw" } }
unified_memory_agent_config — Output (update)
{ "success": true, "originGrants": { "email": "kg", "social": "off", "mcp_companion": "raw" }, "updatedAt": "2026-02-19T..." }
unified_memory_store — Input
{ "text": "string (required) — text to remember", "title": "string (optional)", "occurred_at": "string (optional) — ISO 8601", "participants": ["string"], "external_id": "string (optional) — host idempotency key" }
unified_memory_store — Output
{ "queued": true, "source_id": "uuid-of-ingested-artifact" }
unified_memory_forget — Input
{ "source_id": "string (required) — source_id from this client's unified_memory_store call" }
unified_memory_forget — Output
{ "forgotten": true, "source_id": "uuid-of-ingested-artifact" }
Error Responses
All MCP endpoints return standard HTTP status codes. The 401 response includes a WWW-Authenticate header pointing to the authorization server metadata, allowing clients to auto-discover the OAuth flow.
Success — tool result in response body
Bad request — missing or invalid parameters
Unauthorized — invalid/expired token. Includes WWW-Authenticate: Bearer resource_metadata="..." header
Forbidden — user ID mismatch
Method not allowed — wrong HTTP method
Rate limited — includes Retry-After: 60 header. Wait and retry.
Internal server error
Rate Limits & Billing Detail
Rate Limits
Requests per minute
60 per user (sliding window)
Auth code TTL
5 minutes (single use)
Access token TTL
1 hour
Refresh token TTL
90 days (rotated on each use)
Agent max steps
6 LLM calls per query
CORS
All origins allowed (Access-Control-Allow-Origin: *)
Using AI Agents
Multi-Agent Orchestration
When you send a message, Cognitia's orchestrator analyzes your request and determines which tools and agents are needed. For complex requests, it breaks the task into parallel operations:
Automatic tool selection: Cognitia picks the right tools based on your connected integrations and the nature of your request.
Parallel execution: Independent tasks run simultaneously. For example, searching emails while checking your calendar happens at the same time.
Context awareness: The orchestrator uses your conversation history and persistent memory to provide personalized responses.
Document Generation
Document generation from chat is turned off. Search connected Drive, OneDrive, or Dropbox for memory instead.
Understanding Credits
Cognitia uses a credit-based system to manage usage. Each message, tool call, and AI interaction consumes credits based on complexity. Your subscription tier determines your monthly credit allocation.
Work, not a model menu: Credits scale with task complexity and tools (search, browser, memory). You do not pick an underlying model.
Tool calls count: When Cognitia uses tools (email search, browser automation, etc.), each tool invocation adds to the credit cost of that message.
Track your usage: Monitor your credit balance in your Account settings.
Data Connector
NewConnected access lets an app or a company you choose query your memory so they can personalize their product for you. It is not a listing or a way to sell your data. You choose what they can use and can revoke at any time.
How you connect
Open the Data Platform. Connect an app you use or a company you choose. It is the same product either way: they may query your memory to personalize their product for you.
You choose — pick what they can use before you approve.
Revoke — disconnect anytime to stop new queries.
What they can see
A connected app or company may query only you, and only what you granted. They do not get live access to your accounts. Connecting is not a data sale.
Understanding Cognitia query costs
Credits
Ask and Retrieve are billed in credits. A personal MCP call deducts those credits from the person's balance. A business call uses the same credit count on the business account.
Chat in the Cognitia apps uses the same credit. A Retrieve run inside those apps is not billed again as a separate Retrieve call.
Retrieve
Retrieve is priced on the records actually returned. The limit you set is a ceiling, not the price. Including evidence does not change the price.
1 credit covers the first 20 records.
Each further 20 records, or a part of 20, is 1 more credit.
A successful call that returns no records is still 1 credit.
200 records is 10 credits, and that is the maximum. A limit above 200 is rejected.
Ask
Ask is priced after the call from the input and output tokens it used. The total is rounded up to a whole credit. There is no minimum and no token ceiling. Including evidence does not add a separate charge.
Repeated queries
The same business, user, and query within 60 minutes is not billed again. A different query, a different user, or a later call is billed as usual.
Calls that are free
Store, forget, list, agent configuration, the agent actions ledger, consent requests, and Partner Connect are free. A request rejected before it runs is not billed.
A limit above 200 is rejected. Ask and Retrieve return 402 when the account is exhausted and 429 when the plan rate limit is reached.
Business plans
The $100 signup credit does not expire and has no cash value. The Standard minimum is $100 per month. Pay-as-you-go above that stops at the spend cap. A call that crosses the cap is still returned. The next billable call is refused.
The default Standard spend cap is $500 per month. Enterprise is $1,000 per month minimum, and annual billing is available.
A business can pay for a connected person's personal Ask and Retrieve. Those calls are then billed to the business. Otherwise they use that person's credits, or the call is blocked when the business has chosen to block it.
Data Connector API
NewFor businesses
The Data Connector API is connected access for a person who authorized your company. It is the same product as access the person turns on for an app they use: a query that personalizes the product for them. It is not a public user pool and not a data purchase. Every query is logged.
Start on the free plan, verify your work domain, and create an API key in the dashboard. Authenticate every request with Authorization: Bearer cog_biz_.... Query tools: marketplace_request_consent and marketplace_enrichment_query. POST /api/marketplace/ask-query.
What a query can use
Ask and Retrieve use the user-facing contracts (query / since / as_of / include_evidence), scoped to users who connected this company via their app or the Connected companies sheet.
Ask / Retrieve
Source groups the person approved (mail_calendar, chats_social, files_media, money, device_cognitia). Graph returns anonymized attributes. Evidence adds quoted snippets from those origins — not inbox dumps, full files, or open URLs.
Sensitive
Optional company-sheet toggle. Payment instruments and government ids stay masked even when allowed. Connecting their app does not include Sensitive.
Ask returns synthesized context (email/phone stripped; a name can still appear in the sentence). Retrieve returns an anonymized scored graph with stable entity ids — iterate with entity_id, not the pseudonym. Evidence items are quoted snippets only. Name, email, phone, and address are never returned as fields.
Query prices are explained in Understanding Cognitia query costs.
A limit above 200 is rejected. Ask and Retrieve return 402 when the account is exhausted and 429 when the plan rate limit is reached.
Start freeEndpoints
All routes require Authorization: Bearer cog_biz_... and are subject to per-business rate limits.
/api/marketplace/ask-query
Ask (consent required; no identity fields)
/api/marketplace/retrieve-query
Retrieve (consent required; anonymized graph)
Consent request
POST /api/marketplace/send-consent-request Authorization: Bearer cog_biz_... { "targetUserId": "string (required)", "requestedOrigins": ["mail_calendar | chats_social | files_media | money | device_cognitia"], "requestedFidelity": "graph | evidence", "message": "optional" }
Ask — Query
POST /api/marketplace/ask-query Authorization: Bearer cog_biz_... { "target_user_id": "string (required)", "query": "string (required)", "focus": "optional person or place name", "since": "optional ISO 8601", "as_of": "optional ISO 8601", "include_evidence": "boolean (requires evidence consent)" }
Retrieve — Query
POST /api/marketplace/retrieve-query Authorization: Bearer cog_biz_... { "target_user_id": "string (required)", "query": "string — required unless entity or entity_id is set", "entity": "string — required unless query or entity_id is set", "entity_id": "graph UUID from a prior retrieve", "since": "optional ISO 8601", "as_of": "optional ISO 8601", "origins": "optional origin keys", "limit": "1–200, default 20", "include_evidence": "boolean (requires evidence consent)" }
Partner Connect
NewPartner Connect lets an app builder create a Cognitia user from their own server and send that person to one hosted Connect page. The page shows your app name, asks for origin grants and a duration, and connects the sources you requested. The user is redirected back to you with a one-time code you exchange for an MCP token. Available on the Partner plan.
Users own the result. Sources land in their graph, your app holds a revocable grant, and Store writes from your app wait in their inbox until approved unless they switch your app to direct saves.
Sign-in path
Your user already has Cognitia or you do not want to hold their email on your side. Point them at Connect Cognitia in your app; the standard MCP OAuth flow runs and they consent in the browser. No provisioning call, no return code: the token arrives through the OAuth redirect.
Deep-integration path
You create the account. POST the email and your OAuth client id, get a Connect link that expires in 15 minutes, and open it for the user. If the email already belongs to a Cognitia account, the page asks them to sign in first and then shows the same consent step. The redirect back to your return_url carries cognitia_status, cognitia_user_id, and a cognitia_code valid for 5 minutes.
Endpoints
Authenticate with your business key. Register the OAuth client in the dashboard first; the return_url must share an origin with one of its redirect URIs.
/api/marketplace/partner/users
Create or find a user, return a Connect link
/api/marketplace/partner/connect-sessions
New Connect link for a user you already provisioned
/api/marketplace/partner/connect-sessions?action=exchange
Trade cognitia_code for an MCP token pair
Provision a user
POST /api/marketplace/partner/users Authorization: Bearer cog_biz_... { "email": "string (required)", "external_user_id": "your id for this user (optional)", "client_id": "OAuth client registered to your business (required)", "return_url": "https://… same origin as a redirect URI (required)", "providers": ["gmail", "outlook", "google-drive", "onedrive", "dropbox", "x", "linkedin", "spotify"], "origin_groups": ["email", "storage", "social", "finance", "mcp_companion"] } → { "user_id", "created", "connect_url", "connect_session_id", "expires_at" }
Exchange the return code
POST /api/marketplace/partner/connect-sessions?action=exchange Authorization: Bearer cog_biz_... { "code": "value of cognitia_code from the redirect" } → { "user_id", "client_id", "access_token", "refresh_token", "expires_in", "token_type" }
Review packet for assistant directories
Claude and ChatGPT directory reviews ask the same questions. Copy these answers into your submission.
- Data flow: user → hosted Connect page on cognitia-ai.com → provider OAuth → user graph; your app reads through a user-granted MCP token.
- Credentials: Cognitia holds provider tokens. Your app never receives them.
- Scope: the user chooses Off / High-level / Detailed per origin group and a grant duration (7, 30, 90 days, or until revoked).
- Revocation: the user can revoke your app in Connected apps or disconnect any source; reads and writes stop at once.
- Deletion: unified_memory_forget with a source_id retracts a write your app made; a pending proposal is dismissed.
- Audit: provisioning, Connect completion, and every business query are written to the marketplace audit log.
Pricing is discussed on a call.