Labsco
github logo

mini-context-graph

✓ Official★ 36,200

by github · part of github/awesome-copilot

Standard RAG re-discovers knowledge from scratch on every query. This skill is different:

🔥🔥🔥✓ VerifiedFreeQuick setup
#automation#documents#git#memory
🧩 One of 7 skills in the github/awesome-copilot package — works on its own, and pairs well with its siblings.

Standard RAG re-discovers knowledge from scratch on every query. This skill is different:

Inspect the full instructions your agent will receiveExpand

This is the exact playbook injected into your agent when the skill activates — shown here so you can audit it before installing. You don't need to read it to use the skill.

by github

Standard RAG re-discovers knowledge from scratch on every query. This skill is different: npx skills add https://github.com/github/awesome-copilot --skill mini-context-graph Download ZIPGitHub36.2k

Mini Context Graph Skill

The Core Idea

Standard RAG re-discovers knowledge from scratch on every query. This skill is different:

  • Wiki layer — The LLM writes and maintains persistent markdown pages (summaries, entity pages, topic syntheses). Cross-references are already there. The wiki gets richer with every ingest.

  • Graph layer — Entities and relations are extracted once and stored as a navigable knowledge graph. BFS traversal answers structural queries without re-reading sources.

  • Raw source layer — Original documents are stored immutably with chunks. Provenance links tie every graph node and edge back to the exact text that supports it.

The LLM writes; the Python tools handle all bookkeeping.

Three Layers

Layer Where What the LLM does What Python does Raw Sources data/documents.json Reads (never modifies) Stores chunks + metadata Wiki wiki/ (markdown) Writes/updates pages Manages index.md + log.md Graph data/graph.json Extracts entities + relations Persists, deduplicates, traverses

Key Claims

  • [[memory-leak]] causes [[system-crash]] (confidence: 1.0)

Entities

  • [[memory-leak]] (issue)
  • [[system-crash]] (issue) """, summary="Incident report: memory leaks cause system crashes.", )

===== QUERY WITH EVIDENCE =====

result = skill.query_with_evidence("Why does the system crash?")

Returns: {"query": ..., "subgraph": ..., "supporting_documents": [...], "evidence_chain": ...}

===== WIKI SEARCH (read wiki before answering) =====

pages = wiki_store.search_wiki("memory leak")

Returns: [{slug, category, path, snippet}, ...]

Copy & paste — that's it

## Operations

### Ingest

 When a user provides a new document:

 

- Read `references/ingestion.md` — entity/relation extraction rules. 

- Read `references/ontology.md` — type normalization rules. 

- Extract entities and relations using your LLM reasoning. 

- Call `skill.ingest_with_content(...)` — stores raw content + chunks + graph nodes + provenance. 

- **Write a wiki summary page** using `wiki_store.write_page(category="summary", ...)`. 

- **Update entity pages** — for each new/updated entity, write or update `wiki_store.write_page(category="entity", ...)`. 

- **Update topic pages** if the document touches an existing synthesis topic. 

- A single document ingest will typically touch 3–10 wiki pages. 

### Query

 When a user asks a question:

 

- **Check the wiki first** — `wiki_store.search_wiki(query)` to find relevant pages. Read them. 

- If the wiki has a good answer, synthesize from wiki pages (fast path). 

- If deeper graph traversal is needed, call `skill.query_with_evidence(query)`. 

- Return the answer with evidence citations from `supporting_documents`. 

- If the answer is valuable, file it back as a new wiki topic page. 

### Lint

 Periodically health-check the wiki:

from scripts.tools import wiki_store issues = wiki_store.lint_wiki()

Returns: {orphan_pages, missing_pages, broken_wikilinks, isolated_pages}

Copy & paste — that's it

 Ask the LLM to review and fix: broken links, orphan pages, stale claims, missing cross-references. See `references/lint.md` for full lint workflow.

## Ingestion Constraints

- ❌ Do NOT hallucinate entities not present in the text 

- ❌ Do NOT add relations without explicit textual evidence 

- ❌ Do NOT add edges with confidence < 0.6 

- ✅ Provide `supporting_text` for every entity and relation — this enables provenance 

- ✅ Write a wiki summary page for every ingested document 

- ✅ Update existing entity pages when new information arrives 

- ✅ Flag contradictions in wiki pages when new data conflicts with old claims

## Retrieval Constraints

- 🔒 Traversal depth MUST NOT exceed 2 (config: MAX_GRAPH_DEPTH) 

- 🔒 Only edges with confidence ≥ 0.6 (config: MIN_CONFIDENCE) 

- 🔒 Maximum 50 nodes returned (config: MAX_NODES) 

- ❌ Do NOT fabricate nodes or edges not in the graph

## Full Python API Reference

Method Purpose When to Use 
 `skill.ingest_with_content(doc_id, title, source, raw_content, entities, relations)` Full RAG ingest: raw docs + graph + provenance Every new document 
 `skill.add_node(name, node_type)` Add single entity (no provenance) Quick additions without a source doc 
 `skill.add_edge(source_name, target_name, relation, confidence)` Add single relation Quick additions without a source doc 
 `skill.query(query)` Graph-only retrieval → subgraph Structural queries 
 `skill.query_with_evidence(query)` Graph + provenance → subgraph + source chunks Queries requiring citations 
 `wiki_store.write_page(category, title, content, summary)` Write/update a wiki page After every ingest; after answering queries 
 `wiki_store.read_page(category, title)` Read a wiki page Before answering; for cross-referencing 
 `wiki_store.search_wiki(query)` Keyword search across wiki Fast path before graph traversal 
 `wiki_store.list_pages(category)` List all wiki pages Getting an overview 
 `wiki_store.get_log(last_n)` Read recent operations Understanding wiki history 
 `wiki_store.lint_wiki()` Health check Periodic maintenance 
 `documents_store.list_documents()` List all ingested raw sources Audit / provenance checking 
 `documents_store.search_chunks(query)` Chunk-level search Finding specific evidence

## Design Philosophy

"The wiki is a persistent, compounding artifact. The cross-references are already there. The synthesis already reflects everything you've read." — Karpathy

 

 Layer What Happens Who Owns It 
 **LLM Reasoning** Extraction, synthesis, writing wiki pages Agent (.md guidance files) 
 **Wiki Persistence** Index, log, file I/O `wiki_store.py` 
 **Graph Persistence** Dedup, index, BFS traverse `graph_store.py`, `retrieval_engine.py` 
 **Raw Source Storage** Immutable docs + chunks + provenance `documents_store.py` 
 

 The human curates sources and asks questions. The LLM writes the wiki, extracts the graph, and answers with citations. Python handles all bookkeeping.