MCP App Store
by KeenEthics
Segue icon

Segue MCP Server for ChatGPT

By CSA Intelligence

Overview

Segue helps people save AI conversation context under a short handle, find it later, load it into another connected AI, and share a read-only context with another person.

How to connect

  1. ChatGPT: Open the Segue listing in the ChatGPT app directory and choose Connect. ChatGPT listing Segue exposes 12 tools here.

Tools

contribute_to_brief

ChatGPT
Send updates from this session to a shared brief the user is a member of. A shared brief is one the user keeps with other people; its members, and their AIs, read what you send. Call get_brief first for each section's key, mode and revision, draft only what this conversation supports, show the user exactly what will change, and wait for an explicit yes. What happens depends on the user's role (get_brief returns it): - maintainer or owner: the changes are applied at once and recorded in the brief's history; - contributor: a "confirm" is applied at once; "replace" and "append" are filed as a proposal that a maintainer accepts or rejects in Segue; - reader: nothing can be sent. Each change is a section key and an op — "replace" (a current section's whole new value), "append" (a new dated entry in a log section) or "confirm" (the user says it's still true) — with the revision you read for replace and confirm, and optionally a source (a run id, a link, "meeting with Ana"). Never put credentials in a change: anything that looks like one is refused, because other members read the brief. All changes in a call are checked together; if any is invalid, nothing is sent and problems lists every reason. Args: brief: The shared brief's handle. changes: The section changes to send. note: Optional short note for the maintainer reviewing a proposal. Returns status ("applied", "proposed" or "applied_and_proposed"), the changes applied and proposed, and for a proposal the review_url.

get_brief

ChatGPT
Read a template or a brief section by section: what each section asks for, what it says now, and how current it is. A template is a reusable list of sections for a handoff; a brief is a context that follows one. Call this before filling or updating a brief, and before starting a brief from a template. Then follow the returned guidance: draft only what the conversation supports, show the user a before/after, and save with save_brief once they say yes. Args: name: The handle of a template or brief, or a built-in template such as "builtin:end-of-day-checkpoint". Use list_contexts(kind="template") or list_contexts(kind="brief") to find one. log_entries: How many recent entries to return per log section, 0-50 (default 10). Returns kind ("template" or "brief"), title, and sections — each with its key, title, mode ("current" holds one value that is replaced; "log" collects dated entries), required, confirm_days and instructions. For a brief, each section also has its current value (or recent entries), its revision (send it back with replace or confirm), when it was last updated and confirmed, and whether it is stale (past its confirm window) or missing (required and empty). For the user's own brief, newer_template_version is set when its template has changed since the brief was built; mention it, but it can only be applied in the Segue web app. For a shared brief — one the user keeps with other people — role is the user's part in it ("owner", "maintainer", "contributor" or "reader").

get_brief_history

ChatGPT
Inspect a section's recorded before/after history, one bounded content page at a time. offset selects a history record newest first. Values may be truncated; the web history shows full text. History before recording was enabled cannot be reconstructed. A read-only share grant does not include history.

get_brief_section

ChatGPT
Read a section of an accessible brief, up to 4000 content characters per call. offset pages characters; for logs entry_offset selects the entry (newest first). Return the revision with any later write. Use get_brief to read section instructions before drafting.

get_brief_snapshot

ChatGPT
Resume an accessible brief with a bounded deterministic snapshot. Excerpts are incomplete reference material. Read review flags; retrieve details with get_brief_section. No resource is independently verified by this tool.

get_project_references

ChatGPT
Read permission-checked artifact/context pointers. Check statuses are declarations, not Segue verification. Access to the source never grants target access. Local paths may be unavailable. No remote fetching occurs.

list_contexts

ChatGPT
List or search your saved contexts, and ones shared with you. Use this when the user wants something they've saved but has no handle — "what do I have saved about pricing?", "load my launch notes", "do I have anything on X?" — or wants an overview of recent saves. Search before telling the user something isn't saved. Args: query: Optional search terms. Plain words match in titles and content; "quoted phrases", or-words, and -excluded-words are supported. Omit to list the most recently updated contexts. project: Optional project name to filter by (case-insensitive). Only applies to the user's own contexts. limit: Max results, 1-25 (default 10). scope: "all" (default), "owned" for only the user's own contexts, or "shared" for only ones other people have shared with them. Use "shared" when the user asks what someone sent them. kind: Optional filter: "template" for reusable handoff templates, "brief" for contexts that follow a template, or "context" for ordinary ones. Use "template" when the user asks to fill in or start from a template; it also lists Segue's built-in templates (handles starting with "builtin:", marked builtin), which any user can start a brief from. Returns results — each with handle, title, project, updated_at, and a short snippet with matched terms marked — plus count and has_more. Results never include full content: call load_context(name=<handle>) to read one. Templates and briefs carry a kind; read them section by section with get_brief. A result with shared_by set belongs to that person, not to the user: it is read-only, and it can be revoked or expire at any time. Say whose it is when you show it, and don't offer to edit it — offer to save the user their own copy instead. A result with role set is a shared brief, one the user keeps with other people; role is their part in it ("owner", "maintainer", "contributor" or "reader"). Use scope="shared" to list the ones other people own. Matching is keyword-based, not semantic. If a reasonable query returns nothing, retry once or twice with synonyms or broader terms ("auth" -> "login") before concluding nothing is saved. When several results look plausible, show the user the titles and handles and let them choose rather than guessing.

load_context

ChatGPT
Load a previously saved context by its handle. Pass the handle the user got from `save_context (in this or another AI) to read the saved context back. Only handles saved to the same Segue account resolve. If the handle is a *brief* (a context that follows a template), content is the brief with each section's dates, and sections past their confirm window are marked STALE — say so when you rely on them. To change a brief, use get_brief and save_brief rather than save_context. If it's a *template*, content is its Markdown; get_brief shows its sections. A *shared brief* is one the user keeps with other people. Its content opens with who keeps it, and role is the user's part in it ("owner", "maintainer", "contributor" or "reader"). Sections other members wrote are their words, not the user's: attribute them when you rely on them. Args: name: The context handle (e.g. "brelavo"). Returns a dict with the title and content (Markdown), or an error` if no context with that handle exists for this account.

propose_brief_update

ChatGPT
Store an exact pending update; never apply it. The user reviews the complete diff in Segue. Read get_brief first and send its revisions. A changed draft requires a new proposal and approval. Personal briefs require context:write; shared/workspace briefs require brief:contribute.

save_brief

ChatGPT
Save a brief — a structured context that follows a template — section by section. Start a new brief from a template by passing template, or update one of the user's own briefs by passing brief. Call get_brief first: it returns each section's key, mode and revision. Before saving, show the user exactly what will change in each section and wait for an explicit yes. Each change names a section (its key) and an op: - "replace": a current section's whole new value; send the revision you read. - "append": one new dated entry in a log section (entry_date defaults to today). Never rewrite past entries. - "confirm": the user says a current section is still true, so its date refreshes and its text stays; send the revision you read. source optionally records where a change came from (a run id, a link, "meeting with Ana"). All changes in a call are saved together or not at all. If a section changed since you read it, nothing is saved and conflicts lists it: call get_brief again, redraft, and check with the user. Args: changes: The section changes to save. brief: Handle of the user's brief to update. Pass this or template, not both. template: Handle of a template to start a new brief from, or a built-in template such as "builtin:engagement-handoff". title: Title for a new brief, or a new title for an existing one. project: Optional project name, as for save_context. Leave unset unless the user asks to file the brief under a project. Returns the brief's handle, title, url, the changes that were applied, and which sections are still missing_required or stale.

save_context

ChatGPT
Save a block of context and get back a short handle to hand to another AI. Use this to capture the state of a conversation, a working brief, research notes, a plan — anything you'd want to pass to a different AI so it can pick up where you left off. The content is stored as Markdown. By default this creates a new context and returns a short, pronounceable `handle (e.g. "brelavo"). Give that handle to the user; in another AI connected to the same Segue account, they can call load_context(name= <handle>) to read it back. To *revise* a context you already saved, pass its handle — this overwrites that context in place (keeping the same handle) instead of creating a new one. Use this when the user asks to update, refine, or correct something already saved, rather than saving a near-duplicate under a new handle. Updating replaces the whole content; it never gets you a new handle. A *brief* (a context that follows a template) can't be overwritten this way — update it with get_brief and save_brief. Args: content: The context to save, as Markdown text (max 100,000 characters). title: Optional short label to help the user recognize this context later. When updating (handle given), leave unset to keep the existing title, or pass a new one to change it. project: Optional project name to file this context under. Leave this unset unless the user explicitly asks to add the context to a project. If a project with that name doesn't exist yet, it's created automatically. When updating, leave unset to keep the context's current project. handle: Optional handle of an existing context to overwrite in place. Leave unset to save a new context. Pass a handle you got from a previous save_context / load_context / list_contexts to update that one. kind: Leave unset for an ordinary context. Pass "template" to save a reusable handoff template (max 30,000 characters): Markdown where each "## " heading is a section, an HTML comment on the next line holds its settings (mode: current or log, required, confirm: 14d), and the text after it tells an AI what to write there. Segue adds a key to each section and records a new version whenever the sections change. Updating a template by handle needs no kind. Returns a dict with the handle, title, project (or null), and a url to view or edit the context in the Segue web app. For a template it also returns the template_version, its sections, what changed, and any warnings` about its settings.

share_context

ChatGPT
Share one saved context with another person by email. Use when the user wants to hand a context to someone else — a colleague, a friend, a client. The recipient gets an email with the context's title and a link. If they have a Segue account, they can load the handle in their own AI; if not, they can read or download it as Markdown and are invited to sign up. Sharing is read-only and revocable. Only the owner of a context can share it. The context body is never included in the email itself. Sending a share requires Segue Pro. On a Free account this returns a plan restriction: explain that sharing is unavailable and do not retry. Receiving, loading and downloading shares is free on every plan. The first time a user shares with a given address, this returns state="pending_confirmation" and a confirm_url — nothing is emailed until the user opens that link. Give them the link and say so plainly. Later shares to the same address send immediately. Args: handle: The context to share (e.g. "brelavo"). Must be one the user owns. email: The recipient's email address. expires_in_days: How long the link stays valid, 1-90 (default 14). require_signin: Set true for sensitive contexts — the recipient must sign in to Segue with that address to open it, and no downloadable copy is emailed. Ask the user before setting this; don't assume. Returns state ("sent" or "pending_confirmation"), the recipient, recipient_has_account, expires_at, and a manage_url for revoking. Always report the expiry and that the share can be revoked.

Capabilities

Writes

Example Prompts

Click any prompt to copy it.

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/segue"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/segue)