convez.ai
MCP ServerAutomaçãoIntermediário
jnMetaCode

Local Agent Toolkit

jnMetaCode/local-agent-toolkit

Memória, skills e tracing para agentes IA — 100% local, zero cloud

Ver no GitHub
InicialPluginScore · de 0 a 100

Toolkit MCP-nativo para construir agentes IA com foco em privacidade local. Composto por três ferramentas: engram (memória persistente com busca semântica), skillet (gerenciador de skills de agentes via registro Git) e tracelet (rastreamento e debugging em tempo real via OpenTelemetry). Tudo roda na sua máquina, sem dependências externas.

Instalação

$npx convez-ai jnMetaCode/local-agent-toolkit

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
17
Forks
3
Acompanhando
0
Saúde
28%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
2

Casos de uso

  • Construir agentes IA com memória persistente e offline
  • Gerenciar e compartilhar skills entre projetos de agentes
  • Debugar e monitorar execução de agentes em tempo real
  • Trabalhar com dados sensíveis sem enviar para serviços cloud

Veredito

Toolkit sólido e bem pensado para devs que querem construir agentes IA com privacidade e controle total. A combinação das três ferramentas (memory + skills + tracing) é coerente e reduz a fricção de setup; foco em local-first e zero-dependency é diferencial legítimo. Vale explorar para workflows que exigem dados privados ou ambientes offline.

README

A tradução para o português deste README ainda está na fila.

🛠️ A local-first, MCP-native toolkit for building AI agents

Three small, zero-dependency, npx-first tools that give your agent memory, skills, and eyes — without shipping your data to anyone's cloud.

npx @jnmetacode/engram · npx @jnmetacode/skillet · npx @jnmetacode/tracelet

English | 简体中文


Most AI-agent tooling in 2026 wants you to sign up, install an SDK, and send your prompts, notes, and traces to a hosted service. These three tools take the opposite stance: everything runs on your machine, nothing leaves it, and there's nothing to install beyond one command. Each is pure Node built-ins (zero runtime dependencies), MIT-licensed, framework-agnostic, and tested across Node 18/20/22 on Linux/macOS/Windows.

They fit together (see the end-to-end recipe) but each stands alone. And the memory + skills layers are MCP-native — usable directly from Claude Code / Claude Desktop, not just the CLI.

node demo/recipe.mjs   # one agent run: a skill (skillet) + memory (engram) + tracing (tracelet), all local

The toolkit

🧠 engram — a local, private memory layer

Index your notes, files, PDFs and EPUBs, then recall anything with citations and temporal reasoning (recency-aware ranking, --since week) — 100% on your machine. A built-in BM25 engine works offline; optional local Ollama adds semantic recall. Recall is self-improving — confirm an answer (engram reinforce) and similar queries rank it higher. engram watch keeps it live as you edit; an MCP server lets any agent recall, remember and reinforce.

npx @jnmetacode/engram watch ~/notes   # live memory; then: npx @jnmetacode/engram recall "what did I decide about pricing"

🍳 skillet — a package manager for AI agent skills

Find, install, version and share SKILL.md skills from a Git-backed registry (a JSON file in a repo — no server). Installs copy the skill into your project and pin the commit SHA. 30 verified skills seeded (incl. curated Chinese skills from superpowers-zh); a static gallery and an MCP server let an agent find and install skills for itself.

npx @jnmetacode/skillet search pdf && npx @jnmetacode/skillet add pdf

🔭 tracelet — local DevTools for AI agents

Point any OpenTelemetry exporter at localhost:4318 and watch your agent's execution tree stream in live — LLM calls, tool calls, prompts, tokens, latency, errors, and cost estimates per model. Ingests both OTLP protobuf (the exporter default) and JSON; opt-in --persist keeps history across restarts. No account, no Docker, no Python.

npx @jnmetacode/tracelet

How they fit together

   🧠 engram            🍳 skillet            🔭 tracelet
   gives your agent     installs new          shows you what the
   (and you) memory  →  skills into it     →  agent actually did
   (recall + MCP)       (registry + gallery)  (live OTLP traces)

Build an agent, give it memory (engram), teach it skills (skillet), and debug what it does (tracelet) — all locally.

Install as a Claude Code plugin (one command)

This repo doubles as a plugin marketplace. Inside Claude Code:

/plugin marketplace add jnMetaCode/local-agent-toolkit
/plugin install local-agent-toolkit@local-agent-toolkit

That gives the agent the engram MCP tools (engram_recall / engram_remember — durable local memory) and the skillet MCP tools (skillet_search / skillet_install — find and add skills for itself), plus two bundled skills that teach it when to use them (engram-memory, tracelet-instrument). Run npx @jnmetacode/tracelet in a terminal to watch what it does. Everything stays on your machine.

Shared principles

  • Local-first & private — your data never leaves your machine.
  • Zero runtime dependencies — pure Node built-ins; npx <tool> and go.
  • Framework-agnostic & standards-based — OpenTelemetry, the open SKILL.md format, the Model Context Protocol. No lock-in.
  • MCP-native — engram and skillet run as MCP servers, so they're usable directly inside Claude Code / Claude Desktop, not just the CLI.
  • Small & readable — each is a few hundred lines you can audit in minutes.
  • Tested — every tool has a CI matrix and a real test suite.
  • MIT licensed.

Repos

Each tool lives in its own repo and is published independently:

ToolWhat it doesRepo
🧠 engramlocal private memory — watch mode + MCP serverjnMetaCode/engram
🍳 skilletagent-skills package manager — gallery + MCP serverjnMetaCode/skillet
🔭 traceletlocal DevTools for agent traces — OTLP protobuf+JSONjnMetaCode/tracelet
▶️ demoone-command recipe proving all three together./demo

Status: actively shipped (engram 0.3.x, skillet 0.1.x, tracelet 0.2.x), all functional and tested. See each repo's README and its docs/LAUNCH.md for what's next.

Ver o original no GitHub

Bom para

Relacionados