convez.ai
SkillDevOps & InfraestruturaIntermediário
ratel-ai

Ratel Skills Suite

ratel-ai/skills

Audite, instrumente e integre Ratel em agentes IA com cinco skills coordenadas

Ver no GitHub
InicialPluginScore · de 0 a 100

Cinco skills para Claude Code, Cursor e Codex que automatizam a auditoria, instrumentação e integração do gateway de contexto Ratel em codebases de agentes IA. Inclui assessment, planejamento de observabilidade, design de dashboards e análise de traces em fluxo de trabalho integrado.

Instalação

$npx convez-ai ratel-ai/skills

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
10
Forks
1
Acompanhando
0
Saúde
50%
Último commit
há 3 meses
Versão
—
Issues abertas
0
Contribuidores
3

Casos de uso

  • Avaliar saúde e observabilidade de codebases de agentes IA
  • Planejar e implementar instrumentação com Langfuse
  • Desenhar dashboards de observabilidade e custo de tokens
  • Integrar gateway de contexto Ratel em produção
  • Analisar traces e otimizar performance de agentes

Veredito

Ferramental maduro e bem estruturado para operacionalizar agentes IA com observabilidade profissional. Excelente para equipes que querem auditoria sistemática e rollout planejado do Ratel em produção, com fluxo de engajamento claro e escalável.

README

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

The fastest way to audit an AI agent codebase, plan its observability, design the dashboards, integrate Ratel's context gateway, and analyse live traces — five skills, one engagement arc.

Install

npx skills add ratel-ai/skills -y -g

That installs all five skills globally (into ~/.claude/skills/ for Claude Code, the equivalent location for other supported agents). The -y flag accepts all prompts; -g installs globally rather than into the current project.

Per-skill install:

npx skills add ratel-ai/skills --skill ratel-assessment

Local development install (when iterating on the suite itself):

git clone https://github.com/ratel-ai/skills
npx skills add ./skills

The npx skills CLI is Vercel Labs' open agent skills tool — compatible with Claude Code, Cursor, Codex, OpenCode, Gemini CLI, and 40+ other coding agents.

Quickstart — copy-paste this into your coding agent

I want you to assess my agent codebase and produce a Ratel-flavored
report so we can see what's weak and where Ratel would help.

Step 1 — install the Ratel skills suite:

  npx skills add ratel-ai/skills -y -g

Step 2 — run the `ratel-assessment` skill on this repository. It
will produce a markdown report at `docs/ratel-assessment-<date>.md`
with a 10-dimension scorecard, evidence-backed findings, and a
"Where Ratel fits" section.

Once we've reviewed the report together, run the `ratel-integrate`
skill to produce a concrete rollout plan (integration mode, pilot
scope, A/B test design, Langfuse metrics) at
`docs/ratel-integrate.md`.

Show me the scorecard inline and link to the report file.

Two skills are surfaced explicitly here. The other three (instrument, dashboards, analyze) are reachable via the assessment report's "Recommended next steps" section — every finding routes to the right follow-up skill.

What's inside

Five skills, in the order a partner engagement typically uses them:

SkillWhat it doesWhen to fire
ratel-assessmentStatic read of the agent codebase. Produces a polished assessment report at <repo>/docs/ratel-assessment-<date>.md with a 10-dimension scorecard, evidence-backed findings, and conditional pointers to the right follow-up skill.First touch. Zero partner setup.
ratel-langfuse-instrumentDetects the agent stack, maps topology, decides naming + tagging vocabulary, writes a file-by-file Langfuse instrumentation plan.After assessment flags Observability as Weak / Missing.
ratel-langfuse-dashboardsDesigns two dashboard groups — Ratel-value (Token Cost & Savings, Retrieval Quality, Gateway Origin Split, Upstream Health) and general agent health — as a markdown spec the partner builds by hand in the Langfuse UI.After instrumentation lands.
ratel-integratePlans the Ratel rollout: detects tool management, fetches up-to-date Ratel docs, picks integration mode (direct SDK / MCP gateway / hybrid), picks pilot scope, designs the A/B test, ties success to specific Langfuse metrics.After observability is in.
ratel-langfuse-analyzeReads live Langfuse traces via the Langfuse MCP server, drills into outliers, pattern-matches against a finding catalog, writes a findings report split into Ratel-flavored and stack-agnostic improvements.After traffic accumulates under the A/B split.

The engagement arc

ratel-assessment          → "here's what's weak; here's where Ratel fits"
        ↓
ratel-langfuse-instrument → "here's how to see what's happening"
        ↓
ratel-langfuse-dashboards → "here's what to put on the screens"
        ↓
ratel-integrate           → "here's how to roll Ratel out + A/B it"
        ↓
ratel-langfuse-analyze    → "here's what the data says after the rollout"

Each skill's "Recommended next steps" section names which sibling to run next based on what it found — the arc isn't a forced sequence, it's a conditional flow.

Shared sources of truth

The skills reference each other so the vocabulary stays consistent across an engagement. No file is duplicated:

  • Naming vocabulary — skills/ratel-langfuse-instrument/references/naming-conventions.md. The canonical trace / observation / tag / metadata names. Read by every other skill.
  • Ratel feature → signal → version map — skills/ratel-langfuse-dashboards/references/ratel-value-map.md. The single source of truth for "what Ratel ships when." Read by ratel-assessment and ratel-langfuse-analyze for their Ratel angles.
  • Trace event → Langfuse observation mapping — skills/ratel-langfuse-instrument/references/ratel-hooks.md. Read by ratel-integrate.

When Ratel ships a new feature, the value-map is the one file to update — the angles in the assessment catalog and the findings in the analyze catalog cascade from it.

Use them in your engagement

For Ratel-side readers — when to fire each skill:

  • First conversation with a partner: fire /ratel-assessment against their repo before any sales pitch. The report is the credibility layer; "let's pilot Ratel" is the conclusion the partner reaches on their own once they've read it.
  • After they say yes to a pilot: fire /ratel-langfuse-instrument to get observability in place (a Ratel rollout you can't measure is indistinguishable from no rollout).
  • Before the rollout: fire /ratel-langfuse-dashboards to set up what you'll measure.
  • Rollout week: fire /ratel-integrate for the file-by-file plan + A/B design.
  • Two weeks in: fire /ratel-langfuse-analyze against live traces to find both Ratel-flavored deepening opportunities and stack-agnostic low-hanging fruit you can spot for them.

The reports each skill writes are markdown files committed into the partner's repo under docs/ — they accumulate and become the artifact of the engagement.

Conventions

Every skill in this suite follows the same rules:

  • No emojis. Imperative voice. The skills are for engineering audiences who tune out marketing tone.
  • Pushy multi-phrase descriptions. Each skill's frontmatter trigger description names many phrasings so the skill fires reliably from natural language.
  • Honest skip path. If a skill's preconditions aren't met (no agent surface, no observability, no traffic), it stops and says so. It does not fabricate a deliverable.
  • Markdown output, committed into the partner repo. All deliverables go to <repo>/docs/ so they're reviewable, diff-able, and accumulate across runs.
  • Cross-skill references, not duplication. Shared vocabulary lives in one place; every other skill links to it.

License

MIT. Free to use, modify, redistribute.

Ver o original no GitHub

Bom para

Relacionados