Guru¶

What it is¶

Guru is an enterprise knowledge management platform that uses AI to capture, verify, and deliver trusted information directly into team workflows. It emphasizes "verified knowledge" to ensure that the information users find is accurate and up-to-date. As of early 2027, Guru has integrated the FastMCP 3.1 Task Protocol, enabling its verified knowledge cards to be used as high-fidelity grounding sources for autonomous agentic workflows powered by Gemma 4, Claude 5.6, GPT-5.6, Gemini 4.0 Ultra, and DeepSeek-V4.

What problem it solves¶

It solves the problem of "knowledge decay" and "shoulder-tapping." By institutionalizing a verification workflow, Guru ensures that internal wikis don't become stale. It also reduces repetitive questions by making verified info available via a browser extension and Slack, preventing "hallucinations" in agentic responses by providing a "source of truth" for RAG (Retrieval-Augmented Generation).

Where it fits in the stack¶

Category: Enterprise AI / Knowledge Management Guru serves as the "source of truth" for verified company information, often integrated with AI agents and orchestration frameworks to provide high-fidelity answers to employee queries. It acts as a specialized RAG node in the Agentic Workflow ecosystem.

Typical use cases¶

Sales and Support Enablement: Providing agents with verified product specifications, talk tracks, and troubleshooting steps.
Internal Wiki & Handbook: Managing company policies and procedures with automated reminders for periodic review.
AI-Powered Search & Assistant: Using Guru's "Answers" feature to get direct responses to natural language questions based on verified cards.
Agentic Grounding: Supplying verified facts to models via FastMCP 3.1 to ensure regulatory compliance.

Strengths¶

Verification Workflow: Built-in system for subject matter experts (SMEs) to periodically verify that content is still accurate.
Contextual Delivery: Browser extension and integrations (Slack, MS Teams) bring knowledge to where users are already working.
AI Answers: Leverages generative AI to synthesize answers from across verified knowledge cards, with clear citations and "trust scores."
FastMCP 3.1 Support: Standardized task protocol for seamless integration into autonomous agent toolsets.

Limitations¶

Maintenance Overhead: Requires active participation from experts to keep the verification engine running effectively.
Content Fragmentation: If not managed strictly, knowledge can become scattered across too many small cards.
SaaS Only: No option for a fully self-hosted or offline-first deployment, though API access allows for local indexing.

When to use it¶

When your organization struggles with outdated documentation and "stale wiki" syndrome.
If you need a solution that pushes information to users within their existing tools (like Zendesk or Salesforce).
For teams that prioritize "verified truth" over raw data volume for AI Quality Engineering.

When not to use it¶

For personal note-taking or loosely organized research (consider Obsidian or Logseq).
If your team is small enough that informal knowledge sharing is still highly effective.
For managing high-concurrency technical documentation that belongs in a Git-backed system (consider MkDocs or Docusaurus).

Getting started¶

Guru is typically deployed as a web application and browser extension. Organizations create "Collections" and "Cards" to store information. Developers can use the Guru API or the FastMCP 3.1 server to automate card creation, search, and the verification process.

CLI examples¶

While there is no official CLI, the Guru API is easily accessible via the command line using curl.

# Search for a knowledge card related to 'vacation policy'
curl -X GET "https://api.getguru.com/api/v1/search/cards?q=vacation+policy" \
  -u "$GURU_USER_EMAIL:$GURU_API_TOKEN" \
  -H "Accept: application/json"

# List all collections in the organization
curl -X GET "https://api.getguru.com/api/v1/collections" \
  -u "$GURU_USER_EMAIL:$GURU_API_TOKEN"

API examples¶

The Guru API allows for advanced knowledge operations, such as programmatically syncing documentation from an external source and marking it as verified.

import requests
import os

# Guru uses Basic Auth
USER = os.getenv("GURU_USER_EMAIL")
TOKEN = os.getenv("GURU_API_TOKEN")
AUTH = (USER, TOKEN)

def create_verified_card(title, content, collection_id):
    """
    Creates a new knowledge card in Guru and assigns a verification interval.
    """
    url = "https://api.getguru.com/api/v1/cards"
    payload = {
        "title": title,
        "content": content,
        "collectionId": collection_id,
        "shareStatus": "TEAM",
        "verificationInterval": 90 # Days until verification is required
    }

    response = requests.post(url, auth=AUTH, json=payload)
    response.raise_for_status()
    return response.json()

# Example: Ingesting a new policy updated by Claude 5.6
new_card = create_verified_card(
    "January 2027 AI Ethics Guidelines",
    "<p>Updated guidelines for the use of Gemma 4 and FastMCP 3.1...</p>",
    "COLLECTION_ID_123"
)
print(f"Created Card ID: {new_card['id']}")

Guru Knowledge Verification Validation with Strict Pydantic v2 Schema¶

The following robust Python example uses Pydantic v2 to programmatically validate the metadata schema of knowledge card updates in Guru, ensuring the verification schedules and content segments adhere to strict enterprise guidelines.

import json
from typing import Dict, Any, List, Optional
from pydantic import BaseModel, Field, ValidationError, model_validator

# 1. Define Guru Card Metadata validation schema
class GuruCardMetadata(BaseModel):
    title: str = Field(..., min_length=5, max_length=150)
    collection_id: str = Field(..., pattern="^[a-zA-Z0-9-_]+$")
    verification_interval_days: int = Field(default=90, ge=30, le=365)
    owner_team: str = Field(..., min_length=2)
    tags: List[str] = Field(default_factory=list)

    @model_validator(mode="after")
    def validate_sensitive_intervals(self) -> "GuruCardMetadata":
        if "compliance" in self.tags and self.verification_interval_days > 90:
            raise ValueError("Compliance documents require verification intervals under 90 days for regulatory freshness.")
        return self

# 2. Example representation of raw input parameters
raw_metadata = {
    "title": "January 2027 GDPR Retention Policy",
    "collection_id": "legal-compliance-101",
    "verification_interval_days": 60,
    "owner_team": "Legal Operations",
    "tags": ["gdpr", "compliance", "privacy"]
}

# 3. Validate metadata configurations using Pydantic v2
try:
    validated_meta = GuruCardMetadata.model_validate(raw_metadata)
    print("Guru knowledge card metadata is valid!")
    print(f"Owner Team: {validated_meta.owner_team}")
    print(f"Verification Interval: {validated_meta.verification_interval_days} days")
except ValidationError as e:
    print(f"Guru Metadata Validation failed with errors: {e.json()}")

Dashworks — AI-powered unified search across internal apps.
Glean — Enterprise-scale search and knowledge platform.
Coveo — AI-powered search and recommendations for enterprise.
Notion AI — AI-powered workspace for docs and collaboration.
Obsidian — Local-first personal knowledge management.
Logseq — Privacy-focused local knowledge base.
AnyType — Decentralized, local-first knowledge base.
SilverBullet — Extensible open-source wiki alternative.
Model Context Protocol (MCP) — For standardizing knowledge access for agents.
Agentic Workflows — Patterns for autonomous AI execution.

Sources / references¶

Contribution Metadata¶

Last reviewed: 2027-01-07
Confidence: high