DEVELOPERS / MODEL CONTEXT PROTOCOL

Your context.
Connected.

Bring your Taim threads and memories into the AI tools you use. Find the context you need, save what comes next, and schedule tasks, events, and reminders.

Remote MCP serverStreamable HTTPOAuth

Server endpoint

https://mcp.trytaim.com/mcp

Taim exposes 10 tools: 5 to read your context and 5 to create threads, add notes, and schedule tasks, calendar events, and reminders. Connect an MCP-compatible assistant, sign in with your Taim account, and use the tools in conversation.

Connect your assistant

Quickstart

You need a Taim account and a client that supports remote MCP with OAuth. Choose your client, add the server, and complete the browser sign-in.

Connect from your terminal

Terminal

claude mcp add --transport http taim https://mcp.trytaim.com/mcp

Start Claude Code and run /mcp. Select taim and follow the browser sign-in. The server should show as connected.

Claude Code setup guide

Try your first prompt

“Use Taim to show my recent threads, then help me pick up where I left off.”

Using another client? Add the endpoint as a Streamable HTTP server with OAuth. Configuration formats vary by client; no local Taim server is needed.

Authentication & access

Sign in with the same account you use in Taim. The client discovers the authorization server and completes an OAuth flow. Your account determines which data each tool can access.

Threads: Threads you own, plus threads where you are an active member. Leaving a thread or being removed ends that shared access.
Shared context: Shared entries are visible to members. Tasks and proposals returned from a shared thread are your own.
Memories: Searches return personal memories associated with the signed-in user.
Schedule: Tasks and reminders belong to the signed-in user. Calendar events use that user’s connected Google or Apple calendar. Taim Tasks and reminders do not require a calendar connection.
Write access: Write tools save or queue their changes when called. Your client may ask for confirmation. Shared-thread notes are visible to other members. Tasks and events use normal Taim notifications; reminders deliver at the scheduled time.

Calendar event creation can send a device sync notification, and generated reminders can schedule public web research. These effects are declared in the tools’ MCP annotations. The current tools do not expose delete, archive, or update operations. Disconnect Taim in your client when you no longer want to use the connection.

Tool reference

Tool names and arguments below match the server. Call them through your MCP client’s tools/call method; they are not separate REST endpoints.

All Taim MCP tools
Tool	Access	Use it to
`list_threads`	Read	Browse your threads
`search_threads`	Read	Find relevant threads
`get_thread`	Read	Read a thread
`search_memories`	Read	Recall personal memories
`pull_context`	Read	Get context in one call
`create_thread`	Write	Create or reuse a thread
`add_thread_entry`	Write	Save a note to a thread
`create_task`	Write	Add a task to Schedule
`create_calendar_event`	Write	Add a calendar event
`create_reminder`	Write	Schedule a Taim reminder

Required parameters have no default. All examples use fictional data; response examples show the result payload, without the MCP envelope. Nested thread and entry objects are shortened for readability. Scheduling examples use fixed dates; replace them with your intended dates, and use a future date for reminders.

list_threads

Read

List threads you own and threads shared with you, ordered by most recent activity. Start here when you want to browse or find a thread ID.

Parameters

limitintegerdefault: 50

Maximum threads to return. Clamped to 1–100.

include_archivedbooleandefault: false

Include archived threads in the list.

Returns

threads and count. Each thread contains id, title, thread_kind, summary, last_entry_preview, last_active_at, open_task_count, status, and access (owner or member). count is the number returned, not a total across your account.

tools/call · params

{
  "name": "list_threads",
  "arguments": {
    "limit": 10,
    "include_archived": false
  }
}

Example result

Result payload

{
  "threads": [
    {
      "id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
      "title": "Japan trip",
      "thread_kind": "travel",
      "summary": "Planning an autumn trip to Japan.",
      "last_entry_preview": "Stay in Asakusa for the first few nights.",
      "last_active_at": "2026-09-18T16:30:00Z",
      "open_task_count": 0,
      "status": "active",
      "access": "owner"
    }
  ],
  "count": 1
}

Use get_thread to read entries, tasks, and proposals. This list does not include full thread contents.
There is no cursor or offset parameter. Increase limit to return more threads, up to 100.

search_threads

Read

Search owned and shared threads by meaning and keywords. Ask a natural-language question even if you do not know the thread title.

Parameters

querystringrequired

Search text. Required; cannot be empty or whitespace.

limitintegerdefault: 20

Maximum matching threads. Clamped to 1–100.

Returns

results and count. Each result contains thread_id, title, thread_kind, summary, score, source, and access. source identifies the matching recall method: vector, lexical, or centroid.

tools/call · params

{
  "name": "search_threads",
  "arguments": {
    "query": "What have I planned for Japan?",
    "limit": 5
  }
}

Example result

Result payload

{
  "results": [
    {
      "thread_id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
      "title": "Japan trip",
      "thread_kind": "travel",
      "summary": "Planning an autumn trip to Japan.",
      "score": 0.8421,
      "source": "vector",
      "access": "owner"
    }
  ],
  "count": 1
}

Scores are relevance signals, rounded to four decimal places; they are not probabilities.
Results identify threads. Call get_thread for their contents, or pull_context to retrieve relevant content in one call.
If semantic recall is unavailable, this tool returns an empty results array. An empty result alone does not prove you have no matching threads.

get_thread

Read

Read one thread with recent entries, open tasks, and pending proposals. Use an ID returned by list_threads, search_threads, or create_thread.

Parameters

thread_idstringrequired

ID of a thread you own or actively belong to. Required.

entry_limitintegerdefault: 50

Maximum recent entries to include. Clamped to 1–100.

Returns

thread, entries, proposals, tasks, handled_tasks, reflect_prompt, entry_limit, and has_more_entries. thread is the thread header; entries include content and attribution. has_more_entries indicates older entries exist beyond the returned window.

tools/call · params

{
  "name": "get_thread",
  "arguments": {
    "thread_id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
    "entry_limit": 10
  }
}

Example result

Result payload

{
  "thread": {
    "id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
    "title": "Japan trip",
    "thread_kind": "travel",
    "status": "active"
  },
  "entries": [
    {
      "id": "ee7d18ae-3e31-4661-b4ef-2d12cc765fd5",
      "title": "Where to stay",
      "entry_type": "note",
      "content": "Stay in Asakusa for the first few nights."
    }
  ],
  "proposals": [],
  "tasks": [],
  "handled_tasks": [],
  "reflect_prompt": null,
  "entry_limit": 10,
  "has_more_entries": false
}

On shared threads, entries belong to the whole thread. Tasks and proposals are scoped to your own account.
There is no entry cursor. You can increase entry_limit up to 100; this tool does not expose full-history pagination.
Missing and inaccessible threads both return ‘Thread not found’.

search_memories

Read

Search your personal Taim memories for relevant facts and relationships. Memories are personal context, separate from the entries inside a thread.

Parameters

querystringrequired

A question or description of the facts to recall. Required; cannot be blank.

limitintegerdefault: 5

Maximum memory search results. Clamped to 1–50.

Returns

results and relations, passed through from the memory service. Individual item fields depend on that service. If it is unavailable, both arrays are empty and note is ‘memory service unavailable’.

tools/call · params

{
  "name": "search_memories",
  "arguments": {
    "query": "What are my travel preferences?",
    "limit": 5
  }
}

Example result

Result payload

{
  "results": [],
  "relations": [],
  "note": "memory service unavailable"
}

This searches the authenticated user's memories, including when they have access to shared threads.
An empty successful search is valid. The example below illustrates the separate unavailable-service response.

pull_context

Read

Retrieve relevant threads and personal memories together. This is the best starting point when an assistant needs background for a question or a plan.

Parameters

querystringrequired

The question or topic you need context for. Required; cannot be blank.

thread_limitintegerdefault: 3

Maximum relevant threads. Clamped to 1–10.

memory_limitintegerdefault: 5

Maximum memory search results. Clamped to 1–50.

Returns

query, threads, and memories. Each thread result contains thread, entries, open_tasks, access, and relevance (score and source). memories contains the memory service response, normally results and relations.

tools/call · params

{
  "name": "pull_context",
  "arguments": {
    "query": "Help me plan my Japan trip",
    "thread_limit": 3,
    "memory_limit": 5
  }
}

Example result

Result payload

{
  "query": "Help me plan my Japan trip",
  "threads": [
    {
      "thread": {
        "id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
        "title": "Japan trip",
        "thread_kind": "travel"
      },
      "entries": [
        {
          "id": "ee7d18ae-3e31-4661-b4ef-2d12cc765fd5",
          "entry_type": "note",
          "content": "Stay in Asakusa for the first few nights."
        }
      ],
      "open_tasks": [],
      "access": "owner",
      "relevance": {
        "score": 0.8421,
        "source": "vector"
      }
    }
  ],
  "memories": {
    "results": [],
    "relations": []
  }
}

Each matched thread includes up to five recent entries. Use get_thread if you need a larger window. Proposals are not included here.
Thread recall covers owned and shared threads. Personal memories are searched independently, even when no thread matches.
If thread recall is unavailable, memories can still return. If the memory service is unavailable, memories contains empty results and relations arrays.

create_thread

Write

Resolve an existing thread by its normalized title or canonical key, or create a new thread when no match exists. Owned threads take precedence over matching shared threads.

Parameters

titlestringrequired

Thread title. Required; cannot be blank. Repeated whitespace is normalized.

kindstringdefault: "topic"

Group label, such as travel or work. Normalized to lowercase with hyphens. Invalid, reserved, or uninformative labels (such as general) fall back to topic.

summarystring | nulldefault: null

Optional thread summary. May update an existing owned thread; resolving a shared thread does not replace its owner's summary.

Returns

id, title, and thread_kind for the created or reused thread. Use this id in add_thread_entry to save content.

tools/call · params

{
  "name": "create_thread",
  "arguments": {
    "title": "Japan trip",
    "kind": "travel",
    "summary": "Planning an autumn trip to Japan."
  }
}

Example result

Result payload

{
  "id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
  "title": "Japan trip",
  "thread_kind": "travel"
}

Creating or resolving a thread does not add a note. Call add_thread_entry separately.
Marked idempotent: repeated matching calls reuse the thread, though activity and owned-thread metadata or summary may change.
A matching shared thread may be returned instead of a new private one. Newly created threads carry source: mcp and the connected client ID.

add_thread_entry

Write

Append an entry to an active thread you own or that is shared with you. Use it to save a decision, meeting note, or useful context from a conversation.

Parameters

thread_idstringrequired

Destination thread ID. Required; the thread must be accessible and active.

contentstringrequired

Entry content. Required; surrounding whitespace is trimmed and blank content is rejected.

titlestring | nulldefault: null

Optional short entry title.

entry_typestringdefault: "note"

Entry type label. Blank input falls back to note. This label does not create or execute a task.

idempotency_keystring | nulldefault: null

A stable key for this note creation request. Reuse the same key when retrying after a network failure; use a new key for a new note.

Returns

id, thread_id, entry_type, routing_status, and composition. routing_status can be processing while formatting or research is queued, or filed when the note is ready. composition contains processing metadata when available, otherwise null.

tools/call · params

{
  "name": "add_thread_entry",
  "arguments": {
    "thread_id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
    "content": "Stay in Asakusa for the first few nights.",
    "title": "Where to stay",
    "entry_type": "note",
    "idempotency_key": "japan-accommodation-note-001"
  }
}

Example result

Result payload

{
  "id": "ee7d18ae-3e31-4661-b4ef-2d12cc765fd5",
  "thread_id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72",
  "entry_type": "note",
  "routing_status": "filed",
  "composition": null
}

Without an idempotency key, repeating a successful call can create duplicate notes. Keep the same key and request when retrying an uncertain response.
Key-based deduplication applies to note and thought entries when Taim’s note composition is enabled. Check the thread before retrying other entry types or writes without composition.
Entries are attributed to you and stamped with source: mcp and the client ID. Other members of a shared thread are notified as with an in-app write.
Writes take effect directly. Any confirmation step is controlled by your MCP client. Archived threads reject new entries with ‘Thread is archived’.
A processing result confirms the original was saved and work was queued. Read the entry again with get_thread and wait for filed before saying formatting or research is complete.

create_task

Write

Create a personal Taim Task with a start time, a due date, or no schedule. Optionally link it to a thread you can access. No Google Tasks connection is needed.

Parameters

titlestringrequired

Task title. Required; 1–300 characters and cannot be whitespace-only.

start_timestring | nulldefault: null

ISO 8601 start time with a UTC offset, such as 2030-01-07T09:00:00-05:00. Cannot be combined with due_date.

duration_minutesinteger | nulldefault: null

Task duration from 1 to 1,440 minutes. Requires start_time.

due_datestring | nulldefault: null

Date-only deadline in YYYY-MM-DD format. Cannot be combined with start_time. Omit both to create an unscheduled task.

notesstring | nulldefault: null

Optional task notes, up to 10,000 characters.

prioritystringdefault: "normal"

One of low, normal, high, or urgent.

thread_idstring | nulldefault: null

Optional ID of a thread you own or actively belong to.

Returns

id, title, status, start_time, end_time, date, priority, and thread_id. Unscheduled tasks have no start time or date; date-only tasks preserve their date without adding a clock time.

tools/call · params

{
  "name": "create_task",
  "arguments": {
    "title": "Book Japan accommodation",
    "start_time": "2030-01-07T09:00:00-05:00",
    "duration_minutes": 45,
    "priority": "high",
    "thread_id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72"
  }
}

Example result

Result payload

{
  "id": "c92294ef-b423-40fc-b084-8beb04f67607",
  "title": "Book Japan accommodation",
  "status": "pending",
  "start_time": "2030-01-07T14:00:00Z",
  "end_time": "2030-01-07T14:45:00Z",
  "date": "2030-01-07",
  "priority": "high",
  "thread_id": "0d19e8bf-6a5c-4c97-93f8-a20657e16b72"
}

Timed tasks are grouped on the date in your Taim timezone and use Taim’s normal task notifications.
The task belongs to your account, including when linked to a shared thread.
Each call can create a new task. There is no idempotency key; check Schedule in Taim before retrying an uncertain result.

create_calendar_event

Write

Create a personal timed event in your connected Google or Apple calendar. Omit provider to use Taim’s default writable calendar.

Parameters

titlestringrequired

Event title. Required; 1–300 characters and cannot be whitespace-only.

start_timestringrequired

Event start as an ISO 8601 timestamp with a UTC offset. Required.

end_timestringrequired

Event end as an ISO 8601 timestamp with a UTC offset. Required; must be after start_time.

descriptionstring | nulldefault: null

Optional event description, up to 10,000 characters.

providerstring | nulldefault: null

google or apple. Omit to use the default writable calendar. The chosen calendar must be connected in Taim.

Returns

id, title, provider, status, start_time, and end_time. id is the event’s external ID. Google returns status: created; Apple returns status: queued while the device processes the request.

tools/call · params

{
  "name": "create_calendar_event",
  "arguments": {
    "title": "Plan Japan itinerary",
    "start_time": "2030-01-07T10:00:00-05:00",
    "end_time": "2030-01-07T11:00:00-05:00",
    "description": "Choose accommodation and plan the first few days.",
    "provider": "google"
  }
}

Example result

Result payload

{
  "id": "example_google_event_id",
  "title": "Plan Japan itinerary",
  "provider": "google",
  "status": "created",
  "start_time": "2030-01-07T15:00:00Z",
  "end_time": "2030-01-07T16:00:00Z"
}

Creates one timed event without guest invitations or recurrence. Calendar selection by ID, availability search, and all-day event creation are not exposed by this tool.
An Apple queued result does not confirm the event exists in Apple Calendar yet. Queuing can send your device a sync notification; normal event notifications also apply.
A missing or expired calendar connection returns an error. Connect or reconnect the calendar in Taim.
Each call can create a new event. There is no idempotency key; check Taim and your calendar before retrying an uncertain result.

create_reminder

Write

Create a one-time or recurring Taim reminder. Deliver a fixed message, generate content at delivery time, or schedule an ongoing series.

Parameters

titlestringrequired

Reminder title. Required; 1–300 characters and cannot be whitespace-only.

scheduleobjectrequired

Required schedule object with first_fire_at and optional timezone, recurrence, and weekdays. See the fields below.

messagestring | nulldefault: null

Fixed notification text for simple reminders, up to 10,000 characters. Falls back to title when omitted. Do not supply for generated or series reminders.

kindstringdefault: "simple"

simple, generated, or series. generated and series require prompt_template; series also requires recurrence.

prompt_templatestring | nulldefault: null

Content instructions for generated or series reminders, up to 10,000 characters. Describe the specific reminder or research topic; do not include chat transcripts. Cannot be used with simple reminders.

requires_web_searchbooleandefault: false

Enable public web research at delivery time for generated or series reminders. The research topic comes from prompt_template. Cannot be true for simple reminders.

schedule fields

first_fire_atstringrequired

Required future ISO 8601 timestamp with a UTC offset.

timezonestring | nulldefault: null

IANA timezone, such as America/New_York. Defaults to your saved Taim timezone.

recurrenceobject | nulldefault: null

Repeat rule using the fields below. Omit or set null for a one-time reminder.

weekdaysstring[]default: []

Selected days: monday, tuesday, wednesday, thursday, friday, saturday, sunday. Requires recurrence.unit: weeks and interval_value: 1. first_fire_at must fall on a selected day in the schedule timezone.

schedule.recurrence fields

unitstringrequired

Required when recurrence is supplied. minutes, hours, days, or weeks.

interval_valueintegerdefault: 1

Repeat every this many units, from 1 to 10,000. Taim’s configured minimum reminder interval also applies.

weekdays_onlybooleandefault: false

Monday–Friday shortcut. Requires unit: days and interval_value: 1. Normalized to a weekly schedule with those five weekdays; first_fire_at must be on a weekday.

end_conditionstring | nulldefault: null

until_date or occurrence_count. Omit for no explicit end. Supply only the matching end value below.

until_datestring | nulldefault: null

End timestamp with a UTC offset, at or after first_fire_at. Required with end_condition: until_date; do not also supply occurrence_count.

occurrence_countinteger | nulldefault: null

Number of occurrences, from 1 to 10,000. Required with end_condition: occurrence_count; do not also supply until_date.

Returns

id, title, kind, status, schedule, and next_fire_at. schedule contains timezone, first_fire_at, recurrence, weekdays, and local_time. next_fire_at is the next scheduled delivery time.

tools/call · params

{
  "name": "create_reminder",
  "arguments": {
    "title": "Review tomorrow",
    "message": "Review tomorrow’s schedule.",
    "schedule": {
      "first_fire_at": "2030-01-07T18:00:00-05:00",
      "timezone": "America/New_York",
      "recurrence": {
        "unit": "days",
        "interval_value": 1
      }
    }
  }
}

Example result

Result payload

{
  "id": "90c9268f-2aab-4096-924c-99323445a456",
  "title": "Review tomorrow",
  "kind": "simple",
  "status": "active",
  "schedule": {
    "timezone": "America/New_York",
    "first_fire_at": "2030-01-07T23:00:00Z",
    "recurrence": {
      "unit": "days",
      "interval_value": 1,
      "weekdays_only": false,
      "end_condition": null,
      "until_date": null,
      "occurrence_count": null
    },
    "weekdays": [],
    "local_time": "18:00"
  },
  "next_fire_at": "2030-01-07T23:00:00Z"
}

Daily and weekly repeats follow local time across daylight saving changes. Replace the sample date with a future date when trying this tool.
The tool schedules the reminder. It does not generate content, perform web research, or deliver the notification during the call.
Each call can create a new reminder. There is no idempotency key; check your reminders in Taim before retrying an uncertain result.

Example workflows

Pick up a conversation

“What did I decide about my Japan trip?”

Call pull_context with the question. If a thread needs more detail, use its ID with get_thread.

Save a decision

“Save our accommodation plan to my Japan trip thread.”

Find the thread with search_threads, then call add_thread_entry with its ID and the decision.

Start something new

“Create a home renovation thread and save these ideas.”

Call create_thread, then pass the returned id to add_thread_entry. Check the resolved thread before adding content if a matching shared thread exists.

Turn a plan into a task

“Add a task to book accommodation for my Japan trip on Monday morning.”

Find the thread with search_threads, then call create_task with its ID and a start time with a UTC offset. Use due_date instead for a date-only task, or omit both to leave it unscheduled.

Put time on your calendar

“Block an hour on my calendar to plan the itinerary.”

Call create_calendar_event with the start and end times. Check the returned status: an Apple event marked queued is still waiting for the device to process it.

Set a reminder or recurring briefing

“Remind me every evening to review tomorrow’s schedule.”

Call create_reminder with a future first delivery time, your timezone, and a daily recurrence. For a generated briefing, use kind: generated and a specific prompt_template. Enable requires_web_search when that briefing needs fresh public information.

Errors & limits

Your client displays authentication and tool errors in its own format. These are the main conditions to handle:

Sign-in required: Reconnect using OAuth. If the token does not map to a known Taim user, sign in with the account you use in the Taim app.
Thread not found: The ID does not exist or you no longer have access. Refresh the thread list and use an ID returned by the server.
Thread is archived: Archived threads do not accept new entries. Choose an active thread or manage its archive status in Taim.
Blank input: Queries, thread IDs, thread titles, and entry content must be nonempty where required. Whitespace-only values are rejected.
No search results: No matching context may exist, or semantic recall may be unavailable. Try a different query or use list_threads to browse known threads.
Memory unavailable: search_memories returns empty results and relations with an explanatory note. pull_context can still return thread context.
Invalid schedule: Times must include UTC offsets. Task duration requires a start time; a task cannot have both start_time and due_date. Events must end after they start. Reminders need a future first_fire_at and a valid timezone and recurrence. Invalid scheduling values are rejected, not clamped.
Calendar not connected: Connect or reconnect the selected Google or Apple calendar in Taim before creating an event. A queued Apple event is awaiting device processing.
Creation not confirmed: A task, event, or reminder may have been saved even if the response failed. Check Taim before retrying so you do not create duplicates.

Limits and retries

Read-tool result limits are clamped to each tool’s supported range. These are result caps, not rate limits. For add_thread_entry, reuse the same idempotency_key when retrying the same request. Task, event, and reminder creation have no idempotency key: check Taim before retrying an uncertain response.

Your context.Connected.

Connect from your terminal

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

Returns

Parameters

schedule fields

schedule.recurrence fields

Returns

Pick up a conversation

Save a decision

Start something new

Turn a plan into a task

Put time on your calendar

Set a reminder or recurring briefing

Your context.
Connected.