ChatGPT Plugin

Guru

Search your company knowledge

Brand: Unknown

Category: Pending
Primary Subcategory: Pending

Integration details

Description

Connect ChatGPT to your company's knowledge in Guru. Search verified Guru cards and connected sources, and get answers that cite the source documents they came from. Results respect your existing Guru permissions, so you only see content your account can already access. Built for teams that keep policies, processes and product information in Guru. Requires a Guru account.

Integration type: Plugin
Verification status: Not applicable
Platform: ChatGPT
Category: Pending
Primary Subcategory: Pending
Secondary Subcategories: None listed
Brand: Unknown
Access: Account required
First tracked: 2026-11-06
Tool count: 37
Market: US

Agent DiscoverabilityChatGPT Plugin Discovery Score

ChatGPT organic discovery is live

Your score is coming

ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.

ChatGPT recommends Airtable when a user asks it to update a CRM. — ChatGPT surfaces Airtable because it matches the user's request.

Primary Subcategory

Competitive lineup

No Primary Subcategory assigned yetOnce Guru has a Primary Subcategory, the Plugins and Connectors it competes with will appear here with their scores.

Tools

37 tools agents can invoke

Add a collaborator to a card draft in Guru. Provide either an email address for a user collaborator or a groupId for a group collaborator, but not both.
guru_add_draft_collaborator
Edit a CARD draft by applying ops (this is for card drafts — the kind opened in the card editor — not page drafts). FIRST call guru_read_draft_for_edit, then call this with your ops — they anchor to that read automatically. Read again IMMEDIATELY before EVERY edit — never reuse an `alias` from an earlier edit or turn, as the document may have changed and the aliases would be stale. Ops merge into the draft instead of overwriting it. The response returns the merged document — check your change landed. If you get a stale-read error, read again and rebuild your ops. OPS FORMAT: A JSON array of edit ops. Each op targets a node by its `alias` — the `alias` field the read put on every node, at ANY depth (top-level nodes, and nested ones like a table cell or list item). Copy the alias exactly; never guess or compute it. To change content inside a table/list, target the specific cell/item by its alias — you do NOT rebuild the whole container. Shapes: {"op":"insertNode","before":"<alias>","node":<node>} (or "after":"<alias>" — inserts a sibling next to that node; to add at the END of the document, use "after":"<alias of the last TOP-LEVEL node in the read>" — not a nested child inside a table/list/callout, even if that nested node's alias appears last in the read; to add a content block at the end of a callout/collapsible, use "after" the last child inside it; to add a structural row/item INTO a table or list, e.g. a new row at the bottom of a table, use "after" the last row/item in that container — but if the table/list has zero rows/items (e.g. all were deleted in a prior edit), there is no row/item alias left to anchor after: instead use replaceNodeContent at the table's/list's OWN alias with "children" set to the new row/item node(s), to seed the first row/item back into the emptied container) | {"op":"replaceNodeContent","at":"<alias>","children":[<leaf/inline nodes>]} | {"op":"setNodeProps","at":"<alias>","props":{...}} | {"op":"deleteNode","at":"<alias>"} | {"op":"addEntity","key":"<fresh uuid>","entity":{"url":"...","name":"...","alt":"..."}}. When the document or a container exposes only a lone empty spacer (an empty draft body, or an empty callout/collapsible/table cell), author into it with replaceNodeContent on that spacer — or insertNode "before" it — NEVER insertNode "after" it, which strands the spacer as a leading blank line above your content. replaceNodeContent edits a node's interior (does not recreate it); use deleteNode only to remove a node. NODE SHAPES (build whole nodes for insertNode and for children): {"type":"title","children":[{"text":"..."}]} is the document title — always the first node, exactly one, plain text only; rename it with replaceNodeContent at its alias, and never insert or delete a title; paragraph {"type":"p","children":[<text>]} (use "p", not "paragraph"); {"type":"heading","level":1|2|3,"children":[<text>]}; {"type":"block-quote","children":[<text>]}; {"type":"list","listType":"ul"|"ol","children":[{"type":"list-item","children":[<text>]}]} (whenever content is a series of related items/points/steps — even if the user did not say "list", and especially items you wrote as bullets in your own reply — emit ONE list node: strip the bullet marker and put each item's text in a list-item. Never append "- "/"1." paragraphs. list-item holds text/inlines directly, do NOT wrap them in a p; a sub-list is a nested list placed as a SIBLING of the list-item, in the parent list's children (not inside a list-item — that placement isn't valid and normalization moves the sub-list out to a sibling); it renders indented under whichever list-item immediately precedes it, so place it right after that item, e.g. {"type":"list","listType":"ul","children":[{"type":"list-item","children":[{"text":"parent"}]},{"type":"list","listType":"ul","children":[{"type":"list-item","children":[{"text":"child"}]}]}]}); {"type":"code-block","language":"javascript","children":[{"type":"code-line","children":[{"text":"..."}]}]}; {"type":"markdown","children":[{"type":"markdown-line","children":[{"text":"<one source line>"}]}, ...]} (use it for Mermaid diagrams: put the ```mermaid fence, the diagram source and the closing ``` in a markdown block, one markdown-line per source line, never in a code-block. Cards render mermaid fences inside markdown blocks as diagrams; a code-block with language mermaid shows as plain code). When asked for a diagram, flowchart, process map, sequence, timeline, org chart or similar in a card, write it as a Mermaid diagram in a markdown block (```mermaid fence, one markdown-line per source line). Don't say diagrams aren't supported; {"type":"table","header":true,"columns":[{"width":100},...],"children":[{"type":"tr","children":[{"type":"td","children":[<p>]}]}]} (`columns` is required: one {"width":<px>} entry per COLUMN, not per cell, and the entry count must equal the row's cell count; never emit a Markdown pipe table as paragraph text); {"type":"divider","children":[{"text":""}]}; {"type":"callout","color":"blue","children":[<blocks>]} (color: pink|orange|yellow|green|blue|purple|gray); {"type":"collapsible","children":[{"type":"collapsible-summary","children":[<p>]},{"type":"collapsible-content","children":[<blocks>]}]}. Text leaf: {"text":"..."} with optional bold/italic/underline/strikethrough/code/highlight (true) or color (a hex value); p and heading accept "align":"left|center|right|justify". Inline link: {"type":"link","url":"https://...","children":[{"text":"label"}]}. Image / file: {"type":"image","entityKey":"<key>","children":[{"text":""}]} or {"type":"file","entityKey":"<key>","children":[{"text":"label"}]} are INLINE nodes: wrap them in a p (or heading/list-item), never insert one bare at the document root, e.g. {"type":"p","children":[{"text":""},<image>,{"text":""}]}. `entityKey` names an entry in the draft's `entities` map (returned by the read). To reuse an existing entry, reference its key with no addEntity. For a new one, mint a fresh uuid and send its addEntity and the node that uses it in the SAME ops array (a node whose key has no entity is rejected; addEntity is create-only, so never reuse a key). The entity `url` must be a Guru-hosted file URL (for example the `link` returned when the file was uploaded to Guru); data: URIs are rejected. NOT supported (do not emit): videos, iframes/embeds, guru-card references, page-layout columns, or smart-block widgets.
guru_apply_draft_edits
Archive a card. Archiving is a soft delete: the card disappears from search and folders but can be restored from the Guru web app's Archive view. Cards synced from external sources cannot be archived. In the response, 'archived' is false when the card was already archived.
guru_archive_card
Generate direct answers to questions using the knowledge base. Use when users ask specific questions ('What is X?', 'How do I Y?'). Provides comprehensive answers, not just documents. If answer generation takes too long, this will execute asynchronously: the response includes a `status` field. If `status` is COMPLETE the `answer` is ready and included in the response. If `status` is PENDING the answer is still being generated — call the `guru_get_pending_answer` tool with the returned `chatThreadId` and `turnId` to retrieve it, repeating with a delay until `status` is COMPLETE or ERRORED.
guru_answer_generation
Get comment threads across all cards visible to the current user, most recently active first. Each result is a top-level comment plus all of its replies. activeAfter/activeBefore filter on the thread's last activity — the later of the comment's creation date and its newest reply's creation date — so a thread is returned when a reply falls in the range even if the top-level comment predates it. Results are ordered by that same last-activity date, descending. Status filtering (OPEN or RESOLVED) applies to the top-level comment only; replies have no status. Returns up to 25 threads per call; pass the returned nextPagingToken as pagingToken for the next page.
guru_bulk_get_card_comments
Get full content and metadata for multiple cards in a single call (maximum of 50 card ids per call). Each returned card includes its id (always the canonical lowercase UUID), title, content (Markdown by default, or the stored HTML when contentFormat is HTML), url, verification state, and collection/folder info. Ids for cards that don't exist or that the user cannot access are skipped and returned (as canonical lowercase UUIDs) in 'notFoundOrInaccessibleCardIds' instead of failing the call. For a single card lookup (or to resolve a short id/slug from a card URL to a canonical id), use guru_get_card_by_id instead.
guru_bulk_get_cards
Create a Draft of a Card in Guru. This tool only creates the draft shell — it does not accept content. Pass cardId to draft an edit of an existing published card; omit it to create a new standalone card. To add or change content afterward, call guru_read_draft_for_edit to read the draft's current content and get the ops format, then guru_apply_draft_edits to write content into it.
guru_create_draft
Create a new folder in a collection. The folder is added at the top level of the collection unless a parentFolderId is provided. Folders can be nested at most 3 levels deep. Use the guru_list_folders tool to find the parentFolderId of an existing folder to nest under.
guru_create_folder
Get a short-lived url for uploading ONE local file (e.g. an image the user attached) to Guru, to place it in a card or card draft. The upload responds with JSON whose `link` is the Guru-hosted url of the file: use it as the entity `url` in guru_apply_draft_edits, or as the `src` of an <img> in guru_update_card content. Only use it when the user asks to put a file or image into a card. Upload the file yourself: send `method` to `uploadUrl` as multipart/form-data with the file in the `fileField` part, e.g. `curl -X POST -F "file=@<path-to-file>" "<uploadUrl>"`. Never base64 the file into a tool call. The url works for one upload and expires in 5 minutes, so request a new one per file. If the upload can't connect, your environment is probably blocking the url's host; tell the user an admin needs to allow it.
guru_create_attachment_upload_url
Delete a folder. The cards and subfolders inside the deleted folder are NOT deleted — they move up into the folder's parent (or the collection's top level). A collection's home (root) folder cannot be deleted. In the response, 'deleted' is false when no such folder exists (for example, it was already deleted).
guru_delete_folder
Discard a draft, permanently deleting its unpublished changes. This cannot be undone — confirm the right draft with guru_get_draft before discarding. The published card the draft belongs to (if any) is unaffected; a standalone draft is deleted outright. Requires the draft's id (UUID) — find it with guru_list_drafts if you only have a card id or a content reference. Fails if the draft does not exist or the user cannot access it.
guru_discard_draft
Fetch content by ID
fetch
Get full card content, as Markdown by default. Pass contentFormat HTML for the card's stored HTML, which is what guru_update_card takes, so edit-then-save flows should read HTML. Accepts either the canonical card id (UUID) or the short id/slug from a card URL, and returns the card's canonical 'id' — use it to resolve a URL/short id before calling tools that need the canonical id (e.g. guru_list_drafts).
guru_get_card_by_id
Get a dataset's fields, with the ID, name and type of each, its allowedValues if the values are fixed, its capabilities (SELECT, FILTER, GROUP_BY, ORDER_BY, COUNT, AGGREGATE) and its filter operators. ALL means every one. A content field also has a defaultLength, and a maxLength if its length has a limit. The dataset and a field can have notes on how queries on them behave. Call this before guru_query_dataset, which accepts only these field IDs, copied exactly. Some are upper snake case and some are UUIDs. Never re-case, reformat or invent a field ID, or send a display name in its place.
guru_get_dataset
Retrieve the result of a previously-initiated async answer. Call this with the `chatThreadId` and `turnId` returned by the answer generation tool when `status` is PENDING. Repeat with a delay between requests until `status` is COMPLETE or ERRORED.
guru_get_pending_answer
Get a draft's title and current content in HTML format, including standalone drafts not linked to any published card. Requires the draft's id (UUID) — find it with guru_list_drafts if you only have a card id or a content reference. This is a plain read: to edit the draft use guru_read_draft_for_edit and guru_apply_draft_edits, and to throw its unpublished changes away use guru_discard_draft. In the response, cardId is null for a standalone draft.
guru_get_draft
Get the content of a document by type and ID.
guru_get_document
List all available datasets, with the ID, name and description of each. Call guru_get_dataset for a dataset's fields before you query it with guru_query_dataset. Copy a dataset ID exactly as returned. Never build one from a prefix and another ID.
guru_list_datasets
Get available knowledge agents and their IDs. Always call this first before using guru_search_documents or guru_answer_generation tools, as both require an agentId parameter. Each agent has different expertise areas and data sources configured. If the user doesn't specify which agent to use then find the appropriate agent for a specific domain or use case based on name. For search and answer generation, do not default to 'Guru' agent unless there are no high confidence matches.
guru_list_knowledge_agents
List every collection the user can access. Each collection includes its collectionId, name, description, type, and whether it is read-only. Use this to look up the collectionId for a collection by name before using other tools that operate on a collection.
guru_list_collections
List the drafts the user can edit, most recently modified first, including standalone drafts not linked to any published card. Each draft's id can be passed to guru_read_draft_for_edit and guru_apply_draft_edits. Results are paginated: when the response includes a nextPagingToken, pass it back as 'pagingToken' to get the next page; only a null nextPagingToken means there are no more pages. Pass cardId to instead find the draft of an existing published card (a card has at most one); that returns an empty list if the card has no draft the user can access — note that guru_create_draft with a cardId fails if a draft already exists.
guru_list_drafts
List the items that live directly inside a folder, in folder order: cards (type 'card') and subfolders (type 'folder'). Find a folderId via guru_list_folders (or guru_list_collections then guru_list_folders). To descend into a subfolder entry, call this tool again with the subfolder's id; to read a card entry's content, use guru_get_card_by_id. Results are paginated: when the response includes a nextPagingToken, pass it back as 'pagingToken' to get the next page. A page may contain fewer items than the page size (or none); only a null nextPagingToken means there are no more pages — keep paging until nextPagingToken is null.
guru_list_folder_items
List the folders the user can access, optionally scoped to a single collection. Each folder includes its folderId, title, collectionId, the number of cards directly inside it, and whether it is a collection's home (root) folder. Results are paginated: when the response includes a nextPagingToken, pass it back as 'pagingToken' to get the next page. A page may contain fewer items than the page size (or none); only a null nextPagingToken means there are no more pages — keep paging until nextPagingToken is null. Typical chaining: guru_list_collections to pick a collectionId, this tool to find a folderId, then guru_list_folder_items to see the cards and subfolders inside that folder (pass a home folder's folderId to list a collection's top-level content).
guru_list_folders
List user groups on the team, optionally filtered by a search term. Each group includes its groupId and name. Use this to look up the groupId for a group by name before adding or removing it as a draft collaborator.
guru_list_groups
Move a card from one folder to another within the same collection. Cards can live in more than one folder; when this card does, pass sourceFolderId to say which occurrence to move. To move a card to a DIFFERENT collection, use the guru_move_card_to_collection tool instead.
guru_move_card
Move a card to a different collection, optionally into a specific folder there. Requires permission to move the card out of its collection and to publish in the destination collection. A private card can only be moved by its author, and cards synced from external sources cannot be moved. Moving a card to the collection it is already in is a no-op.
guru_move_card_to_collection
Move a folder under a different parent folder within the same collection, or to the collection's top level when parentFolderId is omitted. The folder keeps all of its contents. Folders can be nested at most 3 levels deep, a folder cannot be moved into itself or its own subfolders, and a collection's home (root) folder cannot be moved. To move a folder to a DIFFERENT collection, use the guru_move_folder_to_collection tool instead.
guru_move_folder
Move a folder to a different collection, bringing all of its cards and subfolders along. Requires write access to the folder and permission to create folders in the destination collection. Folders can be nested at most 3 levels deep, and a collection's home (root) folder cannot be moved. Moving a folder to the collection it is already in is a no-op.
guru_move_folder_to_collection
Query a dataset: list the records that match a filter, or aggregate them, with grouping, ordering and paging. Use a search tool for text search. Call guru_list_datasets, then guru_get_dataset for the dataset's fields, then query. Copy dataset and field IDs exactly as returned. A dataset has only the fields it lists. Read the notes of the dataset and of each field you use, which say how queries on them behave. Easy to get wrong: - With only field select items, the query lists records, one row each. With an aggregation select item, it returns one row per group of its field select items. groupByFieldIds and having need an aggregation, and groupByFieldIds must equal the field select items or be omitted. - Every select item, filter and having condition needs its 'type', also when nested in a combo condition. - Count rows with COUNT on fieldId '*'. '*' is not a field and works only with COUNT, with distinct false. - Use a field only as its capabilities and operators allow, where ALL means every one. COUNT covers COUNT and COUNT DISTINCT. AGGREGATE covers MIN, MAX, SUM and AVG, and SUM and AVG need a numeric field. A distinct query can select only fields with GROUP_BY. - There is no IN, CONTAINS, LIKE or NULL operator. Match several values with a combo OR of EQUAL conditions, and test for a missing value with EQUAL null. - A filter on an ID field needs a well-formed ID, or the query fails. An ID which does not exist, or which you cannot access, matches nothing, with no error. - A content field, such as card or source record content, lists a defaultLength. A field select item's maxLength sets how many characters to return, and a row's truncatedColumns lists the 0-based indexes of its values that were cut. - A response holds at most 100 rows, or 10 when a select item asks a content field for more than its defaultLength and the field can be longer. Send its pagingToken to get the next page, until no token comes back. If truncated is true, the result reached the most rows the dataset can return and more can match: narrow the filter to get the rest.
guru_query_dataset
Read a CARD draft's live content so you can edit it with guru_apply_draft_edits (for card drafts — the kind opened in the card editor — not page drafts). Returns the draft's nodes, each carrying an `alias`. Target ops at those aliases — copy them exactly; apply_draft_edits anchors to this read automatically. Edits merge into the draft instead of overwriting it. Always read immediately before editing. Also returns the draft's `entities` map (image/file metadata keyed by `entityKey`); new image/file nodes may reference an existing key without a fresh addEntity.
guru_read_draft_for_edit
Remove a collaborator from a card draft in Guru. Provide either an email address for a user collaborator or a groupId for a group collaborator, but not both.
guru_remove_draft_collaborator
Find and retrieve specific documents, sources or cards. Use when users want to discover existing content ('find me docs on X', 'do we have cards about Y'). Returns documents for browsing, not answers.
guru_search_documents
Search for content
search
Update the content of an existing card. Use when users want to modify existing card content.
guru_update_card
Update the name, description, color, or emoji of an existing collection. Only the provided fields are changed; omitted fields keep their current values. Use the guru_list_collections tool to find the collectionId of the collection to update.
guru_update_collection
Update the title or description of an existing folder. Only the provided fields are changed; omitted fields keep their current values. A collection's home (root) folder cannot be updated. Use the guru_list_folders tool to find the folderId of the folder to update.
guru_update_folder
Check factual claims against the knowledge base. Use when a user wants to know whether statements, a draft, or an answer are consistent with Guru knowledge ('is it true that X?', 'fact-check this'). Returns one entry per claim with a `status`: SUPPORTED (a document states it), NOT_SUPPORTED (a document states something that conflicts with it), or INSUFFICIENT_INFO (the knowledge base does not settle it; this does not mean the claim is false). A NOT_SUPPORTED claim comes with a short `summary` of what Guru says ("Guru says up to $3,000"), a one-line `suggestion` that does not restate the claim ("To match Guru, use $3,000."), a longer `explanation`, and the refuting `sources`. When possible it also has `conflictingText`, the exact part of the claim that is wrong, and `correctedText`, the text that replaces it. Each source has a `quote`, a `url`, an `iconUrl` to show beside it, and its verification: `verified`, `verificationState`, `lastVerifiedBy` and `lastVerifiedAt`. An unverified source is still evidence; show the reader that it is not verified. SUPPORTED and INSUFFICIENT_INFO claims have no explanation or sources unless `verboseMode` is true. Each claim should be one fact; split compound statements before calling. At most 10 claims per call.
guru_verify_claim

FAQs

Guru ChatGPT Plugin FAQ

How the directory, categories and Discoverability Score work.

Read the methodology

How do I improve Guru's ChatGPT Plugin discoverability?

The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.

Where is this profile measured?

This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.