Przejdź do treści
Biblioteka skilli
AI i agenci · Integracja z narzędziem

graphify-agents

/graphify-agents

Wykorzystuje graf wiedzy graphify, by dawać agentom kontekst kodu przy małym zużyciu tokenów podczas researchu, dekompozycji zadań i analizy wpływu zmian.

Repozytorium
claude-skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
07.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 07.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wykorzystuje graf wiedzy graphify, by dawać agentom kontekst kodu przy małym zużyciu tokenów podczas researchu, dekompozycji zadań i analizy wpływu zmian.

Oryginalny opis (EN)

Use a graphify knowledge graph to give agents low-token codebase context — query the graph instead of reading raw files during research, decomposition, and impact analysis. Use when wiring graphify into an agent-loop, an Explore/research subagent, or an MCP-enabled agent, or when deciding when a graph query beats grepping and reading files.

Jak działa

  1. The Core Pattern: Query, Don't Read
  2. Integration with /core:agent-loop
  3. Keeping the Graph Fresh
  4. Exposing the Graph via MCP
  5. Registering graphify with Claude Code
  6. When NOT to Use the Graph
  7. Anti-Fabrication Requirements
Sekcje z nagłówków SKILL.md, w oryginale · 69 linii, 728 słów
Podgląd SKILL.md
---
name: graphify-agents
description: Use a graphify knowledge graph to give agents low-token codebase context — query the graph instead of reading raw files during research, decomposition, and impact analysis. Use when wiring graphify into an agent-loop, an Explore/research subagent, or an MCP-enabled agent, or when deciding when a graph query beats grepping and reading files.
license: MIT
---

# Graphify for Agents

Reading raw files into context is the dominant token cost of codebase-understanding work. Graphify builds a knowledge graph once (`graphify-out/graph.json`) and answers structural questions by traversing it — returning the relevant nodes and edges instead of whole files. This skill covers using that graph to make agent workflows cheaper and more targeted.

The project's published benchmark reports "**71.5x** fewer tokens per query vs reading raw files" on a mixed corpus, with smaller gains (≈5.4x on a 4-file corpus, ≈1x on a 6-file library) — the advantage scales with corpus size. Measure a specific repo with `graphify benchmark` before quoting a number; small repos see little benefit, so reserve the graph for large corpora.

For installing graphify and the full CLI surface, load the `graphify` skill.

## The Core Pattern: Query, Don't Read

| Question shape | Without graphify | With graphify |
|----------------|------------------|---------------|
| "How does auth connect to the request pipeline?" | Grep, open 6–10 files, read each | `graphify query "how does auth connect to the request pipeline?"` → relevant nodes + edges |
| "What is `SwinTransformer` and what touches it?" | Read the class + every caller | `graphify explain "SwinTransformer"` |
| "What breaks if I change `add`?" | Trace callers by hand | `graphify affected "add"` |
| "How do these two modules connect?" | Read both, infer | `graphify path "DigestAuth" "Response"` |

`query` returns within a token budget (`--budget`, default 2000), so an agent gets a bounded, relevant slice rather than unbounded file contents.

## Integration with /core:agent-loop

Graphify slots into the loop's existing phases without replacing them. Load `/core:agent-loop` for the phase model.

**Phase 1 (Pre-flight / research).** Before decomposition, build or refresh the graph, then have the research/Explore subagent query it instead of fanning out file reads:

```bash
mise run graphify:update      # AST-only refresh, no API key needed
graphify query "where is <epic-area> implemented and what does it depend on?"
```

Feed the query result into the Team Leader's decomposition. The graph names the real files and symbols to reference in worker prompts — which the agent-loop prompt template already requires ("reference existing code and functions to reuse").

**Phase 2 (Working).** Give each worker the `path`/`explain` output for its slice instead of pre-reading files into the prompt. Workers still read the specific files they edit.

**Impact analysis before slicing.** `graphify affected "<symbol>"` (needs a full clustered build) surfaces the blast radius of a change, which informs dependency edges between bees issues.

## Keeping the Graph Fresh

A stale graph misleads agents the way stale docs do. Keep it current:

```bash
graphify hook install    # rebuild on post-commit / post-checkout
graphify watch .         # rebuild live during a session
```

The agent that relies on the graph confirms freshness — `graphify check-update .` reports whether a semantic re-extraction is pending. Treat graph claims like any other: an agent verifies a graph answer against the actual file before acting on it (anti-fabrication).

## Exposing the Graph via MCP

`graphify . --mcp` starts an MCP stdio server (the `[mcp]` extra / `graphify-mcp` console script). An MCP-enabled agent then calls graphify tools directly rather than shelling out. See `/extras-claude-code:claude-agents` (sibling plugin, install extras-claude-code@vinnie357; MCP-enabled agent pattern) for declaring the server in an agent's tool set.

## Registering graphify with Claude Code

`graphify claude install` writes a graphify section to `CLAUDE.md` and a PreToolUse hook so a Claude Code session reaches for the graph automatically. This is graphify's own integration; this marketplace's `graphify`/`graphify-agents` skills are the alternative, progressive-disclosure path that does not modify `CLAUDE.md`.

## When NOT to Use the Graph

- Small repos (the benchmark shows ≈1x on a 6-file library) — grep+read is simpler.
- Questions about the exact current contents of one known file — read it.
- Anything where the graph has not been rebuilt since the relevant code changed — refresh first or read directly.

## Anti-Fabrication Requirements

- Run `graphify benchmark` (or cite the project's published figures as such) before stating a token-savings number — never present a benchmark figure as independent measurement.
- Verify a graph answer against the actual source file before an agent acts on it.
- Confirm graph freshness (`graphify check-update`) before trusting a query in a long session.
- State which commands require a full clustered build vs a raw AST extraction (`affected` and community labels need clustering).

Wersje

W bazie nie ma innych skilli o nazwie graphify-agents.

Migawka bazy z 13.11.2026 · wersja paczki c3cd6e00c61f (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100graphify
    Zamienia folder z kodem, dokumentami, plikami PDF i obrazami w graf wiedzy, który agenci odpytują z wiersza poleceń zamiast wielokrotnie czytać pliki.
  • 100graphify-codebase
    Wdraża i przeszukuje graf kodu graphify przy projektowaniu, przeglądzie i ustalaniu zasięgu wpływu zmian w bazie kodu.
  • 100graphify
    Buduje i odpytuje graf wiedzy o kodzie i dokumentach przez CLI graphify, instaluje go przez mise i eksportuje do GraphML, SVG, Neo4j lub Obsidiana.
  • 100graphify-usage
    Wyjaśnia, jak odpytywać graf wiedzy graphify o strukturę kodu, kiedy wybrać narzędzia grafowe zamiast grep i jak czytać wyniki zapytań.
  • 90project-knowledge-graph
    Buduje graf wiedzy z kodu, dokumentów, artykułów i zrzutów ekranu, żeby szybko poznać strukturę dużego projektu i jego wiedzę.
  • 100code-knowledge-graph-tools-for-ai-agents
    Porównuje GitNexus, Graphify i CodeGraph, narzędzia budujące graf wiedzy o kodzie dla agentów AI przez MCP, zastępując powtarzane przeszukiwanie grep zapytaniami o wpływ, łańcuchy wywołań i zależności.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.