Hvis du vil bygge én AI-app med GPT, Claude, Gemini, DeepSeek og Grok, så brug en samlet API til den fælles anmodningsvej og hold routingpolitikken inde i din applikation. CometAPI leverer en OpenAI-kompatibel base-URL og et delt modelkatalog, så en Python-tjeneste kan kalde forskellige model-id’er gennem én klient. Din kode beslutter stadig, hvilken model der kører, hvilke værktøjer der er tilladt, og hvornår et fallback er sikkert.
Denne vejledning bygger en Grok 4.7-agent, der kan anmode to læse-only forretningsværktøjer, afviser ukendte værktøjer og fejlformede argumenter før kørsel, og skifter til en anden kontrakt-testet model kun efter udvalgte midlertidige fejl. Målet er ikke et magisk autonomt system. Det er en lille, inspicerbar løkke, som kan testes og driftes i produktion.
Hvad du bygger
Agenten har fem eksplicitte dele:
- Ét CometAPI-klient. OpenAI Python SDK bruger CometAPI’s API-base-URL vist i opsætningen nedenfor.
- Grok 4.7 som primær model. Det nuværende CometAPI model-id er
grok-4.7. - Et værktøjsregister. Modellen kan foreslå et funktionskald, men kun applikationskoden kan udføre en funktion på allowlisten.
- En begrænset agentløkke. Løkken stopper efter et fast antal model-svar i stedet for at køre på ubestemt tid.
- En ordnet fallback-politik. Kompatible GPT-, Claude-, Gemini- eller DeepSeek-model-id’er forsøges kun efter en genprøvbar model-/API-fejl.
Grok 4.7 understøtter funktionskald, og CometAPI dokumenterer i øjeblikket både ruterne /v1/chat/completions og /v1/responses for modellen. Denne vejledning bruger Chat Completions, fordi dens OpenAI-kompatible tools, assistentens værktøjsopkald og matchende tool-resultatmeddelelser kortlægges direkte til en kompakt, inspicerbar Python-løkke. Transportkompatibilitet beviser ikke funktionsparitet på tværs af alle modeller, så hver konfigureret fallback skal bestå de samme kontrakttests, før den går i produktion.
Ræsonneringstilstand i flerturns Grok 4.7-agenter
Grok 4.7 accepterer low, medium, high eller xhigh ræsonneringsindsats, hvor high er standard. På xAI’s Responses API inkluderer hvert Grok 4.7-svar reasoning.encrypted_content; en klientstyret flerturnsløkke bør sende de returnerede ræsonneringsposter tilbage uændret i den næste anmodning. Lange løkker kan også bruge context compaction: bevar den returnerede komprimeringspost som ugennemsigtig tilstand og tilføj nye ture efter den. Da dette er tilstandsfulde, leverandørspecifikke responsfelter, skal du bekræfte, at den valgte CometAPI-rute returnerer dem fra ende til anden, før du gør dem til en produktionsafhængighed.
Agentarkitektur: Modellen foreslår, din app beslutter
Et sikkert flow for værktøjskald er enkelt:
Brugeranmodning → modelsvar → valider værktøjskald → udfør tilladt værktøj → tilføj værktøjsresultat → modelsvar
Modellen modtager aldrig databaselegitimationsoplysninger og kører ikke Python direkte. Den producerer en struktureret anmodning såsom “kald get_order_status med dette ordre-id.” Din applikation tjekker værktøjsnavnet, parser argumenterne, anvender autorisation og forretningsregler, kører funktionen og returnerer et serialiseret resultat.
Denne adskillelse betyder mere end modelvalget. En fallback-model skal arve den samme værktøjsgrænse—ikke en bredere—og værktøjsresultater skal behandles som utroværdige data, når de indeholder eksternt indhold.
Sådan bygger du en Grok 4.7 AI-agent med Python
Trin 1: Konfigurer OpenAI Python SDK til CometAPI
Installer OpenAI SDK:
pip install openai
Sæt konfiguration via miljøvariabler:
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"
Denne vejledning bruger Chat Completions, fordi dens eksplicitte assistentværktøjsopkald og matchende værktøjsresultatmeddelelser gør kontrolflowet let at inspicere i et kompakt Python-eksempel. For længere tilstandsfulde løkker kan du evaluere Responses API som beskrevet ovenfor. Kopiér heller ikke gamle model-id’er fra et blogindlæg ind i produktion: hent CometAPI’s offentlige GET /api/models-katalog under deployment eller opstart, og bekræft derefter kapabiliteter og priser i modelkataloget.
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,
)
Den eksplicitte timeout og deaktiverede SDK-retry er bevidste valg. Applikationen vil klassificere fejl og beslutte, om anmodningen skal gentages, eller om der skal skiftes til den næste model. Skjulte retries gør latenstid, duplikerede bivirkninger og fallback-adfærd sværere at forstå.
Trin 2: Definér smalle, læse-only værktøjer først
Start med værktøjer, der læser data i stedet for at ændre dem. Følgende definitioner lader agenten tjekke en ordre og slå lager op. Implementeringen returnerer demo-data; erstat den med autentificerede kald til dine egne tjenester.
import json
TOOLS = [
{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Læs den nuværende status for én ordre.",
"parameters": {
"type": "object",
"properties": {
"order_id": {"type": "string"}
},
"required": ["order_id"],
"additionalProperties": False,
},
},
},
{
"type": "function",
"function": {
"name": "check_inventory",
"description": "Læs tilgængeligt lager for én SKU.",
"parameters": {
"type": "object",
"properties": {
"sku": {"type": "string"}
},
"required": ["sku"],
"additionalProperties": False,
},
},
},
]
def get_order_status(order_id: str) -> dict:
# Erstat denne demo med et autentificeret, læse-only tjenestekald.
return {"order_id": order_id, "status": "in_transit"}
def check_inventory(sku: str) -> dict:
# Erstat denne demo med et autentificeret, læse-only tjenestekald.
return {"sku": sku, "available_units": 12}
TOOL_REGISTRY = {
"get_order_status": get_order_status,
"check_inventory": check_inventory,
}
Et JSON-skema forbedrer formen på anmodningen, men det er ikke autorisation. Valider argumentlængder og -formater, bekræft at den aktuelle bruger må få adgang til den ønskede ordre eller SKU, og begræns størrelsen af hvert værktøjsresultat, før du returnerer det til modellen.
Trin 3: Tilføj en smal multimodel fallback-politik
Fallback skal gendanne fra midlertidig route-fejl, ikke skjule defekte anmodninger. CometAPI’s officielle fallback-guide anbefaler at gå videre til den næste konfigurerede rute ved forbindelsesfejl, timeouts, HTTP 408, HTTP 429 og midlertidige 5xx-svar. Ugyldige legitimationsoplysninger, ikke-understøttede parametre og ugyldige anmodninger skal fejle øjeblikkeligt.
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
Modellisten er konfiguration, ikke en kvalitetsrangering. Vælg fallbacks, der understøtter den samme meddelelsesrolle, værktøjsskema, inputmodalitet, kontekstkrav og responsadfærd, som denne agent har brug for. Log den valgte rute og fejlen, der forårsagede hver overgang.
Trin 4: Kør den begrænsede Grok 4.7-agentløkke
Løkken nedenfor sender samtalen, udfører alle værktøjsopkald på allowlisten, tilføjer resultater med matchende tool_call_id, og beder den valgte model færdiggøre svaret.
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": (
"Du er en supportagent. Brug værktøjer kun når det er nødvendigt. "
"Find aldrig på ordre- eller lagerdata."
),
},
{"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"])
Koden understøtter flere værktøjsopkald i ét modelsvar, fordi den tilføjer et resultat for hvert returneret kald. Hvis et værktøj ændrer tilstand—sender en e-mail, afgiver en ordre eller udsteder en refusion—tilføj en idempotensnøgle og et menneskeligt bekræftelsestrin. Genstart aldrig hele agentturen blindt efter en timeout, hvis en bivirkning allerede kan være sket.
Hvordan GPT, Claude, Gemini og DeepSeek passer i den samme app
CometAPI kan reducere duplikation i forbindelseslaget: én konto, én OpenAI-kompatibel base-URL for den fælles vej, og et model-id valgt af applikationskoden. Det gør GPT, Claude, Gemini, DeepSeek og Grok til kandidater bag én intern grænseflade.
Det gør ikke modellerne udskiftelige. Før du tilføjer en fallback, skal du bekræfte:
- at det aktuelle model-id returneres af CometAPI-kataloget;
- at ruten understøtter det nødvendige værktøjsskema og de nødvendige meddelelsesroller;
- at værktøjskaldsargumenter og adfærd for flere samtidige kald matcher agentens kontrakt;
- at kontekstvinduet og inputmodaliteterne passer til anmodningen;
- at svaret kan valideres, før det når brugeren;
- at latenstid og omkostning holder sig inden for produktbudgettet.
Leverandørnative funktioner kan kræve et native endpoint eller en separat adapter. Hold disse undtagelser eksplicitte i stedet for at tvinge enhver kapabilitet gennem den fælles grænseflade.
Grok 4.7 multimodel-fallback er ikke det samme som multi-agent
En multimodel-fallbackkæde vælger en anden model, når en rute fejler. Et multi-agent-system tildeler forskellige ansvarsområder til separate agenter—f.eks. en planlægger, en researcher og en reviewer. De to mønstre løser forskellige problemer.
Hvis du udvider denne Grok 4.7-agent til et multi-agent-arbejdsflow, så giv hver arbejder en smal rolle, separat værktøjs-allowliste, begrænset budget og struktureret overlevering. Lad ikke alle agenter kalde alle værktøjer eller videresende en ubegrænset transskript. Start med én agent, indtil evalueringsdata beviser, at rolleadskillelse forbedrer resultatet.
Produktionsværn for en Grok 4.7 AI-agent
Valider før værktøjskørsel
Tjek værktøjsnavne, argumentskemaer, tenant-ejerskab, brugerrettigheder og ratelimitter i applikationskoden. Behandl værktøjsbeskrivelser som vejledning for modellen, ikke som en sikkerhedskontrol.
Adskil læseværktøjer fra skriveværktøjer
Læse-only værktøjer kan ofte køre automatisk efter autorisation. Skriveværktøjer bør kræve stærkere tjek, idempotens og bekræftelse for konsekvensfulde handlinger.
Begræns hver løkke
Sæt maksimum for modelture, værktøjsopkald, væg-kloktid, promptstørrelse og tokenbudget. Returnér en kontrolleret fejl eller eskalationsvej, når en grænse nås.
Registrér beslutningssporet
Log den ønskede opgave, politikversion, valgt model-id, fallback-årsag, værktøjsnavn, værktøjslatenstid, valideringsresultat, tokenforbrug og slutstatus. Log ikke hemmeligheder eller unødvendigt kundedataindhold.
Brug kontrakttest, ikke antagelser
Kør de samme fixtures mod hver konfigureret model. Et nyttigt minimumssæt dækker et normalt svar, ét værktøjskald, flere værktøjskald, fejlformede argumenter, et ukendt værktøj, en værktøjstimeout, en primær-model 429 og en ugyldig API-nøgle, der ikke må udløse fallback.
En deploymentsjekliste
- Hent aktuelle model-id’er og verificer Grok 4.7-ruten før deployment.
- Opbevar CometAPI-nøglen i en secret manager, aldrig i kildekode eller prompts.
- Start med læse-only værktøjer og eksplicitte JSON-skemaer.
- Anvend autentificering og tenant-autorisation før hvert værktøjskald.
- Tillad fallback kun for klassificerede midlertidige fejl.
- Test hver fallback mod den samme værktøjskaldskontrakt.
- Tilføj idempotens og bekræftelse før du aktiverer skriveværktøjer.
- Sæt grænser for løkke, latenstid, kontekst og omkostninger.
- Mål opgavesucces, ikke kun API-tilgængelighed.
Hvorfor bygge denne agent gennem CometAPI?
CometAPI er nyttig her, fordi den fælles integration forbliver lille. OpenAI Python SDK peger på én base-URL, Grok 4.7 vælges via model-id, og kompatible modeller fra andre udbydere kan placeres bag den samme applikationsejede rutepolitik.
Det giver et team plads til at evaluere GPT, Claude, Gemini og DeepSeek uden at sprede leverandørspecifik forbindelseskode gennem produktet. Det bevarer også en vigtig grænse: CometAPI leverer adgang, mens din applikation ejer kapabilitetskontroller, værktøjskørsel, fallback-politik, evaluering og brugerrettet adfærd.
Gennemse den aktuelle Grok 4.7-modelside, konfigurer klienten fra CometAPI quickstart, og hent aktuelle model-id’er før du vælger produktionsfallbacks.
FAQ
Hvilken API bør jeg bruge til en app med GPT, Claude, Gemini og DeepSeek?
Til den fælles chat- og værktøjskaldsvej kan en OpenAI-kompatibel samlet API som CometAPI reducere integrationsarbejdet. Behold modelvalg og fallback-politik i din applikation, og brug leverandørnative adaptere, når en krævet funktion ikke passer i den delte kontrakt.
Kan Grok 4.7 kalde Python-funktioner direkte?
Grok 4.7 kan returnere strukturerede funktionskaldsanmodninger. Din Python-applikation parser anmodningen, validerer den, udfører en funktion på allowlisten og sender resultatet tilbage til modellen. Modellen kører ikke lokal Python.
Skal hver fejl udløse en anden model?
Nej. Brug fallback til udvalgte forbindelsesfejl, timeouts, 408, 429 og midlertidige 5xx-svar. Ugyldige anmodninger, autentificeringsfejl og ikke-understøttede parametre bør rettes i stedet for at blive sendt til en anden model.
Kan jeg bruge ét værktøjsskema med hver model?
Kun efter test. En delt transport garanterer ikke identisk værktøjsadfærd, argumentkvalitet, parallel-kaldsadfærd eller skemahåndhævelse. Tilføj en model til kæden kun efter den består agentens kontrakttests.
Er et multimodel-fallbacksystem et multi-agent-system?
Nej. Fallback ændrer den model, der bruges til en anmodning efter en rutefejl. Multi-agent-arkitektur tildeler forskellige opgaver til separate agenter. Byg dem som separate lag med separate tests og kontroller.