Als je één AI-app wilt bouwen met GPT, Claude, Gemini, DeepSeek en Grok, gebruik dan een uniforme API voor het gemeenschappelijke aanvraagpad en houd het routeringsbeleid binnen je applicatie. CometAPI biedt een OpenAI-compatibele basis-URL en een gedeelde modelcatalogus, zodat een Python-service via één client verschillende model-ID’s kan aanroepen. Je code bepaalt nog steeds welk model draait, welke tools zijn toegestaan en wanneer een fallback veilig is.
Deze tutorial bouwt een Grok 4.7-agent die twee read-only businesstools kan aanroepen, onbekende tools en ongeldige argumenten vóór uitvoering afwijst, en alleen na geselecteerde, tijdelijke storingen overschakelt naar een ander, via contracttests gevalideerd model. Het doel is geen magisch autonoom systeem. Het is een kleine, inspecteerbare lus die getest en in productie bediend kan worden.
Wat je gaat bouwen
De agent heeft vijf expliciete onderdelen:
- Eén CometAPI-client. De OpenAI Python SDK gebruikt de CometAPI API-basis-URL zoals hieronder ingesteld.
- Grok 4.7 als het primaire model. De huidige CometAPI-model-ID is
grok-4.7. - Een toolregister. Het model kan een functiaanroep voorstellen, maar alleen applicatiecode mag een toegestane functie uitvoeren.
- Een begrensde agentloop. De lus stopt na een vast aantal modelbeurten in plaats van eindeloos door te lopen.
- Een geordend fallbackbeleid. Compatibele GPT-, Claude-, Gemini- of DeepSeek-model-ID’s worden pas geprobeerd na een herhaalbare model-/API-fout.
Grok 4.7 ondersteunt function calling, en CometAPI documenteert momenteel zowel de routes /v1/chat/completions als /v1/responses voor het model. Deze tutorial gebruikt Chat Completions omdat de OpenAI-compatibele tools, toolaanroepen door de assistant, en bijpassende tool-resultaatberichten direct mappen naar een compacte, inspecteerbare Python-lus. Transportcompatibiliteit bewijst geen feature-pariteit over elk model, dus elke geconfigureerde fallback moet dezelfde contracttests doorstaan voordat deze in productie gaat.
Redeneerstatus in Grok 4.7-agents met meerdere beurten
Grok 4.7 accepteert low, medium, high of xhigh reasoning effort, met high als standaard. Op de Responses API van xAI bevat elk Grok 4.7-antwoord reasoning.encrypted_content; een door de client beheerde meerbeurtlus moet de geretourneerde reasoning-items ongewijzigd doorgeven in het volgende verzoek. Lange lussen kunnen ook gebruikmaken van context compaction: bewaar het geretourneerde compaction-item als ondoorzichtige staat en voeg nieuwe beurten erna toe. Omdat dit staatvolle, providerspecifieke responsevelden zijn, verifieer dat de geselecteerde CometAPI-route ze end-to-end retourneert voordat je er in productie van afhankelijk wordt.
Agentarchitectuur: het model stelt voor, jouw app beslist
Een veilige tool-aanroepflow is eenvoudig:
User request → model response → validate tool call → execute allowlisted tool → append tool result → model response
Het model ontvangt nooit database-inloggegevens en voert nooit direct Python uit. Het produceert een gestructureerd verzoek zoals “call get_order_status with this order ID.” Je applicatie controleert de toolnaam, parseert de argumenten, past autorisatie en bedrijfsregels toe, voert de functie uit en retourneert een geserialiseerd resultaat.
Deze scheiding is belangrijker dan de modelkeuze. Een fallbackmodel moet dezelfde toolgrenzen erven—niet een bredere—en toolresultaten moeten als onbetrouwbare data worden behandeld wanneer ze externe content bevatten.
Zo bouw je een Grok 4.7-AI-agent met Python
Stap 1: Configureer de OpenAI Python SDK voor CometAPI
Installeer de OpenAI SDK:
pip install openai
Stel de configuratie in via omgevingsvariabelen:
export COMETAPI_KEY="your-cometapi-key"
export PRIMARY_MODEL="grok-4.7"
export FALLBACK_MODEL_1="your-compatible-gpt-model-id"
export FALLBACK_MODEL_2="your-compatible-claude-model-id"
export FALLBACK_MODEL_3="your-compatible-gemini-model-id"
export FALLBACK_MODEL_4="your-compatible-deepseek-model-id"
Deze tutorial gebruikt Chat Completions omdat expliciete toolaanroepen door de assistant en bijpassende toolresultaatberichten de controleflow eenvoudig maken om te inspecteren in een compact Python-voorbeeld. Voor langere, staatvolle lussen kun je de Responses API evalueren zoals hierboven beschreven. Kopieer bovendien geen oude model-ID’s uit een blogpost naar productie: haal tijdens deployment of bij het opstarten CometAPI’s publieke GET /api/models-catalogus op en bevestig vervolgens de mogelijkheden en prijsstelling in de model directory.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
max_retries=0,
timeout=30.0,
)
De expliciete timeout en uitgeschakelde SDK-retry zijn bewust. De applicatie classificeert fouten en besluit of het verzoek moet worden herhaald of dat moet worden overgeschakeld naar het volgende model. Verborgen retries maken latentie, gedupliceerde bijwerkingen en fallbackgedrag lastiger te begrijpen.
Stap 2: Definieer eerst beperkte, alleen-lezen tools
Begin met tools die data lezen in plaats van wijzigen. De volgende definities laten de agent een bestelling controleren en voorraad opzoeken. De implementatie retourneert demodata; vervang dit door geauthenticeerde aanroepen naar je eigen services.
import json
TOOLS = [
{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Read the current status of one order.",
"parameters": {
"type": "object",
"properties": {
"order_id": {"type": "string"}
},
"required": ["order_id"],
"additionalProperties": False,
},
},
},
{
"type": "function",
"function": {
"name": "check_inventory",
"description": "Read available inventory for one SKU.",
"parameters": {
"type": "object",
"properties": {
"sku": {"type": "string"}
},
"required": ["sku"],
"additionalProperties": False,
},
},
},
]
def get_order_status(order_id: str) -> dict:
# Replace this demo with an authenticated, read-only service call.
return {"order_id": order_id, "status": "in_transit"}
def check_inventory(sku: str) -> dict:
# Replace this demo with an authenticated, read-only service call.
return {"sku": sku, "available_units": 12}
TOOL_REGISTRY = {
"get_order_status": get_order_status,
"check_inventory": check_inventory,
}
Een JSON-schema verbetert de vorm van het verzoek, maar is geen autorisatie. Valideer argumentlengtes en -formaten, bevestig dat de huidige gebruiker toegang heeft tot de gevraagde order of SKU, en beperk de grootte van elk toolresultaat voordat je het aan het model teruggeeft.
Stap 3: Voeg een beperkt multi-model fallbackbeleid toe
Fallback moet herstellen van tijdelijke routeringsfouten, niet kapotte verzoeken verbergen. De officiële fallbackgids van CometAPI raadt aan om naar de volgende geconfigureerde route te gaan bij verbindingsfouten, timeouts, HTTP 408, HTTP 429 en tijdelijke 5xx-responses. Ongeldige inloggegevens, niet-ondersteunde parameters en ongeldige verzoeken moeten direct falen.
from openai import APIConnectionError, APIStatusError, APITimeoutError
def configured_models() -> list[str]:
names = [
os.getenv("PRIMARY_MODEL", "grok-4.7"),
os.getenv("FALLBACK_MODEL_1"),
os.getenv("FALLBACK_MODEL_2"),
os.getenv("FALLBACK_MODEL_3"),
os.getenv("FALLBACK_MODEL_4"),
]
return [name for name in names if name]
def is_retryable(error: Exception) -> bool:
if isinstance(error, (APIConnectionError, APITimeoutError)):
return True
if isinstance(error, APIStatusError):
return error.status_code in {408, 429} or error.status_code >= 500
return False
def complete_with_fallback(messages: list[dict], tools: list[dict]):
models = configured_models()
last_error = None
for index, model in enumerate(models):
try:
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
tool_choice="auto",
)
return response, model
except Exception as error:
last_error = error
final_route = index == len(models) - 1
if final_route or not is_retryable(error):
raise
raise RuntimeError("No configured model completed the request") from last_error
De modellenlijst is configuratie, geen kwaliteitsrangschikking. Kies fallbacks die dezelfde berichtrollen, toolschema, inputmodaliteit, contextvereisten en responsegedrag ondersteunen die deze agent nodig heeft. Log de geselecteerde route en de fout die elke overgang veroorzaakte.
Stap 4: Voer de begrensde Grok 4.7-agentloop uit
De onderstaande lus stuurt het gesprek, voert eventuele toegestane toolaanroepen uit, voegt resultaten toe met de bijbehorende tool_call_id, en vraagt het geselecteerde model om het antwoord af te maken.
def execute_tool_call(tool_call) -> str:
name = tool_call.function.name
if name not in TOOL_REGISTRY:
return json.dumps({"error": f"Tool not allowed: {name}"})
try:
arguments = json.loads(tool_call.function.arguments)
result = TOOL_REGISTRY[name](**arguments)
return json.dumps(result)
except (json.JSONDecodeError, TypeError, ValueError) as error:
return json.dumps({"error": f"Invalid tool arguments: {error}"})
def run_agent(user_text: str, max_turns: int = 4) -> dict:
messages = [
{
"role": "system",
"content": (
"You are a support agent. Use tools only when needed. "
"Never invent order or inventory data."
),
},
{"role": "user", "content": user_text},
]
route_log = []
for turn in range(max_turns):
response, model = complete_with_fallback(messages, TOOLS)
route_log.append({"turn": turn + 1, "model": model})
assistant = response.choices[0].message
messages.append(assistant.model_dump(exclude_none=True))
if not assistant.tool_calls:
return {
"answer": assistant.content,
"routes": route_log,
"usage": response.usage.model_dump() if response.usage else None,
}
for tool_call in assistant.tool_calls:
messages.append(
{
"role": "tool",
"tool_call_id": tool_call.id,
"content": execute_tool_call(tool_call),
}
)
raise RuntimeError("Agent stopped after reaching max_turns")
result = run_agent("Where is order A-104, and is SKU BLUE-42 in stock?")
print(result["answer"])
print(result["routes"])
De code ondersteunt meerdere toolaanroepen in één modelrespons omdat voor elke geretourneerde aanroep een resultaat wordt toegevoegd. Als een tool toestand wijzigt—een e-mail verzenden, een bestelling plaatsen of een terugbetaling doen—voeg dan een idempotentiesleutel en een menselijke bevestigingsstap toe. Start nooit blind de volledige agentbeurt opnieuw na een timeout als een bijwerking mogelijk al heeft plaatsgevonden.
Hoe GPT, Claude, Gemini en DeepSeek in dezelfde app passen
CometAPI kan duplicatie op de connectielaag verminderen: één account, één OpenAI-compatibele basis-URL voor het gemeenschappelijke pad, en een model-ID die door applicatiecode wordt gekozen. Dat maakt GPT, Claude, Gemini, DeepSeek en Grok kandidaten achter één interne interface.
Het maakt de modellen niet uitwisselbaar. Controleer vóór het toevoegen van een fallback:
- of de huidige model-ID door de CometAPI-catalogus wordt geretourneerd;
- of de route het vereiste toolschema en de vereiste berichtrollen ondersteunt;
- of toolaanroepargumenten en gedrag bij meerdere aanroepen overeenkomen met het agentcontract;
- of het contextvenster en de inputmodaliteiten bij het verzoek passen;
- of de response kan worden gevalideerd voordat deze de gebruiker bereikt;
- of latentie en kosten binnen het productbudget blijven.
Provider-native features kunnen een native endpoint of een aparte adapter vereisen. Houd die uitzonderingen expliciet in plaats van elke mogelijkheid door de gemeenschappelijke interface te forceren.
Grok 4.7 multi-model fallback is niet hetzelfde als multi-agent
Een multi-model-fallbackketen kiest een ander model wanneer een route faalt. Een multi-agent-systeem wijst verschillende verantwoordelijkheden toe aan afzonderlijke agents—bijvoorbeeld een planner, een onderzoeker en een reviewer. De twee patronen lossen verschillende problemen op.
Als je deze Grok 4.7-agent uitbreidt naar een multi-agent-workflow, geef elke werker dan een smalle rol, een aparte tool-allowlist, een begrensd budget en een gestructureerde overdracht. Laat niet elke agent elke tool aanroepen of een onbeperkt transcript doorsturen. Begin met één agent totdat evaluatiedata bewijst dat rolopsplitsing het resultaat verbetert.
Randvoorwaarden voor productie van een Grok 4.7-AI-agent
Valideer vóór tooluitvoering
Controleer toolnamen, argumentschema’s, tenant-eigenaarschap, gebruikersrechten en ratelimieten in applicatiecode. Behandel toolbeschrijvingen als richtlijnen voor het model, niet als een beveiligingscontrole.
Scheid leestools van schrijftools
Alleen-lezen tools kunnen vaak automatisch draaien na autorisatie. Schrijftools moeten strengere controles, idempotentie en bevestiging vereisen voor ingrijpende acties.
Begrens elke loop
Stel maxima in voor modelbeurten, toolaanroepen, wandkloktijd, promptgrootte en tokenbudget. Retourneer een gecontroleerde fout of escalatiepad wanneer een grens is bereikt.
Leg het beslissingsspoor vast
Log de gevraagde taak, beleidsversie, geselecteerde model-ID, reden voor fallback, toolnaam, toollatentie, validatieresultaat, tokengebruik en eindstatus. Log geen geheimen of onnodige klantinhoud.
Gebruik contracttests, geen aannames
Draai dezelfde fixtures tegen elk geconfigureerd model. Een nuttige minimale suite dekt een normaal antwoord, één toolaanroep, meerdere toolaanroepen, ongeldige argumenten, een onbekende tool, een tool-timeout, een 429 van het primair model en een ongeldige API-sleutel die geen fallback mag triggeren.
Een checklist voor uitrol
- Haal actuele model-ID’s op en verifieer de Grok 4.7-route vóór deployment.
- Bewaar de CometAPI-sleutel in een secret manager, nooit in broncode of prompts.
- Begin met alleen-lezen tools en expliciete JSON-schema’s.
- Pas authenticatie en tenantautorisatie toe vóór elke toolaanroep.
- Sta fallback alleen toe voor geclassificeerde tijdelijke fouten.
- Test elke fallback tegen hetzelfde tool-aanroepcontract.
- Voeg idempotentie en bevestiging toe voordat je schrijftools inschakelt.
- Stel limieten in voor lussen, latentie, context en kosten.
- Meet taaksucces, niet alleen API-beschikbaarheid.
Waarom deze agent via CometAPI bouwen?
CometAPI is hier nuttig omdat de gemeenschappelijke integratie klein blijft. De OpenAI Python SDK wijst naar één basis-URL, Grok 4.7 wordt geselecteerd via model-ID, en compatibele modellen van andere providers kunnen achter hetzelfde, door de applicatie beheerde routebeleid worden geplaatst.
Dat geeft een team ruimte om GPT, Claude, Gemini en DeepSeek te evalueren zonder providerspecifieke connectiecode door het product te verspreiden. Het bewaart ook een belangrijke grens: CometAPI levert toegang, terwijl jouw applicatie capaciteitscontroles, toolexecutie, fallbackbeleid, evaluatie en gebruikersgerichte werking beheert.
Bekijk de actuele Grok 4.7-modelpagina, configureer de client via de CometAPI quickstart, en haal actuele model-ID’s op vóór je productiefallbacks kiest.
Veelgestelde vragen
Welke API moet ik gebruiken voor een app met GPT, Claude, Gemini en DeepSeek?
Voor het gemeenschappelijke chat- en tool-aanroeppad kan een OpenAI-compatibele, uniforme API zoals CometAPI het integratiewerk verminderen. Houd modelselectie en fallbackbeleid in je applicatie, en gebruik providerspecifieke adapters wanneer een vereiste feature niet in het gedeelde contract past.
Kan Grok 4.7 direct Python-functies aanroepen?
Grok 4.7 kan gestructureerde verzoeken voor functiaanroepen retourneren. Je Python-applicatie parseert het verzoek, valideert het, voert een toegestane functie uit en stuurt het resultaat terug naar het model. Het model zelf voert geen lokale Python uit.
Moet elke fout een ander model activeren?
Nee. Gebruik fallback voor geselecteerde verbindingsfouten, timeouts, 408, 429 en tijdelijke 5xx-responses. Ongeldige verzoeken, authenticatiefouten en niet-ondersteunde parameters moeten worden opgelost in plaats van naar een ander model te sturen.
Kan ik één toolschema voor elk model gebruiken?
Pas na testen. Een gedeeld transport garandeert geen identiek toolgedrag, argumentkwaliteit, parallelle-aanroepgedrag of schemahandhaving. Voeg een model pas toe aan de keten nadat het de contracttests van de agent heeft doorstaan.
Is een multi-model-fallbacksysteem een multi-agent-systeem?
Nee. Fallback wijzigt het model dat voor een verzoek wordt gebruikt na een routefout. Multi-agent-architectuur wijst verschillende taken toe aan afzonderlijke agents. Bouw ze als afzonderlijke lagen met aparte tests en controles.