Software that learns from
every execution

curl -X POST http://localhost:3000/api/v1/nodes   -H "Content-Type: application/json"   -H "Authorization: Bearer <token>"   -d '{
    "node_id":      "node-alpha",
    "endpoint":     "https://alpha.example.com",
    "public_key":   "<base64-ed25519-pubkey>",
    "capabilities": ["gene-store", "capsule-store"]
  }'

curl http://localhost:3000/api/v1/nodes  # list all nodes

# Fan-out gene search across all healthy nodes
curl "http://localhost:3000/api/v1/federation/genes?q=fix_timeout"

# Filter by task class and minimum confidence
curl "http://localhost:3000/api/v1/federation/genes?task_class=network_retry&min_confidence=0.8"

# Response aggregates results from every healthy node:
# {"results":[...],"nodes_queried":3,"nodes_healthy":3}

curl -X POST http://localhost:3000/api/v1/subscriptions   -H "Content-Type: application/json"   -H "Authorization: Bearer <token>"   -d '{
    "callback_url": "https://my-node.example.com/hooks/gene",
    "events":       ["gene_promoted","gene_revoked"],
    "filter":       {"min_confidence":0.8}
  }'

# Hub delivers a signed POST to your callback_url
# when any registered node promotes or revokes a matching gene.

from oris_sdk import OrisClient, OrisConfig, Gene
from datetime import datetime

# Initialize — local SQLite storage, no network needed
client = OrisClient(OrisConfig(store_path="my_genes.db"))

# Save a gene locally
gene = Gene(
    gene_id="retry-backoff-1",
    name="exponential-retry",
    task_class="error-handling",
    confidence=0.92,
    strategy={"approach": "exponential_backoff", "max_retries": 5},
    signals={"error_rate": 0.15},
    use_count=12,
    success_count=11,
    source="local",
    created_at=datetime.now(),
    updated_at=datetime.now(),
)
client.store.save(gene)

# Query genes by task class
results = client.store.query(task_class="error-handling", min_confidence=0.8)
print(f"Found {len(results)} high-confidence genes")

# Update stats after using a gene
client.store.update_stats("retry-backoff-1", used=True, success=True)

# Context manager support
with OrisClient(OrisConfig(store_path=":memory:")) as c:
    c.store.save(gene)
    print(c.store.get("retry-backoff-1").name)

import { OrisClient } from "@colin4k1024/oris-sdk";
import type { Gene } from "@colin4k1024/oris-sdk";

// Initialize — local SQLite storage, no network needed
const client = new OrisClient({ storePath: "my_genes.db" });

// Save a gene locally
const gene: Gene = {
  geneId: "retry-backoff-1",
  name: "exponential-retry",
  taskClass: "error-handling",
  confidence: 0.92,
  strategy: { approach: "exponential_backoff", max_retries: 5 },
  signals: { error_rate: 0.15 },
  useCount: 12,
  successCount: 11,
  contributorId: "agent-1",
  source: "local",
  createdAt: new Date(),
  updatedAt: new Date(),
};
client.store.save(gene);

// Query genes by task class
const results = client.store.query({
  taskClass: "error-handling",
  minConfidence: 0.8,
});
console.log(`Found ${results.length} high-confidence genes`);

// Update stats after using a gene
client.store.updateStats("retry-backoff-1", true, true);

// Clean up
client.close();

from oris_sdk import OrisClient, OrisConfig, Gene
from oris_sdk.mysql_store import MySQLConfig
from datetime import datetime, timezone

# Initialize with MySQL — shared storage for teams
client = OrisClient(OrisConfig(
    mysql=MySQLConfig(
        host="127.0.0.1",
        port=3306,
        user="oris",
        password="secret",
        database="oris",
    )
))

# Same API as SQLite — save, query, update
gene = Gene(
    gene_id="retry-backoff-1",
    name="exponential-retry",
    task_class="error-handling",
    confidence=0.92,
    strategy={{"approach": "exponential_backoff"}},
    source="local",
    created_at=datetime.now(timezone.utc),
    updated_at=datetime.now(timezone.utc),
)
client.store.save(gene)

results = client.store.query(task_class="error-handling", min_confidence=0.8)
print(f"Found {{len(results)}} genes in MySQL")

# Or connect via DSN string
from oris_sdk.mysql_store import MySQLStore
store = MySQLStore.from_url("mysql://oris:secret@127.0.0.1:3306/oris")

import {{ OrisClient }} from "@colin4k1024/oris-sdk";
import type {{ Gene }} from "@colin4k1024/oris-sdk";

// Initialize with MySQL — shared storage for teams
// Note: requires `npm install mysql2`
const client = await OrisClient.create({{
  mysql: {{
    host: "127.0.0.1",
    port: 3306,
    user: "oris",
    password: "secret",
    database: "oris",
  }},
}});

// Same API as SQLite — save, query, update
const gene: Gene = {{
  geneId: "retry-backoff-1",
  name: "exponential-retry",
  taskClass: "error-handling",
  confidence: 0.92,
  strategy: {{ approach: "exponential_backoff" }},
  source: "local",
  useCount: 0,
  successCount: 0,
  contributorId: "agent-1",
  createdAt: new Date(),
  updatedAt: new Date(),
}};
await client.store.save(gene);

const results = await client.store.query({{
  taskClass: "error-handling",
  minConfidence: 0.8,
}});
console.log(`Found ${{results.length}} genes in MySQL`);

client.close();

from oris_sdk import OrisClient, OrisConfig

# Initialize with Experience Repo connection
client = OrisClient(OrisConfig(
    store_path="my_genes.db",
    experience_base_url="https://experience.oris.dev",
    experience_api_key="your-api-key",
    experience_seed=b"your-32-byte-ed25519-seed-here..",
    experience_sender_id="agent-1",
))

# Push unsynced local genes to Experience Repo
result = client.sync.push_to_hub()
print(f"Pushed {result.pushed} genes, {result.failed} failed")

# Pull community genes from Experience Repo
imported = client.sync.pull_from_hub()
print(f"Imported {imported} new genes")

# Push specific genes only
result = client.sync.push_to_hub(gene_ids=["retry-backoff-1", "cache-warm-2"])

# Pull with filters
imported = client.sync.pull_from_hub(
    q="error-handling",
    min_confidence=0.85,
    limit=50,
)

# Check sync history
logs = client.sync.get_sync_log(limit=20)
for log in logs:
    print(f"  {log.direction} {log.gene_id}: {log.status}")

import { OrisClient } from "@colin4k1024/oris-sdk";

// Initialize with Experience Repo connection
const seed = new Uint8Array(32); // Your Ed25519 seed
const client = new OrisClient({
  storePath: "my_genes.db",
  experience: {
    baseUrl: "https://experience.oris.dev",
    apiKey: "your-api-key",
    seed,
    senderId: "agent-1",
  },
});

// Push unsynced local genes to Experience Repo
const result = await client.sync.pushToHub();
console.log(`Pushed ${result.pushed} genes, ${result.failed} failed`);

// Pull community genes from Experience Repo
const imported = await client.sync.pullFromHub();
console.log(`Imported ${imported} new genes`);

// Push specific genes only
await client.sync.pushToHub({ geneIds: ["retry-backoff-1", "cache-warm-2"] });

// Pull with filters
await client.sync.pullFromHub({
  q: "error-handling",
  minConfidence: 0.85,
  limit: 50,
});

// Check sync history
const logs = client.sync.getSyncLog(20);
logs.forEach((l) => console.log(`  ${l.direction} ${l.geneId}: ${l.status}`));

client.close();

from oris_sdk import HubClient, HubConfig, ExecutionClient, ExecutionConfig
from oris_sdk import ExperienceClient, ExperienceConfig

# Hub — register a node
hub = HubClient(HubConfig(base_url="http://hub:8080", api_key="key",
                           seed=b"32-byte-ed25519-seed-here.......", node_id="n1"))
hub.register(endpoint="http://my-node:9000", capabilities=["evolve"], version="0.1.0")

# Execution — run a job
exe = ExecutionClient(ExecutionConfig(base_url="http://exec:8080", token="tok"))
job = exe.run_job(thread_id="thread-1", input={"task": "hello"})

# Experience — share a gene
exp = ExperienceClient(ExperienceConfig(base_url="http://exp:8080", api_key="ak",
                                         seed=b"32-byte-ed25519-seed-here.......", sender_id="agent-1"))
gene = exp.share({"gene_id": "g1", "confidence": 0.9})

import { HubClient, ExecutionClient, ExperienceClient } from "@colin4k1024/oris-sdk";

// Hub — register a node
const seed = new Uint8Array(32); // Ed25519 seed
const hub = new HubClient({ baseUrl: "http://hub:8080", apiKey: "key", seed, nodeId: "n1" });
const reg = await hub.register("http://my-node:9000", ["evolve"], "0.1.0");

// Execution — run a job
const exe = new ExecutionClient({ baseUrl: "http://exec:8080", token: "tok" });
const job = await exe.runJob("thread-1", { task: "hello" });

// Experience — share a gene
const exp = new ExperienceClient({ baseUrl: "http://exp:8080", apiKey: "ak", seed, senderId: "agent-1" });
const gene = await exp.share({ gene_id: "g1", confidence: 0.9 });