Files

138 lines
6.0 KiB
Markdown
Raw Permalink Normal View History

2026-10-26 01:31:48 +01:00
**Ja. Hierarchie is de juiste keuze**, zeker als alles native in MoloApp moet blijven en je geen externe agent-frameworks wilt.
Met de bestaande HTTP/1.1+HTTP/2 runtime, sessions, ORM, supervisor, observability, multi-tenancy en de Google/LLM-clients die je al hebt, kun je een complete agent-cluster bouwen die naar buiten toe precies één OpenAI Chat Completions endpoint is.
### Kernarchitectuur (native C++23)
```
Client
↓
POST /v1/chat/completions (en streaming)
↓
OpenAI-compat façade ← bestaande HTTP runtime
↓
Root Router / Orchestrator ← snel pad, weinig tools
↓
Domein-coördinatoren ← hiërarchie
↓
Specialist agents / tool-executors
↓
Bestaande Google-clients + LLM-vendor clients
```
Alles blijft binnen MoloApp. Geen Python, geen externe agent runtime, geen extra libraries tenzij je ze zelf schrijft.
### 1. OpenAI-compat façade
Implementeer in de bestaande routing:
- `POST /v1/chat/completions`
- `POST /v1/chat/completions` met `stream: true` (SSE)
- Optioneel: `/v1/models`, `/v1/embeddings` (doorzetten of zelf)
De façade:
1. Parseert de OpenAI payload.
2. Haalt of maakt een session (je hebt al sessions + ORM).
3. Geeft de messages + tools (indien aanwezig) door aan de Root Router.
4. Normaliseert het antwoord terug naar OpenAI-formaat (inclusief tool_calls als je die wilt exposen).
Streaming gaat via de bestaande HTTP/2 of HTTP/1.1 chunked/SSE-ondersteuning die je al hebt.
### 2. Hiërarchie van agents
Definieer een lichte basis:
```cpp
struct AgentContext {
std::string session_id;
std::vector<Message> messages;
std::unordered_map<std::string, std::string> state; // of via ORM
// multi-tenancy, audit trail, etc.
};
class Agent {
public:
virtual ~Agent() = default;
virtual std::string name() const = 0;
virtual std::string description() const = 0; // voor routing
virtual AgentResult run(AgentContext& ctx) = 0;
};
```
**Root Router** (één instance, of per-tenant):
- Ziet alleen de domein-coördinatoren.
- Doet **geen** zware tool-calls.
- Beslist welke coördinator (of combinatie) aan de beurt is.
**Domein-coördinatoren** (voorbeelden die passen bij jouw lijst):
- Voice & Live
- Agent Platform / Runtime / Sessions / Memory / Sandbox
- Google Cloud AI + Enterprise
- Data & Ops
- Maps
- Workspace
- LLM Vendors (xAI, Anthropic, Meta/Muse, …)
- Generic Discovery (de 316 APIs)
Elke coördinator heeft alleen de tools of sub-agents die bij dat domein horen. Dat houdt de keuze-ruimte klein.
**Leafs**: concrete tool-executors die de bestaande clients aanroepen (service-account, token refresh, Model Armor, etc. zit al in die clients).
### 3. Routing – efficiënt en zonder externe deps
Drie niveaus, van snel naar zwaarder:
1. **Deterministische / regel-gebaseerde router** (snelst)
Keyword, prefix, of eenvoudige feature-extractie in pure C++.
Voorbeeld: als de user “calendar”, “gmail”, “drive” zegt → Workspace.
Als er audio/WAV in zit → Voice.
Dit kan in microseconden.
2. **Embedding-gebaseerde routing** (aanbevolen hybride)
- Gebruik de embeddings-client die je al hebt (Gemini/Vertex of andere).
- Sla embeddings van de `description` van elke coördinator op (in-memory of SQLite via ORM).
- Bij elke request: embed de laatste user message (of een korte samenvatting), doe cosine similarity, pak de top-1 of top-k.
- Je kunt een eenvoudige vector store zelf bouwen op SQLite (BLOB + cosine in C++) of zelfs een flat in-memory vector. Geen aparte vector DB nodig.
3. **LLM-router** (fallback of voor complexe gevallen)
Roep een snel model (via je bestaande LLM-clients) met structured output: “kies één van deze domeinen + reden”.
Alleen gebruiken als 1 en 2 te onzeker zijn.
Je kunt ze combineren: eerst regels, dan embedding, dan pas LLM. Dat houdt de p50-latentie laag.
### 4. Tool calls en hiërarchie
- Root Router: bijna geen tools. Alleen routing-beslissing (eventueel als intern tool).
- Domein-coördinatoren en leafs: **wel** tool calls.
Zij mogen de echte Google/LLM-clients aanroepen.
- Prefer **agent-as-tool** (synchroon of async): de parent roept de child aan, krijgt resultaat terug en formuleert zelf het finale antwoord. Zo blijft de “één agent”-illusie intact.
- Handoff alleen voor langlopende stateful flows (bijv. live voice session of multi-turn Workspace wizard). In dat geval houd je de session-state bij en normaliseer je de output weer naar OpenAI-formaat.
Parallelle tool-executie kun je in de coördinator doen met de bestaande async/HTTP-client mogelijkheden of met een eenvoudige thread-pool / coroutine-achtige constructie die je al in de runtime hebt.
### 5. State, memory, sessions
- Gebruik de bestaande sessions + ORM.
- Optioneel: een eigen Memory Bank-achtige tabel (session_id, key, value, embedding, timestamp) die je zelf vult.
- Audit en governance die je al hebt, kun je direct op agent-stappen hangen (wie routeerde naar wat, welke tool, welke kosten).
### 6. Supervisor en schaalbaarheid
De bestaande supervisor kan de agent-processen of worker-threads bewaken.
Voor multi-tenancy: de Root Router is tenant-aware (via de session of een header).
Observability: log elke routing-beslissing en tool-call met de bestaande observability-laag.
### Concrete startvolgorde
1. OpenAI-compat endpoint + session-mapping.
2. Eenvoudige Root Router (regels + embedding).
3. 2–3 domein-coördinatoren (bijv. LLM Vendors, Workspace, Voice) met hun tools.
4. Agent-as-tool aanroep + response normalisatie.
5. Streaming.
6. Rest van de domeinen + Memory Bank + parallelle calls.
Alles blijft native C++23, gebruikt alleen wat je al hebt (wolfSSL, sqlite, libpq, je eigen Google/LLM-clients), en je bouwt de agent-runtime, routing, eventuele simpele vector store en tool-dispatch zelf.
Wil je dat ik een concreet C++23 skeleton geef voor de Root Router + één domein-coördinator + de OpenAI-façade (inclusief hoe je de bestaande clients eraan hangt)? Of eerst de routing-logica (regels + embedding) uitwerken?