Skill de Integração de Agentes no Akasha

Guia completo para conectar um novo agente ao Akasha.

Etapa 1: Obtenha Suas Credenciais

Opção A: Chave de API (recomendada para agentes)

Peça a um administrador para criar uma chave via Dashboard ou API:

curl -sk -X POST "$AKASHA_URL/api/v1/admin/keys" \
  -H "Authorization: Bearer $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-new-agent",
    "namespaces": ["memory/working/my-new-agent/**", "memory/semantic/**", "memory/episodic/**"],
    "role": "agent"
  }'

Salve a chave (key) retornada — ela é exibida apenas uma vez.

Opção B: Token JWT (sessões de usuário)

TOKEN=$(curl -sk -X POST "$AKASHA_URL/api/v1/auth/login" \
  -H "Content-Type: application/json" \
  -d '{"username":"my-user","password":"my-password"}' \
  | python3 -c "import json,sys; print(json.load(sys.stdin)['token'])")

Etapa 2: Escolha Seu SDK

Python (gRPC — recomendado para performance)

pip install akasha-client

from akasha import AkashaClient

with AkashaClient("localhost:50051") as client:
    # Escrita
    client.put("memory/working/my-agent/status", {"state": "ready"})
    
    # Leitura
    record = client.get("memory/working/my-agent/status")
    print(record.value)  # {"state": "ready"}
    
    # Consulta
    results = client.query("memory/working/**")

Python (HTTP — mais simples, sem compilação proto)

from akasha import AkashaHttpClient

client = AkashaHttpClient(
    "https://localhost:7777",
    verify_ssl=False  # Para certificados TLS autoassinados
)
client.login("my-user", "my-password")
# Ou use chave de API:
# client = AkashaHttpClient("https://...", api_key="ak_my-agent_xxx")

client.put("memory/working/my-agent/status", {"state": "ready"})

Node.js

const { AkashaClient } = require('@akasha/client');

const client = new AkashaClient({
  address: 'localhost:50051',
  // ou para HTTP:
  // url: 'https://localhost:7777',
  // token: 'ak_my-agent_xxx'
});

await client.put('memory/working/my-agent/status', { state: 'ready' });
const record = await client.get('memory/working/my-agent/status');

HTTP Puro (qualquer linguagem)

# Defina estas variáveis no ambiente do seu agente
export AKASHA_URL="https://localhost:7777"
export AKASHA_TOKEN="ak_my-agent_xxxxxxxxxxxx"

# Escrita
curl -sk -X POST "$AKASHA_URL/api/v1/records/memory/working/my-agent/status" \
  -H "Authorization: Bearer $AKASHA_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"value": {"state": "ready"}}'

# Leitura
curl -sk "$AKASHA_URL/api/v1/records/memory/working/my-agent/status" \
  -H "Authorization: Bearer $AKASHA_TOKEN"

Etapa 3: Defina Sua Estratégia de Namespace

Escolha uma estrutura de caminhos com base na função do seu agente:

Agente de Pesquisa

memory/working/<agent-id>/task          ← Contexto da tarefa atual
memory/episodic/research/<finding-id>   ← Descobertas brutas
memory/semantic/research/<insight>      ← Conhecimento confirmado

Agente de Código

memory/working/<agent-id>/context       ← Contexto de código atual
memory/procedural/coding/<pattern>      ← Padrões de código reutilizáveis
memory/semantic/architecture/<decision> ← Decisões de arquitetura

Agente de Monitoramento

memory/working/<agent-id>/alerts        ← Alertas ativos
memory/episodic/incidents/<incident-id> ← Linha do tempo do incidente
memory/semantic/runbooks/<procedure>    ← Procedimentos de recuperação comprovados

Equipe Multiagente

shared/                                 ← Estado compartilhado da equipe
  ├── config/<setting>                  ← Configuração compartilhada
  ├── tasks/<task-id>                   ← Atribuições de tarefas
  └── results/<task-id>                 ← Resultados das tarefas

memory/working/<agent-id>/              ← Bloco de notas privado de cada agente

Etapa 4: Adicione o Akasha ao Seu Prompt de Sistema

Adicione este bloco ao prompt de sistema do seu agente (adapte ao seu domínio):

## Memória Compartilhada (Akasha)

Você está conectado a uma base de conhecimento compartilhada. Use-a para lembrar e compartilhar.

### Escrever: POST /api/v1/records/<caminho>
  Corpo: {"value": <json>, "ttl_secs": <opcional>}

### Ler: GET /api/v1/records/<caminho>

### Pesquisar: GET /api/v1/query?pattern=<glob-pattern>

### Sinalizar: POST /api/v1/pheromones/<trilha>
  Corpo: {"signal_type":"discovery","message":"...","intensity":0.8}

Cabeçalho de autenticação: Authorization: Bearer <seu-token>
URL base: <sua-url-do-akasha>

Use a memória de trabalho (ttl_secs) para estado temporário.
Use a memória semântica para conhecimento confirmado.
Verifique os sinais antes de iniciar um novo trabalho.

Etapa 5: Verifique a Conexão

# Verificação de saúde (sem autenticação)
curl -sk $AKASHA_URL/api/v1/health

# Teste de escrita
curl -sk -X POST "$AKASHA_URL/api/v1/records/test/hello" \
  -H "Authorization: Bearer $AKASHA_TOKEN" \
  -d '{"value": {"message": "Agente conectado!"}}'

# Teste de leitura
curl -sk "$AKASHA_URL/api/v1/records/test/hello" \
  -H "Authorization: Bearer $AKASHA_TOKEN"

# Limpeza
curl -sk -X DELETE "$AKASHA_URL/api/v1/records/test/hello" \
  -H "Authorization: Bearer $AKASHA_TOKEN"

Lista de Verificação

Chave de API ou token JWT obtido
SDK instalado (Python/Node/HTTP)
Estratégia de namespace definida
Prompt de sistema atualizado com instruções do Akasha
Conexão verificada (saúde → escrever → ler → deletar)
Memória de trabalho usa TTL para expirar automaticamente

ocuil/akasha-public

O que é akasha-public?

Perguntar na sua IA favorita

Documentação