Skip to content
Skills Library
AI & agents · Writing

knowledge-summarize

/knowledge-summarize

Generate a TL;DR summary of a specific document or learning unit in the Knowledge base. Pulls chunks from pgvector and synthesizes via Claude Haiku. Use when the user wants a quick overview ('summary of lesson 5', 'TL;DR of this PDF', 'explain document X in one paragraph').

Repository
evo-nexus ↗
Licence
Apache-2.0
Last repository change
12.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 12.05.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Generate a TL;DR summary of a specific document or learning unit in the Knowledge base. Pulls chunks from pgvector and synthesizes via Claude Haiku. Use when the user wants a quick overview ('summary of lesson 5', 'TL;DR of this PDF', 'explain document X in one paragraph').

Triggers from the description

summary of lesson 5TL;DR of this PDFexplain document X in one paragraph
Original author description

Generate a TL;DR summary of a specific document or learning unit in the Knowledge base. Pulls chunks from pgvector and synthesizes via Claude Haiku. Use when the user wants a quick overview ('summary of lesson 5', 'TL;DR of this PDF', 'explain document X in one paragraph').

How it works

  1. When to trigger
  2. Arguments
  3. Workflow
  4. Actionable failures
Original SKILL.md headings · 82 lines, 283 words
SKILL.md preview
---
name: knowledge-summarize
description: "Generate a TL;DR summary of a specific document or learning unit in the Knowledge base. Pulls chunks from pgvector and synthesizes via Claude Haiku. Use when the user wants a quick overview ('summary of lesson 5', 'TL;DR of this PDF', 'explain document X in one paragraph')."
---

# knowledge-summarize

Group: **Consumption**. Generate TL;DR of a document or unit using indexed chunks.

## When to trigger

- "Summary of lesson 5"
- "TL;DR of this PDF"
- "Explain document X"
- "Summary of module Y"

## Arguments

| Name | Type | Required | Description |
|---|---|---|---|
| `document_id` | str | one of two | Document UUID |
| `unit_id` | str | one of two | Unit UUID (aggregates all docs) |
| `connection` | str | no | Defaults to first ready |
| `max_tokens` | int | no | Limit (default 500) |

## Workflow

### Step 1 — Fetch chunks

```python
from dashboard.backend.sdk_client import evo

if document_id:
    doc = evo.get(f"/api/knowledge/v1/documents/{document_id}",
                  headers={"X-Knowledge-Connection": connection})
    chunks = doc["chunks"]
    title = doc["title"]
elif unit_id:
    docs = evo.get(f"/api/knowledge/v1/documents?unit_id={unit_id}",
                   headers={"X-Knowledge-Connection": connection})
    chunks = []
    for d in docs:
        full = evo.get(f"/api/knowledge/v1/documents/{d['id']}",
                       headers={"X-Knowledge-Connection": connection})
        chunks.extend(full["chunks"])
    title = f"Unit {unit_id} ({len(docs)} documents)"
```

### Step 2 — Concatenate + truncate

Concatenate `chunk.content` separated by `\n\n`. If total > 40k chars: sample first/middle/last third.

### Step 3 — LLM call

Model: `claude-haiku-4-5-20251001`.

Prompt:

```
Summarize the document in structured markdown. Max {max_tokens} tokens.

## {title}

**TL;DR (1 paragraph):** ...

**Key points:**
- ...
- ...

**Target audience / when to use:** (optional)

### Document
{concatenated_chunks}
```

### Step 4 — Render

Return summary + footer `Based on {N} chunks from {M} documents`.

## Actionable failures

- Neither `document_id` nor `unit_id` passed → "Pass one of the two (mutually exclusive)."
- Not found → "Not found. Use `knowledge-browse` to list."
- `ANTHROPIC_API_KEY` missing → "Set `ANTHROPIC_API_KEY` in `.env`."
- Doc status != ready → "Not indexed (status={status}). Re-upload the document or wait for ingestion to complete."

Versions

The database has no other skills named knowledge-summarize.

Database snapshot: 13.11.2026 · package version 32a95e5c2f00 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 85haiku-rag
    Search, read and compute over the user's haiku.rag knowledge base through the haiku-rag MCP tools. Use whenever a request could be answered from the user's ingested documents, when asked to find, look up, check or cite something in their documents or knowledge base, or when the…
  • 100knowledge-admin
    Administrative operations on the Knowledge base: connect new pgvector servers, check health, view stats, export data, install parser models. Use when the user wants to configure/monitor the system ('connect a new pgvector', 'status of connections', 'how many docs do we have',…
  • 100knowledge-query
    Hybrid search (vector + BM25 via RRF + metadata boost) against the pgvector Knowledge base, with optional RAG synthesis. Use when the user asks factual questions that should be grounded in indexed documents (e.g., 'what do we know about X', 'search the knowledge base for Y',…
  • 90ai-llm-patterns
    AI/LLM integration patterns: Anthropic SDK streaming with TypeScript, RAG architecture (chunking, embedding, vector search with pgvector), tool use / function calling, model selection guide (Haiku 4.5 vs Sonnet 5 vs Opus 4.8), prompt caching, structured output with Zod, token…
  • 100capture-knowledge
    Use when capturing a durable, team-relevant learning into the committed .claude/knowledge/ base — a gotcha, decision, convention, or runbook worth sharing with teammates' agents. Human-gated.
  • 90tasktide
    Orchestrates development tasks with Claude Code subagents and routes work between Haiku, Sonnet and Opus. Use to plan architecture, implement features, refactor, debug, review and test code.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.