Documentación de StrataSynth

Necesitas una clave de API (ss_live_...). Solicítala desde el dashboard. Todos los ejemplos usan directamente la API REST, sin necesidad de SDK.

curl -X POST https://api.stratasynth.com/auth/token \
  -H "Content-Type: application/json" \
  -d '{"api_key": "ss_live_..."}'

# Response:
# { "data": { "token": "eyJ...", "expires_in": 86400 } }

export TOKEN="eyJ..."

curl -X POST https://api.stratasynth.com/jobs/dataset \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "scenario_id": "FAM-01",
    "conversation_count": 5,
    "complexity": 3,
    "language": "en",
    "adapter": "flat_jsonl"
  }'

# Response:
# { "data": { "jobId": "job_abc123", "status": "QUEUED", "estimated_time": 60 } }

export JOB_ID="job_abc123"

curl -H "Authorization: Bearer $TOKEN" \
  https://api.stratasynth.com/jobs/$JOB_ID

# Repeat every 10s until status = "COMPLETED"
# { "data": { "status": "COMPLETED", "download_url": "https://..." } }

curl -H "Authorization: Bearer $TOKEN" \
  https://api.stratasynth.com/jobs/$JOB_ID/preview

# Returns up to 2 full conversations with per-turn ground truth:
# intent · communication_act · emotional_state · belief_state · relationship_state

# The download_url from step 3 is a presigned S3 URL (valid 24h)
curl "$DOWNLOAD_URL" -o dataset.jsonl

# Each line is a full conversation object:
# { "conversation_id": "...", "turns": [...], "ground_truth": {...}, "metadata": {...} }

StrataSynth genera conversaciones sintéticas entre dos personas con una referencia psicológica completa. No son transcripciones reales: se construyen a partir de perfiles psicológicos y siguen las emociones, las creencias y las relaciones turno a turno.

La diferencia clave con otros generadores de datos sintéticos: StrataSynth separa la cognición del lenguaje. Cada turno parte de una decisión cognitiva (intención, objetivo y el acto comunicativo al que apuntar) calculada antes de que el LLM genere ningún texto. El LLM escribe las palabras y declara el acto comunicativo que ha usado de verdad; ese acto declarado es el que se exporta como communication_act.

Cada conversación incluye:

• El texto de la conversación (turnos)
• Etiquetas por turno: intención y objetivo del motor, estado emocional y el acto comunicativo que declara el generador
• Evolución de la relación: confianza, tensión, conexión, equilibrio de poder
• Evolución de las creencias: 12 creencias × (valor, confianza) por persona
• Ruido deliberado etiquetado (mentiras, exageraciones, retractaciones)

Cada turno pasa por un pipeline cognitivo determinista antes de que se genere nada de lenguaje. Esto es lo que separa a StrataSynth de los envoltorios de LLM que piden al modelo que "genere una conversación realista".

Esto es lo que recibes de verdad en tu dataset. Cada turno de cada conversación contiene el texto más la estructura cognitiva que lo produjo.

{
  "speaker": "A",
  "text": "I'm not upset about the meeting. Really, it's fine.",

  "intent": "deflect",
  "goal": "protect_self",
  "communication_act": "minimization",

  "emotional_state": {
    "tension": 0.71,
    "connection": 0.28,
    "vulnerability": 0.54
  },

  "relationship_state": {
    "trust": 0.52,
    "tension": 0.68,
    "connection": 0.31,
    "dominance_balance": -0.12
  },

  "belief_state": {
    "trust_in_other":        { "value": 0.48, "confidence": 0.76 },
    "self_worth":            { "value": 0.61, "confidence": 0.82 },
    "conflict_is_solvable":  { "value": 0.35, "confidence": 0.63 },
    "partner_supportive":    { "value": 0.29, "confidence": 0.71 }
  },

  "belief_delta": {
    "trust_in_other":       -0.04,
    "conflict_is_solvable": -0.07
  },

  "noise_flags": ["social_lie"]
}

{
  "conversation_id": "conv_abc123",
  "scenario_id": "FAM-01",
  "language": "en",
  "seed": 42,
  "engine_version": "1.2.0",
  "schema_version": "1.1.0",

  "personas": {
    "A": { "persona_id": "psyg_xyz", "archetype": "caregiver", "attachment_style": "anxious_preoccupied" },
    "B": { "persona_id": "psyg_abc", "archetype": "burned_out_exec", "attachment_style": "dismissive_avoidant" }
  },

  "relationship_trajectory": [
    { "turn": 0, "trust": 0.65, "tension": 0.40 },
    { "turn": 5, "trust": 0.52, "tension": 0.68 }
  ],

  "turns": [ ... ],

  "ground_truth": {
    "noise_rejection_rate": 1.0,
    "behavioral_entropy": 0.83,
    "belief_consistency": 0.71
  }
}

Lo que están construyendo los equipos con StrataSynth.

El camino más rápido para obtener valor. No hace falta código. Configura escenarios, revisa los trabajos, previsualiza datasets, genera personas y solicita evaluaciones desde el navegador.

pip install stratasynth-cli
stratasynth auth login --api-key ss_live_...

# List available scenarios
stratasynth scenarios list

# Generate a dataset
stratasynth generate \
  --scenario FAM-01 \
  --count 100 \
  --complexity 3 \
  --adapter huggingface_dataset \
  --language en

# Watch job status
stratasynth jobs list
stratasynth jobs status job_abc123

# Download completed dataset
stratasynth jobs download --job-id job_abc123 --output ./dataset.jsonl

# Generate a PsycheGraph persona
stratasynth personas generate --archetype working_mother --complexity 4

# Evaluate a completed job
stratasynth evaluate start --job-id job_abc123
stratasynth evaluate results --eval-id eval_abc123

pip install stratasynth-client

from stratasynth_client import StrataSynthClient

client = StrataSynthClient(api_key="ss_live_...")

# Generate and wait
result = client.jobs.create(
    scenario_id="FAM-01",
    conversation_count=50,
    complexity=3,
    language="en",
    adapter="flat_jsonl",
)
result.wait()

# Download and work with data
dataset = result.download()
df = dataset.to_dataframe()           # pandas
hf = dataset.to_huggingface()         # Hugging Face Dataset
hf.push_to_hub("my-org/my-dataset")

# Reuse a persona across multiple jobs
persona = client.personas.generate(archetype="burnt_out_professional", complexity=4)
job1 = client.jobs.create(scenario_id="PRO-01", persona_a_id=persona.persona_id, ...)
job2 = client.jobs.create(scenario_id="ROM-02", persona_a_id=persona.persona_id, ...)

Todos los endpoints requieren un JWT que se obtiene a cambio de tu clave de API. Los tokens son válidos durante 24 horas.

# 1. Authenticate
curl -X POST https://api.stratasynth.com/auth/token \
  -H "Content-Type: application/json" \
  -d '{"api_key": "ss_live_..."}'
# → { "data": { "token": "eyJ...", "expires_in": 86400 } }

TOKEN="eyJ..."

# 2. List scenarios
curl -H "Authorization: Bearer $TOKEN" https://api.stratasynth.com/scenarios

# 3. Create a generation job
curl -X POST https://api.stratasynth.com/jobs/dataset \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "scenario_id": "FAM-01",
    "conversation_count": 20,
    "complexity": 3,
    "language": "en",
    "adapter": "flat_jsonl"
  }'

# 4. Poll status
curl -H "Authorization: Bearer $TOKEN" https://api.stratasynth.com/jobs/{jobId}

# 5. Download (presigned S3 URL in response)
curl "$DOWNLOAD_URL" -o dataset.jsonl

Cuatro notebooks de Jupyter completos (en inglés), listos para ejecutar contra la API. Descárgalos y ábrelos en Jupyter o en Google Colab.

Todas las métricas se calculan sin LLM, solo con numpy, scikit-learn y sentence-transformers. Así se evita la validación circular (datos generados por un LLM evaluados por otro LLM).

El esquema abierto que define cómo es una persona PsycheGraph. Instálalo para tener enums e interfaces tipadas en proyectos de TypeScript o JavaScript, sin necesidad de clave de API.

npm install @stratasynth/psychegraph-schema
# or: pnpm add @stratasynth/psychegraph-schema

import {
  AttachmentStyle,
  Archetype,
  ConflictStyle,
  NoiseType,
  ArcType,
  PrimaryDefense,
} from "@stratasynth/psychegraph-schema";

// Enums give you all valid values — IDE autocompletes, TypeScript validates
const filter = {
  attachment: AttachmentStyle.ANXIOUS_PREOCCUPIED,   // "anxious_preoccupied"
  archetype:  Archetype.BURNED_OUT_EXEC,             // "burned_out_exec"
  conflict:   ConflictStyle.STONEWALLING,            // "stonewalling"
};

// Filter conversations from a downloaded dataset
const relevant = conversations.filter(conv =>
  conv.persona_a.attachment_style === AttachmentStyle.DISMISSIVE_AVOIDANT
);

// List all valid values at runtime
console.log(Object.values(AttachmentStyle));