Hermes Agent

Caller (any number)
  │
  ▼
Twilio / Telnyx DID  ──  Patter verifies the carrier signature at the public boundary
  │
  ▼
PATTER VOICE SHELL  (pipeline mode)
  · STT  — transcribes the caller
  · turn-taking / VAD / barge-in  — decides when the caller is done
  · TTS  — speaks Hermes's reply
  │
  │  each turn  →  HermesLLM  →  POST http://127.0.0.1:8642/v1/chat/completions
  ▼
HERMES AGENT RUNTIME  (tools · memory · skills run here, before it replies)
  │
  ▼
reply text  →  Patter speaks it  →  back to the caller

agent = phone.agent(
    stt=DeepgramSTT(),
    llm=HermesLLM(),
    tts=ElevenLabsTTS(),
    long_turn_message="One moment, let me check that.",
    long_turn_message_after_s=4,
)

# Python SDK
pip install getpatter

# TypeScript SDK
npm install getpatter

export API_SERVER_ENABLED=true
export API_SERVER_HOST=127.0.0.1          # loopback only — never expose to the internet
export API_SERVER_PORT=8642               # the HermesLLM default base_url targets :8642
export API_SERVER_KEY="choose-a-strong-key"
export API_SERVER_MODEL_NAME="hermes-agent"   # the model id HermesLLM sends; optional

curl -s http://127.0.0.1:8642/v1/models \
  -H "Authorization: Bearer $API_SERVER_KEY"

from getpatter import Patter, HermesLLM, DeepgramSTT, ElevenLabsTTS, Twilio

phone = Patter(
    carrier=Twilio(),                    # reads TWILIO_ACCOUNT_SID / TWILIO_AUTH_TOKEN
    phone_number="+15550001234",
)

# Passing stt + tts (and no engine=) selects pipeline mode: STT -> LLM -> TTS.
agent = phone.agent(
    system_prompt=(
        "You are the front desk. Keep replies short and speakable; "
        "you have phone callers, not chat users."
    ),
    stt=DeepgramSTT(),                   # reads DEEPGRAM_API_KEY
    llm=HermesLLM(),                     # base_url http://127.0.0.1:8642/v1, 120 s timeout
    tts=ElevenLabsTTS(),                 # reads ELEVENLABS_API_KEY
)

phone.serve(agent)                       # listens for inbound calls

llm = HermesLLM(
    base_url="http://hermes-host.internal:8642/v1",
    model="hermes-agent",
    api_key="...",          # or leave unset to read API_SERVER_KEY
    timeout=120.0,          # raise further if your turns run long
)

import { Patter, HermesLLM, DeepgramSTT, ElevenLabsTTS, Twilio } from 'getpatter';

const phone = new Patter({
  carrier: new Twilio(),                 // reads TWILIO_ACCOUNT_SID / TWILIO_AUTH_TOKEN
  phoneNumber: '+15550001234',
});

// Passing stt + tts (and no engine) selects pipeline mode: STT -> LLM -> TTS.
const agent = phone.agent({
  systemPrompt:
    'You are the front desk. Keep replies short and speakable; ' +
    'you have phone callers, not chat users.',
  stt: new DeepgramSTT(),                // reads DEEPGRAM_API_KEY
  llm: new HermesLLM(),                  // baseUrl http://127.0.0.1:8642/v1, 120 s timeout
  tts: new ElevenLabsTTS(),              // reads ELEVENLABS_API_KEY
});

await phone.serve(agent);

const llm = new HermesLLM({
  baseUrl: 'http://hermes-host.internal:8642/v1',
  model: 'hermes-agent',
  apiKey: process.env.API_SERVER_KEY,    // or omit to read it automatically
  timeout: 120,                          // seconds; raise if turns run long
});

git clone https://github.com/PatterAI/patter-mcp
cd patter-mcp
npm install
npm run build
npm start          # Streamable HTTP on http://localhost:3000/mcp

# ~/.hermes/config.yaml
mcp_servers:
  patter:
    url: "http://localhost:3000/mcp"
    # Raise the per-server timeout well above the 120s default so a long
    # wait:true call (which blocks until the call ends) is not killed.
    timeout: 600
    tools:
      include:
        - make_call
        - call_third_party
        - get_calls
        - get_transcript
        - end_call
        - get_metrics
        - configure_inbound

# ~/.hermes/config.yaml
mcp_servers:
  patter:
    command: "node"
    args:
      - "/absolute/path/to/patter-mcp/dist/index.js"
      - "--stdio"
    env:
      OPENAI_API_KEY: "${OPENAI_API_KEY}"
      ELEVENLABS_API_KEY: "${ELEVENLABS_API_KEY}"
      TWILIO_ACCOUNT_SID: "${TWILIO_ACCOUNT_SID}"
      TWILIO_AUTH_TOKEN: "${TWILIO_AUTH_TOKEN}"
    tools:
      include:
        - make_call
        - call_third_party
        - get_calls
        - get_transcript
        - end_call
        - get_metrics
        - configure_inbound

{
  "name": "make_call",
  "arguments": {
    "to": "+15550001234",
    "wait": true,
    "agent": {
      "system_prompt": "Ask whether they have an opening tomorrow morning."
    }
  }
}

export API_SERVER_ENABLED=true
export API_SERVER_KEY="choose-a-strong-key"

# consult_adapter.py — bridges Patter consult -> Hermes chat completions
import os
import httpx
from fastapi import FastAPI, Request

app = FastAPI()

HERMES_URL = os.environ["HERMES_API_URL"]          # e.g. http://hermes-host:8642
HERMES_KEY = os.environ["API_SERVER_KEY"]

@app.post("/consult")
async def consult(req: Request) -> dict:
    body = await req.json()
    user_request = body.get("request", "")

    payload = {
        "model": "hermes",
        "messages": [{"role": "user", "content": user_request}],
    }
    headers = {"Authorization": f"Bearer {HERMES_KEY}"}

    async with httpx.AsyncClient(timeout=30.0) as client:
        resp = await client.post(
            f"{HERMES_URL}/v1/chat/completions",
            json=payload,
            headers=headers,
        )
        resp.raise_for_status()
        data = resp.json()

    reply = data["choices"][0]["message"]["content"]
    return {"reply": reply}

from getpatter import Patter, ConsultConfig

phone = Patter(carrier=...)

agent = phone.agent(
    system_prompt="You are front-desk support. If you can't answer directly, "
                  "consult your back-office agent.",
    stt=...,
    tts=...,
    consult=ConsultConfig(
        url="https://consult-adapter.example.com/consult",
        headers={"Authorization": "Bearer ${ADAPTER_TOKEN}"},
        timeout_s=30.0,
    ),
)

phone.serve(agent)