MCP App Store
by KeenEthics
Giraffe icon

Giraffe MCP Server for ChatGPT

By BRBR GROUP LLC

Overview

Giraffe keeps your AI projects clear and current across ChatGPT and other compatible AI assistants. Save and retrieve project context, decisions, facts, notes, open questions, and documents from whichever AI tool you are using. When plans change, Giraffe helps preserve the latest agreed state, what changed, and which earlier information was replaced—so you can continue working without searching through old chats or rebuilding context. Use Giraffe to organize Spaces and Projects, search your knowledge, and create or update Documents directly from your AI assistant. Giraffe is free to use.

How to connect

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

Tools

create_document

ChatGPT
Compose a document from an existing Giraffe project and save it there — a meeting brief, a study sheet, a handover, a board update, a plan, a summary. Use this when the user asks you to PREPARE, WRITE UP or GET READY with something from a project, rather than to change what the project knows. Only call this when the user asks for it — never automatically. It does not alter the project's facts, decisions, questions or notes: a document is a way of presenting them, and can be deleted without losing anything. Read the project first (get_project) so you compose from what is actually there and invent nothing. Infer the right shape yourself from what the user said — who it is for, how long it should be, whether it wants prose or points — and only ask if that is genuinely ambiguous; do not offer the user a list of formats to choose from. You choose the blocks, their order and their words; Giraffe chooses every visual detail, so send no HTML, CSS or styling. After it succeeds, tell the user what you prepared and that it is in Giraffe. IF A CALL'S OUTCOME IS UNCLEAR, DO NOT SIMPLY SEND IT AGAIN. Unlike create_project, this is not durably idempotent: past a short window a second call makes a second document. Call list_documents first, decide whether the document you meant to create is already there, and only create again once you have established it is not. If you still cannot tell, say so to the user rather than risking a duplicate.

create_project

ChatGPT
Create a NEW persistent Giraffe project — a durable context the user will keep coming back to over weeks or months (a person, a company, an ongoing initiative), not a one-off write-up. If what the user wants is something WRITTEN UP from a context that already has a project (a brief, a plan, a summary), that's a Document, not a new project — call create_document against the existing project instead. Only call this after the user explicitly asks to save, remember or update, or says yes to your offer to — never automatically, and never because you read a project or a conversation happened. Before calling, check list_projects or search_projects: if a similar project already exists, call update_project on it instead of creating a near-duplicate; if the conversation could plausibly belong to more than one existing project, ask which one rather than guessing. Extract durable conclusions from the conversation (facts, decisions, open questions, notes) — not a transcript dump — and never invent a value the user didn't actually state. 'changes' uses the same structured change types as update_project (set_fact, add_decision, add_question, add_note, ...). After a successful call, tell the user which project was created.

edit_document_blocks

ChatGPT
Change PART of a Document without resending it: append blocks at the end, insert_after a block, replace a block, or delete one. Only call this when the user asks for it — never automatically. Operations apply in the order given and are all-or-nothing — if any one fails, none of them happen and the document is untouched. Prefer this over update_document whenever the user wants something added, corrected or removed rather than the document rewritten: it does not make you re-transcribe content you are not changing, which is both cheaper and the only way to be certain you did not alter it by accident. Block ids come from get_document — mode:"outline" is the cheap way to get them. Operations address TOP-LEVEL blocks; to change something inside a section, replace the whole section. expected_version works exactly as it does for update_document. The response returns the new version, the resulting block count and a content hash, so you can confirm the edit arrived intact. Use update_document instead when the user genuinely wants the document rewritten.

get_contract

ChatGPT
Return Giraffe's machine-readable contract, versioned: the Project vs Document model, the write rules, how to reconcile new information against existing state, every error code and how to recover from it, the document block grammar with its limits, and four worked examples of a request becoming a document. Call it once before composing your first Document, or when a call fails in a way you don't recognise. It is orientation, not enforcement — reading it changes nothing about what Giraffe will accept.

get_document

ChatGPT
Read one document's block structure, its version number, who wrote it, and whether the project has changed since it was prepared. Call this before update_document so you revise the real current document rather than rewriting it from memory, and so you have the version number the update needs. For a long document, read it in two steps instead of one: mode:"outline" returns one line per block — id, type, size and a short label — and block_ids:[...] then returns just the blocks you name. Blocks inside a section are addressable the same way. Note that update_document still replaces the WHOLE document, so a partial read is for finding and quoting, not for revising: read in full before you revise.

get_document_versions

ChatGPT
The revision history of one document — version number, who wrote it, and the note left with it. Use it when the user asks what changed or wants an earlier version read back; get_document takes a version number.

get_project

ChatGPT
Get the full current state of one Giraffe project: overview, current facts, decisions, open questions, notes, which Documents exist for it, recent changes, and its version number. Call this without being asked when the user is clearly continuing or recalling work that likely lives in their projects — 'where did we leave off?', 'what did we decide?', 'continue the launch plan' — even if they never name Giraffe. Not on every turn, and not for a passing mention, casual brainstorming or a one-off question. Reading never authorizes a write. If you do not know which project, call search_projects first. Always call this (or already have its output, just as fresh) before update_project — not just to get the version number, but to understand what the project currently believes before you change it: read the current facts before claiming one changed, check open questions before adding a near-duplicate, and check existing Documents before composing one that already exists. Accepts a project name, slug, or project_id; if nothing matches, returns close suggestions instead of failing silently.

get_project_history

ChatGPT
Get the full change timeline for a Giraffe project (every fact/decision/question/note change, who made it, and when). Only call this when the user specifically asks about history or how something changed over time — get_project already covers current state plus a short recent-changes summary for everything else.

list_documents

ChatGPT
List the documents that already exist for a project, with their ids, versions, who wrote each, and whether the project has moved on since. Check this before create_document: if a suitable document already exists, revise it with update_document instead of creating a near-duplicate.

list_projects

ChatGPT
List the user's projects in Giraffe: name, id, space, a one-line overview snippet, and version, most recently updated first. Call this when you don't already know which project a save belongs to, or before create_project to check whether a similar one already exists — never make the user navigate Giraffe manually to find something you can look up. If the conversation already makes the project obvious (the user named it, or you've been discussing it the whole conversation), route to it directly instead of listing defensively. A large library is capped and the response says so — use search_projects to find a specific one rather than paging. Pass include_archived:true only if the user explicitly asks for archived projects.

search_projects

ChatGPT
Search everything the user has saved in Giraffe: project names and overviews, current facts, decisions, open questions and notes, the sources attached to them, and Documents — which are matched on their full contents, not just their titles. Use this when the user refers to something by topic rather than by name, to find which Document discusses something, or to check whether a similar project already exists before calling create_project. Call this without being asked when the user is clearly continuing or recalling work that likely lives in their projects — 'where did we leave off?', 'what did we decide?', 'continue the launch plan' — even if they never name Giraffe. Not on every turn, and not for a passing mention, casual brainstorming or a one-off question. Reading never authorizes a write. A Document hit gives you its title and document_id; call get_document to read it (mode:"outline" first if it is long). Only CURRENT state is searched — superseded fact values, reversed decisions and older Document versions are deliberately not returned, so anything you find here is what the user believes now. If the project is unclear, search; if more than one plausible match remains, ask rather than guess.

update_document

ChatGPT
Replace the contents of an existing document with a revised version — 'make it half as long', 'less bullets, more narrative', 'add a competitor table', 'this is for a technical cofounder, not an investor', 'put the opportunity first'. Only call this when the user asks for it — never automatically. Send the COMPLETE new blocks array, not a patch. Every revision is stored as a new version and the previous one stays readable, so you can revise freely without destroying the user's earlier draft. expected_version must be the document's current version: if it is not, the call is refused and nothing is saved (it names the version you sent, never one to write with), in which case re-read with get_document and check whether your change is already there, rather than guessing. This only changes the document; it never edits the project's own facts or decisions. If the conversation ALSO changed what the project itself knows — not just how this document presents it — make that a separate update_project call: a Document and its source Project are different resources with independent version numbers, never one transaction.

update_project

ChatGPT
Apply structured changes to an EXISTING Giraffe project. A request to save something here is not 'append this text' — it is 'make this project reflect what we just figured out': read enough current state first (get_project), work out how the new information relates to it, and send ONE coherent batch of changes for the outcome. Only call this after the user explicitly asks to save, remember or update, or says yes to your offer to — never automatically, and never because you read a project or a conversation happened. Change types: set_fact (a keyed current-state value, e.g. budget or price — superseding replaces the old value in place, it doesn't stack; set previous_value to the value you last read, which proves you're updating what you actually saw, not guessing), remove_fact, add_decision, reverse_decision, add_question, resolve_question, reopen_question, add_note, update_note, remove_item, plus an optional overview replace in the same call. How to reconcile new information against what the project already says: - EXPLICIT: the user states an old-to-new relationship outright ('the price is now $18, not $15'; 'we changed the plan — closed beta first, Product Hunt only after'). Apply it directly, in ONE batch: set_fact with previous_value, or reverse_decision + add_decision together, plus resolve_question if the same information answers an open one. Do not ask for confirmation — the old value stays in history either way. - STATED BUT INFORMAL: the user has clearly reached a conclusion, just phrased loosely or normalized in your own words. Apply it — this tier exists specifically so Giraffe never turns into a confirmation dialog for an ordinary save. Use reason briefly if it helps explain the change later, but never invent a rationale the user didn't give. - GENUINELY AMBIGUOUS: the new information could mean more than one materially different thing relative to current state — an exception vs. a reversal vs. just a passing idea (project says the price is $18; user says 'for enterprise we might keep $15' — is that a carve-out, a rollback, or a thought?). Don't call this tool yet: ask the user one concise question in the conversation, and only write once they've answered. A conflict with existing state is not automatically a reason to ask, and a change is not automatically safe just because nothing conflicts: an explicit replacement should be applied, not confirmed; a genuinely ambiguous one should be asked about, not guessed; purely additive information (a new fact, note, or open question with no relationship to what's already there) always just applies. Overview: only include it in this same call when the change would make an AI reading the Overview ALONE reach a materially wrong conclusion about the project's main purpose, direction, scope, or status (a pivot, a market change, closed-beta-to-public-launch) — not for a routine fact edit, one decision among several, or a resolved question. Default to leaving it out. If you don't already know the project's current version, call get_project first. expected_version must match the project's actual current version exactly, or the call is rejected with a CONFLICT response and nothing is saved (it names the version you sent, never one to write with) — when that happens, re-read with get_project, check whether your change is already there, recompute against what's actually there now, and retry only if it is not; don't guess and don't resend changes already reflected. Never invent a previous_value for a fact you didn't actually see. Prefer this over create_project whenever the topic overlaps an existing project. This never edits a Document — if the same conversation is also revising one, that's a separate update_document call. After a successful call, tell the user which project was updated.

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/giraffe"><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/giraffe)