Glossary

A secret token used to authenticate requests to the Cograph API. Generated from Settings → API Keys. Available in two scopes: read-only (cograph_sk_ro_…) for safe general use, and read+write (cograph_sk_rw_…) when you need to create knowledge items via the MCP server.

Also known as: Truck Factor

The number of people who must leave your organization before a knowledge area becomes unowned. A bus factor of 1 means a single person is the sole expert — if they leave, that knowledge is lost. Named for the hypothetical "hit by a bus" scenario. Cograph continuously monitors for topics with a bus factor of 1, calling these "single points of failure."

The structured process for documenting institutional knowledge before an employee departs. A capture workflow consists of knowledge items — individual tasks assigned to the departing employee or their manager. Each item has a priority, type (document, runbook, handoff, etc.), and a status that tracks completion.

A graph of working relationships between employees built from three signal sources: code co-authorship (employees who frequently modify the same files or review each other's PRs), document co-editing (people who co-edit the same Google Docs or Notion pages), and Slack conversation patterns (frequent back-and-forth in the same threads). Collaboration strength is expressed as a 0–100% score and feeds into successor matching — candidates who already collaborate closely with the departing employee are ranked higher.

The declarative query language for Neo4j. Uses ASCII-art patterns to describe traversals — e.g., (a:Employee)-[:HAS_EXPERTISE]->(t:Topic) matches employees connected to topics via an expertise relationship. All queries in the Cograph knowledge graph are written in Cypher. The MCP tool find_knowledge_gaps generates Cypher queries under the hood.

The primary workflow unit in Cograph. When an employee is marked as departing, Cograph creates a departure record that progresses through a lifecycle: Initiated → Risk Assessed → Capture In Progress → Completed. Each departure has a risk score, a set of knowledge items to capture, and a timeline based on the departure date.

The full-text search engine used by Cograph to power cross-content search. Cograph indexes all content into a single unified index (meridian_content) using a contentType discriminator field. The MCP tool search_knowledge queries Elasticsearch across employees, knowledge items, Slack messages, GitHub commits, and risk reports. All queries are scoped to your organization automatically.

A number between 0 and 1 that represents how strongly an employee "owns" a given knowledge topic. Calculated as a weighted composite: code ownership (40%), document authorship (30%), communication patterns (20%), and peer recognition (10%). A score above 0.7 is considered high expertise; the threshold for bus factor analysis. Scores decay over time if no new signals arrive.

A git command that shows who last modified each line of a file. Cograph uses git blame data collected from GitHub to derive code ownership — the fraction of lines in a file or repository last touched by each developer. This feeds directly into expertise scores for technical topics.

The GitHub integration mechanism Cograph uses. Unlike a personal OAuth connection (which is tied to an individual user), a GitHub App is installed at the organization or repository level and has its own identity. This means Cograph's access does not break if the installing user leaves, and permissions can be scoped per-repository.

A data synchronization strategy where only new or changed records are fetched since the last sync, rather than re-fetching the full dataset. All Cograph integrations use incremental sync to minimize API usage and keep the knowledge graph up-to-date with low latency. Each integration tracks a lastSyncedAt timestamp to mark the watermark for the next sync.

A connected third-party service from which Cograph collects signals. Cograph currently supports three integrations: Google Workspace (employee directory, Google Docs ownership), Slack (conversation patterns, expertise mentions), and GitHub (code ownership, PR review graphs). Each integration connects via OAuth or a GitHub App and syncs data on a scheduled basis.

A topic area where no employee holds sufficient expertise above the threshold score, making it an organizational risk. Unlike a single point of failure (which requires exactly one expert), a knowledge gap means coverage is generally thin. Surfaces in the MCP tool find_knowledge_gaps.

A graph-structured database that maps entities (employees, topics, documents, repositories) and the relationships between them (expertise, ownership, collaboration). Unlike relational databases that store rectangular tables, a knowledge graph stores nodes and edges, making traversals like "who are the top experts on a topic, and who do they collaborate with?" highly efficient. Cograph stores its knowledge graph in Neo4j.

A single unit of institutional knowledge to be documented during a departure. Examples: a runbook for the payments API, a handoff note for an external vendor relationship, or a document describing an architectural decision. Each knowledge item has a title, description, priority (critical / high / medium / low), type, and assignee.

An open protocol created by Anthropic that standardizes how AI assistants communicate with external tools and data sources. An MCP server exposes tools (callable actions), resources (readable data endpoints), and prompts (pre-built workflows). The Cograph MCP server implements this protocol so that Claude, GPT-4, Gemini, and other compatible AI clients can query your knowledge graph in natural language.

A pre-built, multi-step workflow in an MCP server. Instead of the AI needing to call tools one-by-one, you invoke a prompt by name and the AI orchestrates all the required tool calls and produces a structured output. Cograph offers three prompts: offboarding-kickoff, knowledge-transfer-interview, and successor-briefing.

A read-only data endpoint in an MCP server, identified by a URI (e.g., cograph://org/bus-factor-analysis). Resources are analogous to web pages for AI — structured JSON data that an AI can "fetch" and reason over. Cograph exposes three resources: employee knowledge profiles, departure risk reports, and the organization-wide bus factor analysis.

A callable action exposed by an MCP server. Tools accept typed inputs and return structured results. Cograph provides 7 tools: 6 read-only (query_expertise, find_knowledge_gaps, identify_successors, search_knowledge, get_collaboration_network, simulate_departure_impact) and 1 write (create_knowledge_item).

A graph database that stores data as nodes and directed relationships (edges) rather than rows and columns. Cograph uses Neo4j to store and query the knowledge graph. Neo4j's native graph storage makes multi-hop traversals (e.g., "find all employees who collaborate with the top expert on a topic") orders of magnitude faster than equivalent SQL joins. Queries are written in Cypher.

A family of machine learning techniques for extracting meaning from text. Cograph uses NLP in the topic extraction stage of graph building: analyzing commit messages, file paths, document titles, and Slack messages to assign topic labels. For example, a commit touching src/auth/ is tagged "Authentication"; a doc titled "Incident Response Runbook" is tagged "Incident Response".

An entity in the knowledge graph. Cograph's graph has four primary node types: Employee (a person in the organization), Topic (a knowledge area), Document (a Google Doc, Notion page, or similar artifact), and Repository (a GitHub codebase). Nodes are connected by typed, directed relationships.

An industry-standard authorization protocol that allows a service to access data from another service on a user's behalf without handling their password. Cograph uses OAuth 2.0 to connect Google Workspace and Slack. When you authorize an integration, you are redirected to the provider's consent screen, and Cograph receives a scoped access token that it stores encrypted at rest.

The collective expertise, processes, context, and institutional memory that an organization accumulates over time. Organizational knowledge is often tacit (in people's heads rather than documented), concentrated in specific individuals, and at risk when those individuals leave. The goal of Cograph is to make this knowledge visible, transferable, and resilient.

A PostgreSQL extension that adds a vector data type and similarity search operators. Cograph uses pgvector to store text embeddings and perform semantic similarity search — finding documents or knowledge items that are conceptually similar to a query even when they don't share exact keywords. Similarity is measured with cosine distance.

A GitHub feature for proposing and reviewing code changes. An engineer opens a PR to merge a branch into the main codebase; other engineers review, comment, and approve it. Cograph uses PR review history to infer collaboration edges between engineers — frequent reviewer–reviewee pairs appear as COLLABORATES_WITH relationships in the knowledge graph.

A directed connection between two nodes in the knowledge graph. Relationships carry typed labels and properties. Cograph's four core relationship types are: HAS_EXPERTISE (Employee → Topic, with a score property), OWNS (Employee → Document, with an ownershipScore), OWNS_CODE (Employee → Repository or File, with ownershipScore, commitCount, and linesAuthored), and COLLABORATES_WITH (Employee ↔ Employee, with strength and context).

An AI-generated assessment of the knowledge risk associated with a departure. Generated by analyzing the departing employee's expertise profile against the organization's knowledge graph. Includes an overall risk score (0–100), a breakdown by critical / high / medium / low knowledge areas, recommended capture timeline, suggested successors, and mitigation steps.

A 0–100 number expressing the severity of knowledge risk for a departure. A higher score means more critical or unique knowledge is at risk. The score combines: the employee's overall expertise breadth, the uniqueness of their expertise (are they the sole expert on any topics?), and the proximity of the departure date.

The automatic reduction of an employee's expertise score over time if no new signals arrive for that topic. Prevents historical contributions from permanently inflating scores. An employee who last touched "Infrastructure" two years ago will have a lower score than one who touched it last month, even if their historical contribution was larger. Decay ensures the graph reflects current, not just historical, expertise.

A data point collected from an integration that Cograph uses to infer knowledge. Examples: a Git commit (GitHub signal → code ownership), a document edit (Google Workspace signal → document authorship), a Slack message reply where someone is the primary responder (communication pattern signal). Signals are aggregated and weighted into expertise scores.

A topic area where exactly one employee holds high expertise (score above 0.7). If that person leaves, the knowledge is unrecoverable within the organization. Single points of failure are the highest-priority items in bus factor analysis and surface in the MCP tool find_knowledge_gaps when includeSinglePointsOfFailure is set to true.

An employee recommended to receive knowledge transfer from a departing colleague. Cograph ranks successor candidates by two factors: expertise overlap (how much the candidate already knows about the departing employee's topics) and collaboration history (how closely they already work together). Candidates who both have relevant expertise and an existing working relationship are ranked highest.

A discrete knowledge area extracted from signals by NLP. Topics are the atoms of expertise in Cograph's model — every expertise score is a relationship between an Employee node and a Topic node. Examples: "API Authentication", "PostgreSQL", "Customer Onboarding", "Incident Response", "Infrastructure". Topics are organization-specific and grow organically from the content your team produces.

The second stage in Cograph's daily graph update pipeline. Raw signals from integrations are analyzed with NLP to produce topic labels. A commit to files in src/payments/ contributes to "Payments". A doc titled "Kubernetes Deployment Runbook" contributes to "Kubernetes" and "Infrastructure". Topic extraction uses a combination of file path analysis, title parsing, and content summarization.

Also known as: Bus Factor

An alternate name for Bus Factor. See Bus Factor.

The formula used to calculate expertise scores from multiple signal types. Each signal type is assigned a weight; the final score is their weighted sum. Current weights: code ownership (40%), document authorship (30%), communication patterns (20%), peer recognition (10%). The weights were chosen to reflect the relative reliability and directness of each signal as evidence of expertise.