Przejdź do treści
Biblioteka skilli
Zarządzanie i produkt · Research

memory-search

/memory-search

Przeszukuje pamięć organizacji przed niebanalnym zadaniem: wcześniejsze decyzje, wyciągnięte lekcje, poprzednie prace i właścicieli.

Licencja
MIT
Ostatnia zmiana repozytorium
14.09.2026

Ocena i bezpieczeństwo

90/ 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ść25 / 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
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 14.09.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

Przeszukuje pamięć organizacji przed niebanalnym zadaniem: wcześniejsze decyzje, wyciągnięte lekcje, poprzednie prace i właścicieli.

Oryginalny opis (EN)

Search organizational memory efficiently before any non-trivial task — an adaptive, relevance-gated first pass over the gutt knowledge graph, deepening only when needed. Use to recall prior decisions, lessons learned, past work, patterns, owners, or why something was done. Triggers on: previous, before, last time, decision, why did we, what do we know about, prior art, past work, lessons learned, have we done, did we already, history of, who worked on.

Jak działa

  1. Hard rules (non-negotiable — read first)
  2. When to use
  3. The search ladder
  4. Summary-first discipline
  5. Degradation
  6. References
Sekcje z nagłówków SKILL.md, w oryginale · 146 linii, 1 173 słów
Podgląd SKILL.md
---
name: memory-search
description: "Search organizational memory efficiently before any non-trivial task — an adaptive, relevance-gated first pass over the gutt knowledge graph, deepening only when needed. Use to recall prior decisions, lessons learned, past work, patterns, owners, or why something was done. Triggers on: previous, before, last time, decision, why did we, what do we know about, prior art, past work, lessons learned, have we done, did we already, history of, who worked on."
---

# Memory Search

How every agent should read the gutt knowledge graph: one strong first pass,
judged for relevance, deepened only when it falls short. This is the most-used
memory operation and the foundation skill — other memory skills
cross-reference it rather than restate it. Its job is to surface the answer as
fast as possible **when it exists**, and to say so plainly when it doesn't.

## Hard rules (non-negotiable — read first)

1. **One adaptive pass first.** Open with a single pass — `search_memory_nodes`
   and `search_memory_facts` in parallel, on your best phrasing. Never open with
   traversal, schema calls, or `fetch_lessons_learned`.
2. **Relevance gate.** Answer only from results that genuinely fit the question.
   If nothing on-topic comes back, say **"no relevant memory found"** — never
   assemble an answer out of loosely-matching distractors.
3. **Reformulate, don't paginate.** If the first pass is weak, **rephrase** the
   query and re-run nodes+facts (up to 2 more times, accumulating). Stop early
   if a rephrase returns essentially the same weak results. Never fetch page 2
   just because `has_more` is true — a different phrasing beats pagination.
   The identifier pair (rule 7) inverts this: a rephrase leaves the exact route
   and cannot stand in for a pair that came back empty — report that as its own
   finding, never with the near-miss keys a phrasing returned — and a pair with
   `has_more` is paged, because the route matches a term rather than ranking by
   meaning.
4. **Summary-first.** Read summaries (node `summary`, lesson `summary`, `search`
   `title`) before fetching any full episode body. Full bodies only to cite or
   recover a crucial missing detail.
5. **Count caps, not truncation.** No `summary_only` / `max_chars` parameter
   exists — bound context with `max_nodes` / `max_facts` / `limit` and by
   choosing summary-shaped tools. Never invent a truncation flag.
6. **Bare tool names.** Call `search_memory_nodes` etc. by bare name; the
   `mcp__…__` prefix varies per install — use whatever your tool list surfaces.
7. **Identifier lane.** When the question carries an identifier — a prefix of
   up to ten characters, a hyphen and digits, whether the user typed it or you
   lifted it from the ticket, report or result in hand — call **both**
   `search_memory_nodes` and `search_memory_facts` with that identifier as the
   **entire** query and no `agent_id`, `center_node_id` or `center_on_user`. Any
   extra word, and any of those three, drops the call off the exact route and
   onto look-alike keys. One pair per identifier, first, and in addition to the
   phrasings — never instead of them. A list of items is not one question: a
   skill working through a slice says which of its keys get a pair, and when.

## When to use

- Before any non-trivial task, to surface prior decisions, lessons, and context.
- To answer "have we done this / why did we / what do we know about X / who owns Y".

For **writing** memory see `memory-capture`; for **multi-hop traversal** see
`graph-traversal` (rung 3).

## The search ladder

### Rung 1 — the adaptive first pass (the workhorse)

**Identifier first (rule 7).** If the question carries one, run step 1's two calls
with the bare identifier as the whole query of both, before the phrasings — and
keep the phrasings: nodes return the item and the entities whose summaries name
it, facts return what it relates to, and only a phrasing reaches what was said
around it. An empty pair, or one with `has_more`, is rule 3's case, not a
reason to rephrase. Which shapes fire the exact route, and which spellings of a
key match, are in the tool reference.

1. Run **`search_memory_nodes(query, group_ids, max_nodes≈10)`** and
   **`search_memory_facts(query, group_ids, max_facts≈10)`** together on your best
   phrasing.
   Nodes give entity summaries ("what/who is X"); facts give the relationships
   and specific claims ("why / who decided / what's linked"). Most real
   questions need **both** — facts frequently carry the actual answer and rank
   it higher than the entity summary does.
2. **Judge the results against the question.** If the top few clearly answer it
   → stop and answer. This is the common, cheap case.
3. **If weak** (nothing clearly on-topic) → **reformulate** — different wording,
   synonyms, a more specific angle — and re-run nodes+facts. Repeat at most
   twice; stop as soon as a rephrase adds nothing new. Accumulate across
   phrasings; the best phrasing is often not the first.
4. **Relevance gate before answering:** cite only genuinely on-topic results.
   If after reformulating nothing fits, report "no relevant memory found"
   rather than stretching a distractor into an answer.

Skip `fetch_lessons_learned` in rung 1 — Lesson entities are also nodes, so
`search_memory_nodes` already surfaces them. Reach for it only when the task is
explicitly about lessons/pitfalls, where its `guidance` / `outcome` structure
is worth a dedicated call.

### Rung 2 — narrow with filters (only if rung 1 left a gap)

Introspect types with `get_available_schemas` / `get_schema` (v2.0 — skip if
hidden), then refine:

- Entities: `search_memory_nodes(entity="<Label>", center_node_id=<id>)`.
- Relationships: `search_memory_facts(edge_type="<TYPE>", center_node_id=<id>)`.
- Time-bound: `search_memory_facts(created_after=…, created_before=…)` —
  current-valid is the default; `include_invalidated=true` only for history.
- To scope facts to a person/agent, pivot via `center_node_id` from an
  already-scoped node (`search_memory_facts` has no `agent_id`).

### Rung 3 — deep traversal (hand off)

Multi-hop paths and full neighborhoods — `find_path`, `get_node_edges`,
walking edges — belong to the **`graph-traversal` skill**. Cross-reference it;
do not inline traversal here. Those nav tools
are **unbounded** (no pagination, no validity filter) — one more reason to let
that skill own them.

## Summary-first discipline

The three summary surfaces — read these before any episode body:

- **node `summary`** — from `search_memory_nodes`.
- **lesson `summary` / `context_summary`** — from `fetch_lessons_learned`
  (`context_summary` is often empty for edge-derived lessons; `summary` is the
  dependable field).
- **result `title`** — from the OpenAI-compatible `search`, when present.

Full episode bodies (`get_episode`, `get_episodes`, `get_episodes_for_entity`)
only to quote verbatim or recover a crucial detail. These list endpoints return
the **full body of every item**, so page small (`limit`) and call them **last**.
There is no server-side episode-summary retrieval — summary-first is a
reading discipline, not a tool flag.

## Degradation

Probe with ToolSearch before assuming a tool exists. Visibility is gated in two
**independent** ways — a tool shows only if its **version** ≤ the install's
`ENABLED_TOOL_VERSIONS` _and_ its **tag** is in the `TOOL_PROFILE` (see
`references/tools.md` for the full map).

- **Rung 1 always works:** `search_memory_nodes` and `search_memory_facts` are
  `core`-tagged and v1.0 — present under any profile.
- **Hideable:** schema introspection and traversal (`navigation` / `schema`
  tags, v2.0) and the `search` / `fetch` pair (v3.0) — each can drop out by
  version _or_ by profile (e.g. `agent-lite` omits `navigation` even at v2.0).

If those are hidden: stay on rung 1 and its reformulation loop, skip schema
introspection, drop the `search` titles surface. If the memory server is absent
entirely: state the degradation in one line and proceed — never stall.

## References

- `references/tools.md` — exact per-tool parameters, return shapes, version
  tiers, scoping behavior, and the identifier route's contract: which shapes
  fire it, which spellings of a key match, which near-miss keys do not, and
  what an empty page proves at each offset.
Pliki w paczce (2)
  • SKILL.md 8 KB
  • references/tools.md 13 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · ibrain-bvba/gutt-claude-code-plugin90MIT
rjmurillo/ai-agents100MIT
rjmurillo/ai-agents100MIT
S3YED/appie-kit100MIT
S3YED/appie-kit100MIT
davila7/claude-code-templates95MIT
23blocks-OS/ai-maestro-plugins95MIT
doloopz94/virtual-office-muse-ai90MIT
aristoapp/membase90MIT

Migawka bazy z 13.11.2026 · wersja paczki 967dd975a5b0 (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

  • 95pact-memory
    Zapisuje kontekst, cele, wnioski i decyzje agentów PACT oraz przeszukuje je semantycznie między sesjami.
  • 90yggdrasil-memory
    Przywołuje wcześniejsze decyzje, rozwiązania i wnioski z poprzednich sesji i projektów, a po rozwiązaniu problemu zapisuje je na przyszłość.
  • 90sugar-memory
    Korzysta z lokalnej pamięci Sugar w Hermes: przypomina wcześniejsze decyzje i błędy przed nowym zadaniem i zapisuje to, co trwałe.
  • 100recall
    Wyszukuje w pamięci wcześniejsze decyzje, uzasadnienia i wzorce, aby stosować je spójnie z poprzednim rozumowaniem.
  • 100daily-log
    Zapisuje sesje pracy, decyzje i ich wyniki oraz wyciągnięte lekcje.
  • 100using-memory
    Przypomina wcześniejsze decyzje i kod z lokalnej pamięci memxt, gdy użytkownik odwołuje się do dawnej pracy, i zapisuje nowe decyzje.

Uwagi i zgłoszenia

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