Ask Titan gebruikt een top-level LangGraph-runtime om uit toegestane specialistische AI-agents te kiezen. MCP biedt de toolinterface. SQL, Power BI/DAX en documentretrieval blijven binnen de agents die deze bronnen begrijpen.
Het engineeringprobleem
AI-vraag
Top-level orchestrator
Werk met het actieve gesprek, bekijk de toegestane capabilities, selecteer indien nodig een tool en bepaal wanneer de beurt klaar is.
Specialistische AI-agent
Inspecteer bronmetadata, genereer en voer de benodigde operatie uit, verwerk bronspecifieke fouten en retourneer een begrensd resultaat.
Applicatieruntime
Los capability-toegang op, bewaar conversatiestatus, handhaaf runtimelimieten en behoud uitvoeringsbewijs buiten het model.
Eén turn door de runtime
De top-level graph heeft een klein control surface. Hij ontvangt de actieve conversatiecontext en de tools die voor die request zijn toegestaan. Als specialistische uitvoering nodig is, loopt de request via de MCP-capabilityinterface naar de geselecteerde specialistische agent. Het executionresultaat keert via MCP terug naar LangGraph, dat de agent-tool-loop voortzet of het eindantwoord voor de gebruiker produceert.
Stap 1 · bepaal de toolset
De MCP-client kan een grotere capabilitycatalogus ontdekken dan de huidige request zou moeten ontvangen. Ask Titan bepaalt de toegestane toolset in applicatiecode en bindt alleen die tools aan het orchestrator-model.
Laad de huidige toolcatalogus die door de MCP-capabilityservice beschikbaar wordt gesteld.
Bepaal welke tools zijn toegestaan voor de huidige identity en runtimecontext.
Het model ontvangt schema's voor de toegestane set in plaats van de volledige capabilitycatalogus.
available_tools = await discover_mcp_tools()
allowed_names = await resolve_allowed_tools(user_id)
permitted_tools = [
tool
for tool in available_tools
if tool.name in allowed_names
]
agent = build_orchestrator(
tools=permitted_tools,
checkpointer=conversation_memory,
)Dit is capability-autorisatie op applicatieniveau. Het vervangt geen rechten in Databricks, SQL Server, Power BI of enige andere gekoppelde bron.
Stap 2 · draai de LangGraph-loop
Ask Titan gebruikt een ReAct-achtige LangGraph-loop. De agent-node roept het model aan met de actieve context en toegestane tools. Als het model een tool call uitstoot, routeert de graph de uitvoering naar de tool-node. Het resultaat wordt toegevoegd aan de graph-state en de control gaat terug naar de agent. Als het model geen tool call uitstoot, kan de graph de turn beëindigen met de modelrespons.
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", ToolNode(permitted_tools))
graph.add_conditional_edges(
"agent",
route_next_step,
{
"tools": "tools",
"end": END,
},
)
graph.add_edge("tools", "agent")
graph = graph.compile(
checkpointer=conversation_memory,
)Stap 3 · specialistische uitvoering
De top-level orchestrator ziet een capability als een tool met naam, beschrijving en inputschema. Achter die interface kan de implementatie een deterministische functie of een bronspecifieke agentgraph zijn. Ask Titan gebruikt specialistische agents wanneer uitvoering meerdere bronspecifieke stappen vereist.
Gestructureerde data
Werkt binnen de toegestane databron-grens en schemametadata, genereert SQL, voert de query uit en kan uitvoeringsfeedback gebruiken om de operatie te verfijnen.
Semantische data
Werkt met metadata, measures en relaties uit het semantische model en genereert en voert vervolgens DAX uit tegen het governed businessmodel.
Ongestructureerde data
Herschrijft de actieve vraag voor retrieval, haalt relevante documentchunks op en genereert een antwoord uit de resulterende broncontext.
Capabilitygrens
De orchestrator hoeft niet te weten hoe Databricks execution metadata blootstelt, hoe een Power BI semantic model measures representeert of hoe documentretrieval is geïmplementeerd. Hij heeft alleen genoeg informatie nodig om de toegestane capability te kiezen en met het teruggegeven resultaat te werken.
@mcp_tool(
name="semantic_model_agent",
description="Answer questions using the governed semantic model",
)
async def semantic_model_agent(question: str):
metadata = await inspect_model()
dax = await generate_dax(question, metadata)
result = await execute_dax(dax)
if result.has_error:
result = await refine_and_retry(
question,
metadata,
result,
)
return bounded_tool_result(result)Stap 4 · state en modelcontext
De graph gebruikt een checkpointer zodat threadstate over turns kan blijven bestaan. Dat betekent niet dat ieder opgeslagen bericht en historisch toolresultaat bij iedere pass terug naar het model moet worden gestuurd. Ask Titan houdt persistence en model-context-shaping als aparte concerns.
Opgeslagen threadstate
Thread-scoped checkpoints bewaren graphstate buiten de modelprompt. Dit behoudt conversatiecontinuïteit en geeft de runtime een duurzame state van waaruit volgende turns kunnen doorgaan.
Actieve LLM-context
Afgeronde turns kunnen worden samengevouwen tot het gebruikersbericht en definitieve antwoord, terwijl de actieve turn de tool-call-sequence behoudt die nodig is voor uitvoering. Te grote toolresultaten kunnen compact in modelcontext worden weergegeven terwijl het volledige resultaat buiten de prompt blijft.
prefix, active_turn = split_at_latest_user_message(state.messages)
finished_turns = collapse_completed_turns(prefix)
recent_history = keep_recent_turns(finished_turns)
llm_context = [
*recent_history,
*active_turn,
]
llm_context = cap_oversized_tool_results(llm_context)De rol van MCP
Ask Titan gebruikt MCP zodat de orchestrator specialistische capabilities via een consistente toolinterface kan ontdekken en aanroepen. De orchestration-graph, conversation-state, application policy, bronpermissions en specialistimplementatie blijven afzonderlijke verantwoordelijkheden.
Interfacegrens: MCP definieert hoe capabilities aan de orchestrator worden aangeboden. Het beslist niet welke capabilities een gebruiker mag gebruiken, hoe een specialist zijn werk uitvoert of wat de onderliggende databron toestaat.
Verdeling van verantwoordelijkheden
State, nodes, conditional routing, toolloops en checkpointintegratie.
Capability-discovery, toolschema's en invocatie over de interfacegrens.
Bepaalt welke ontdekte capabilities voor het huidige request aan de orchestrator mogen worden gebonden.
Credentials, rollen en bronautorisatie, inclusief RLS of CLS waar ondersteund.
Runtimegrenzen
Agentloops hebben expliciet gedrag nodig voor fouten en beëindiging. Ask Titan behandelt dit als runtimeverantwoordelijkheid in plaats van erop te vertrouwen dat het model of een prompt zijn eigen uitvoering bewaakt.
| Runtimecase | Runtimegedrag |
|---|---|
| Model emit geen tool-call | Beëindig de graph-turn met de modelrespons en sla de resulterende conversatiestate op. |
| Model emit een toegestane tool-call | Routeer naar de tool-node, voer de geselecteerde capability uit en geef het resultaat terug aan de agent voor de volgende modelpass. |
| Specialistische uitvoering faalt | Houd bronspecifieke foutinterpretatie en correctie binnen de specialist-flow, waar relevante bronmetadata en execution context beschikbaar zijn. |
| Tooloutput is te groot voor bruikbare modelcontext | Houd het volledige resultaat buiten de prompt en geef een begrensde representatie door aan de volgende model-call. |
| Het model blijft toolcalls uitsturen | Pas deterministische runtimelimieten toe zodat de loop niet afhankelijk is van het model dat uiteindelijk zelf besluit te stoppen. |
Grenzen die gescheiden blijven
Een ontdekte MCP-tool is niet automatisch beschikbaar voor de huidige gebruiker of aanvraag.
Het binden van een tool vervangt geen credentials, rollen of permissions die door de onderliggende databron worden afgedwongen.
Een thread opslaan betekent niet dat de volledige historie in iedere model-call moet worden afgespeeld.
AI-vaardigheden
Engineeringconclusie
De top-level Ask Titan-graph blijft eenvoudiger uitbreidbaar wanneer hij niet iedere databronimplementatie absorbeert. Nieuw bronspecifiek gedrag kan achter een specialistische capability boundary blijven terwijl de orchestrationstructuur grotendeels gelijk blijft.
Patronen die we behouden
Volgende in de serie
Het volgende artikel gaat dieper in op de autorisatieboundary die hier is geïntroduceerd: identity, applicatiebeleid, capability filtering, tool binding en source-level permissies. Het legt ook uit waarom het ontdekken van een MCP-capability niet hetzelfde is als een gebruiker autoriseren om die aan te roepen.
Lees deel 3FAQ
Praktische antwoorden over Ask Titan's top-level orchestrator, MCP capability discovery, specialist-agents, graph state en modelcontext.
LangGraph voert de top-level stateful agent-and-tool-loop uit. De orchestrator ontvangt de huidige conversatiecontext en de toegestane toolset, beslist of hij antwoordt of een tool aanroept, ontvangt toolresultaten en gaat door totdat de turn is afgerond.
MCP biedt een consistente interface voor het ontdekken en aanroepen van specialistische capabilities. Ask Titan kan SQL-, Power BI- en documentagents via dezelfde toolgrens aanbieden zonder hun bronspecifieke implementatielogica in de top-level orchestrator te embedden.
Nee. Ask Titan bepaalt application-level tool access voordat tools aan de orchestrator worden gebonden. MCP levert de capability-interface; gebruikersautorisatie en datasourcepermissions zijn afzonderlijke controls.
Nee. De orchestrator selecteert een toegestane specialistische capability. De SQL-agent beheert structured-data-executie, de Power BI-agent semantic-model- en DAX-executie en de documentagent retrieval en source-grounded answering.
Het resultaat keert terug naar de LangGraph-runtime als toolresultaat. Het top-level model kan dat resultaat gebruiken om te antwoorden, indien nodig een andere toegestane tool aanroepen of de turn afronden.
Ask Titan compileert de graph met thread-scoped checkpointpersistentie. De opgeslagen graph-state biedt continuïteit van gesprekken over meerdere turns, terwijl de modelcontext voor iedere call los van die opgeslagen state wordt opgebouwd.
Nee. Oudere afgeronde turns kunnen worden teruggebracht tot gebruikersbericht en definitief antwoord, terwijl de actieve turn de tool-calls en toolresultaten behoudt die voor correcte executie nodig zijn. Oversized toolresultaten kunnen ook compacter in modelcontext worden weergegeven.
De expliciete graph scheidt modelplanning, tooluitvoering, persisted state en stopcondities. Bronspecifiek gedrag blijft binnen specialistische agents in plaats van zich op te hopen in één top-level prompt en één connectorlaag.
Nee. Het orchestratieontwerp is afhankelijk van een capability-interface voor tool discovery en invocation. Transport- en protocol-lifecycledetails kunnen onafhankelijk evolueren, wat belangrijk is omdat MCP substantieel is veranderd tussen specificatierevisies.
Agentorchestratie
Ask Titan scheidt top-level routing van bronspecifieke uitvoering. Hetzelfde patroon kan worden gebruikt voor maatwerk enterprise-AI-systemen die meerdere beheerde tools, persistente state en expliciete applicatiecontrols nodig hebben.
Eén turn, vier grenzen
Technische runtimestate en tijdelijke writes die worden gebruikt om de thread voort te zetten.
De voorbeelden in dit artikel zijn vereenvoudigde architectuurpatronen. Deze publieke referenties documenteren de LangGraph- en MCP-concepten die in het ontwerp worden gebruikt.