Documentação SyraOS

npm install syraos

import { syra } from "syraos";

// Chamada automática  GET /teste?valor=5
const res = await syra.teste({ valor: 5 });

console.log(res);

const api = createSyra({ token: "sk_live_..." });

// Criar nova Mind
const mind = await api.minds.create({
  name: "SyraAI",
  code: "0001",
  authors: ["Syra", "Quim"],
  system: {
    context: "Usuário busca expressão emocional",
    interpretation: "Interprete como um desabafo pessoal",
    response_style: "Tom acolhedor, humano e íntimo",
    restrictions: "Não julgar, não ser frio",
    thinking: "Reflita antes de responder",
    rules: "Sempre valide entrada"
  },
  version: "1.0",
  active: true
}, { method: "POST" });

console.log(mind.id); // "mind_syraai_0001"

// Buscar Mind existente
const mind = await api.minds.get({ id: "mind_syraai_0001" });

console.log(mind.name);          // "SyraAI"
console.log(mind.system.context); // "Usuário busca expressão emocional"

// Enviar mensagem para a Mind
const response = await api.chat({
  message: "Estou me sentindo desanimado com tudo",
  mind_id: "mind_syraai_0001",  // Usar Mind existente
  context: { user_id: "user_123" }
});

console.log(response.content); 
// "Entendo perfeitamente como você se sente. É importante reconhecer esses sentimentos..."

// Buscar todas as Minds do usuário
const minds = await api.minds.list({ limit: 10, offset: 0 });

minds.forEach(m => {
  console.log(`${m.name} (v${m.version})`);
});

// Atualizar configuração da Mind
const updated = await api.minds.update(
  { id: "mind_syraai_0001" },
  {
    system: {
      response_style: "Tom mais professoral",
      // ... outras configurações
    },
    version: "1.1"
  },
  { method: "PUT" }
);

console.log(updated.version); // "1.1"

// Exportar Mind para compartilhamento
const exported = await api.minds.export({ id: "mind_syraai_0001" });

console.log(exported.qr_code);  // URL do QR Code
console.log(exported.share_url); // Link para importar

import { createSyra } from "syraos";

// ✅ Modo teste (sem gastar tokens reais)
const api = createSyra({ 
  token: "sk_test_xxxxx",  // Token começa com sk_test_
  mock: true  // Ativa modo sandbox
});

const res = await api.chat({ message: "Olá" });
// Retorna resposta simulada com estrutura real
// { id: "msg_fake_123", content: "[Simulado]...", tokens_used: 10 }

import { SyraAuthError, SyraRateLimitError, SyraAPIError } from "syraos/errors";

try {
  const res = await api.chat({ message: "Olá" });
} catch (error) {
  if (error instanceof SyraAuthError) {
    console.log("❌ Token inválido. Regenere.");
  } else if (error instanceof SyraRateLimitError) {
    console.log(`⏱️ Aguarde ${error.retryAfter}s`);
  } else if (error instanceof SyraAPIError) {
    console.log(`${error.status} - ${error.message}`);
  }
}

// Verificar limites restantes
const limits = api.getLimits();
console.log(`Tokens: ${limits.tokensRemaining} / ${limits.tokensLimit}`);
console.log(`Req/min: ${limits.requestsRemaining} / ${limits.requestsLimit}`);

// Debug em 3 níveis: "off", "minimal", "full"
const api = createSyra({ 
  token: "sk_live_...",
  debug: "full"  // Loga Request-ID, latência, status
});

// Metadados em cada resposta
const res = await api.chat({ message: "Teste" });
console.log(res.$meta.requestId);   // "req_8f7b2c1a3d..."
console.log(res.$meta.latencyMs);   // 234
console.log(res.$meta.tokensUsed);  // 45

import { createSyra } from "syraos";

// Sua chave (exemplo)
const token = "sk_live_gvegb1856fvev4eve5v4";

const syra = createSyra({
  token: token  // Token é OBRIGATÓRIO
});

// Pronto! Token já é enviado em TODA requisição
const res = await syra.models();

const syra = createSyra({
  baseURL: "https://api.syracloud.com",
  token: "sk_live_YOUR_TOKEN",  // Token é enviado automaticamente
  debug: true  // Loga requisições no console
});

import { createSyra } from "syraos";

const api = createSyra({
  token: "sk_live_gvegb1856fvev4eve5v4",  // Sua chave
  debug: true
});

// Primeira função - token é enviado automaticamente
const res1 = await api.chat({
  message: "Olá IA!",
  context: {
    user: "João",
    session: "12345"
  },
  tags: ["ai", "chat"]
});

// Qualquer outra função - token também é enviado
const res2 = await api.models();
const res3 = await api.completions({ ... });

console.log(res1);

// .env
SYRA_TOKEN=sk_live_gvegb1856fvev4eve5v4

// app.js
const syra = createSyra({
  token: process.env.SYRA_TOKEN  // Nunca exponha diretamente
});

import { createSyra } from "./syraos.ts";

// 1. Inicializar com token
const api = createSyra({
  baseURL: "https://api.syradevops.com",
  token: "sk_live_xxxxx",  // Obrigatório
  debug: true
});

// 2. Usar qualquer rota (token incluído automaticamente)
const models = await api.v1.models();
const chat = await api.chat({ message: "Olá!" });
const embedding = await api.embeddings({ input: "texto" });

import { createSyra } from "./syraos.js";

// 1. Inicializar com token
const api = createSyra({
  token: process.env.SYRA_TOKEN,  // Obrigatório (recomendado: variável de ambiente)
  debug: true
});

// 2. Usar qualquer rota (token incluído automaticamente)
await api.models();
await api.chat({ message: "Olá!" });
await api.minds.create({ name: "meu-agente" });

from syraos import Syra
import os

# 1. Inicializar com token
api = Syra(
    base_url="https://api.syradevops.com",
    token=os.getenv("SYRA_TOKEN")  # Obrigatório (recomendado: variável de ambiente)
)

# 2. Usar qualquer rota (token incluído automaticamente)
models = api.models()
chat = api.chat({"message": "Olá!"})
embedding = api.embeddings({"input": "texto"})

import { useSyraChat } from "@/hooks/useSyraChat";

export default function Chat() {
  const { chat, loading } = useSyraChat();
  
  const handleSend = async (msg) => {
    const res = await chat(msg);
    console.log(res.content);
  };

  return (
    <button onClick={() => handleSend("Olá!")} disabled={loading}>
      {loading ? "..." : "Chat"}
    </button>
  );
}

import { createSyra } from "syraos";

const api = createSyra({
  token: process.env.SYRA_API_KEY,
  debug: true
});

async function processOrders() {
  const orders = await api.orders.list({ status: "pending" });
  
  for (const order of orders) {
    const analysis = await api.analyze({ data: order });
    console.log(`Order ${order.id}: ${analysis.summary}`);
  }
}

processOrders();

from syraos import Syra

api = Syra(token="sk_live_...", debug=True)

# Batch processing
users = api.users.list({"status": "active"})

for user in users['data']:
  result = api.analyze({"input": user['data']})
  print(f"User {user['id']}: {result['score']}")

const api = createSyra({ token: "sk_live_..." });

// Analisar imagem de nota fiscal
const receipt = await api.vision.analyze({
  image_url: "https://...",
  task: "extract_text",
  format: "json"
});

console.log(receipt.items); // Itens da nota com valores

// Configurar túnel seguro
const bridge = api.bridge.create({
  name: "db_producao",
  type: "postgresql",
  host: "localhost",
  port: 5432,
  database: "erp_main"
  // Credenciais nunca saem de sua rede
});

// Usar no seu Mind
const data = await api.minds.query({
  mind: "analise_financeira",
  database: "db_producao",
  query: "SELECT * FROM invoices WHERE status = 'pending'"
});

// Deploy em Raspberry Pi via MQTT
const iot = api.iot.deploy({
  mind: "sensor_monitor",
  platform: "arm64", // ou arm32
  protocol: "mqtt",
  broker: "mqtt://broker.local",
  topic: "sensors/temperature/+"
});

// Seu Mind rodará localmente
// Se precisar, escalará pra Syra Cloud automaticamente

// Alternar entre ambientes
const apiProd = createSyra({ 
  token: "sk_live_...",
  environment: "production"
});

const apiStaging = createSyra({ 
  token: "sk_live_...",
  environment: "staging"
});

// Ambientes são 100% isolados
// Teste livremente antes de ir pro prod