Files
moloapp/plan2.md
T
2026-10-26 01:31:48 +01:00

138 lines
6.0 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
**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?