Hermion API & MCP

curl https://classifier.hermionai.xyz/access

curl -X POST https://classifier.hermionai.xyz/classify \
  -H "Content-Type: application/json" \
  -H "X-Hermion-Key: <your-passkey>" \
  -d '{
    "messages": [
      { "actor": "Alex", "ts": "2025-01-01T10:00:00Z", "text": "I really miss you" },
      { "actor": "Sam",  "ts": "2025-01-01T10:05:00Z", "text": "Miss you too" },
      { "actor": "Alex", "ts": "2025-01-01T10:06:00Z", "text": "Back next week" }
    ]
  }'

curl -X POST https://api.hermionai.xyz/api/v1/analyze \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer herm_sk_live_..." \
  -d '{
    "signals": [ /* signals from step 2 */ ],
    "context_type": "relationship",
    "self_name": "Alex"
  }'

Alex Chen  00:01:23
We've been seeing really strong retention numbers.
 
Chen Wei  00:01:30
That's encouraging. What does churn look like?

00:01:23.000 --> 00:01:28.000
<v Alex Chen>We've been seeing really strong retention numbers.
 
00:01:28.500 --> 00:01:34.000
<v Chen Wei>That's encouraging. What does churn look like?

Alex Chen: We've been seeing really strong retention numbers.
Chen Wei: That's encouraging. What does churn look like?

**Alex Chen:** We've been seeing really strong retention numbers.
 
**Chen Wei:** That's encouraging. What does churn look like?

// After parsing any format above, your messages look like this:
const messages = [
  {
    actor: "Alex Chen",
    ts: "2025-01-01T00:01:23Z",  // from transcript, or synthetic
    text: "We've been seeing really strong retention numbers."
  },
  {
    actor: "Chen Wei",
    ts: "2025-01-01T00:01:30Z",
    text: "That's encouraging. What does churn look like?"
  }
]
 
// Then call the classifier exactly as normal — nothing changes:
const response = await fetch("https://classifier.hermionai.xyz/classify", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-Hermion-Key": "<your-passkey>"
  },
  body: JSON.stringify({ messages })
})

const actorGroups = {
  "Alex":  "Startup",         // Group 1
  "Maya":  "Startup",         // Group 1
  "Chen":  "Investor Group",  // Group 2
  "James": "Investor Group",  // Group 2
  // Any actor not listed is ignored — stripped completely before classification
}

function prepareGroupMessages(allMessages, actorGroups) {
  const total = allMessages.length
 
  // Bypass: if no actors are ignored, all messages are between the two groups
  const ignoredExists = allMessages.some(m => !(m.actor in actorGroups))
  if (!ignoredExists) {
    return allMessages
      .filter(m => m.actor in actorGroups)
      .map(m => ({ ...m, actor: actorGroups[m.actor] }))
  }
 
  // Compute group-level spacing (combined message count per group)
  const groupNames = [...new Set(Object.values(actorGroups))]
  const groupCounts = Object.fromEntries(groupNames.map(g => [g, 0]))
  for (const m of allMessages) {
    if (m.actor in actorGroups) groupCounts[actorGroups[m.actor]]++
  }
 
  // N = min(max(spacingA, spacingB), 20)
  const spacings = groupNames.map(g =>
    groupCounts[g] > 0 ? total / groupCounts[g] : total
  )
  const N = Math.round(Math.min(Math.max(...spacings), 20))
 
  // Keep only messages where the other group appears within ±N positions
  // Original array (incl. ignored actors) is the ruler — ignored messages
  // count toward position distance but are never kept
  const kept = []
  for (let i = 0; i < allMessages.length; i++) {
    const msg = allMessages[i]
    if (!msg || !(msg.actor in actorGroups)) continue
 
    const myGroup = actorGroups[msg.actor]
    const start = Math.max(0, i - N)
    const end = Math.min(allMessages.length - 1, i + N)
 
    let found = false
    for (let j = start; j <= end; j++) {
      if (j === i) continue
      const neighbor = allMessages[j]
      if (!neighbor) continue
      if (neighbor.actor in actorGroups && actorGroups[neighbor.actor] !== myGroup) {
        found = true; break
      }
    }
 
    if (found) kept.push({ ...msg, actor: actorGroups[msg.actor] })
  }
 
  return kept
}
 
const preparedMessages = prepareGroupMessages(rawMessages, actorGroups)
// Only exchanges in genuine proximity — ignored actors stripped completely

// Classify — same call as always
const { signals } = await (await fetch("https://classifier.hermionai.xyz/classify", {
  method: "POST",
  headers: { "Content-Type": "application/json", "X-Hermion-Key": passkey },
  body: JSON.stringify({ messages: preparedMessages })
})).json()
 
// Analyze — self_name is your group name
const intelligence = await (await fetch("https://api.hermionai.xyz/api/v1/analyze", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": "Bearer herm_sk_live_..."
  },
  body: JSON.stringify({
    signals,
    context_type: "professional",
    self_name: "Startup"  // whichever group name represents you
  })
})).json()

// Build display labels from original mapping — client-side only
const displayMap = {}
Object.entries(actorGroups).forEach(([speaker, group]) => {
  displayMap[speaker] = `${speaker} (${group})`
})
// { "Alex": "Alex (Startup)", ... }
// Use for your own signal trace display only — never sent to the API

{
  "actor": "Alex",
  "ts": "2025-01-01T10:00:00Z",
  "text": "I really miss you right now"
}

{
  "actor": "Alex",
  "ts": "2025-01-15T00:00:00Z",
  "is_gap": true,
  "gap_days": 14
}

{
  "actor": "Alex",
  "ts": "2025-01-01T10:00:00Z",
  "call_type": "voice",
  "call_duration_min": 22,
  "missed_call": false
}

{
  "actor": "Alex",
  "ts": "2025-01-01T10:00:00Z",
  "call_type": "voice",
  "call_duration_min": 0,
  "missed_call": true
}

{
  "signals": [
    {
      "actor": "Alex",
      "ts": "2025-01-01T10:00:00Z",
      "target": "Sam",
      "cat": "cat_a1f2",
      "evt": "evt_085010",
      "a": "u*0.923*1.0",
      "b": "min(q,s*0.923+0.15*0.077)",
      "gh": "gh_c1",
      "meta": {
        "response_latency_sec": null,
        "message_length": 27,
        "read_state": "unknown",
        "time_of_day": "morning"
      },
      "confidence": 0.923,
      "is_gap_signal": false,
      "gap_days": null,
      "call_type": null,
      "call_duration_min": null,
      "missed_call": false
    }
  ],
  "count": 3
}

{
  "mcpServers": {
    "hermion": {
      "url": "https://api.hermionai.xyz/mcp/sse",
      "headers": {
        "Authorization": "Bearer herm_sk_live_..."
      }
    }
  }
}

git clone https://github.com/hermionai/hermion-classifier-os
cd hermion-classifier-os
npm install
cp .env.example .env
npm start

PORT=3002
HERMION_INTERNAL_SECRET=   # optional — bypasses rate limits for internal use

{
  "progression_percentage": 37,
  "peak_percentage": 62,
  "momentum": "progressing",
  "interest_level": "high",
  "binding_constraint": "balanced",
  "next_move": "increase_investment",
  "other_next_move": "wait_and_test",
  "next_move_reason": "...",
  "next_move_reason_detail": "...",
  "goal_label": "Long-term relationship",
  "risk_scores": {
    "ghosting": 0.12,
    "rejection": 0.08,
    "stall": 0.31
  },
  "actor_posture": {
    "self_positive_ratio": 0.67,
    "other_positive_ratio": 0.71,
    "self_is_withdrawing": false,
    "other_is_withdrawing": false,
    "self_signal_share": 0.52,
    "total_gap_days_recent": 0.0,
    "other_next_move": "wait_and_test"
  },
  "system_diagnosis": {
    "primary_driver": "affection",
    "primary_resistance": "structural friction",
    "short_circuits": [],
    "r_decomposition": { ... }
  },
  "topology_mode": "phase_plus_quantum",
  "quantum": { ... },
  "phase_count": 4,
  "signal_count": 47,
  "gap_signal_count": 2
}