Hvis du vil bygge én AI-app med GPT, Claude, Gemini, DeepSeek og Grok, bruk et samlet API for den felles forespørselsbanen og hold rutingspolicyen i applikasjonen din. CometAPI tilbyr en OpenAI-kompatibel base-URL og en delt modellkatalog, slik at en Python-tjeneste kan kalle ulike modell-ID-er gjennom én klient. Koden din bestemmer fortsatt hvilken modell som kjører, hvilke verktøy som er tillatt, og når en fallback er trygg.
Denne veiledningen bygger en Grok 4.7-agent som kan be om to skrivebeskyttede forretningsverktøy, avviser ukjente verktøy og feilformede argumenter før kjøring, og bytter til en annen kontrakttestet modell bare etter utvalgte forbigående feil. Målet er ikke et magisk autonomt system. Det er en liten, etterprøvbar løkke som kan testes og drives i produksjon.
Hva du skal bygge
Agenten har fem eksplisitte deler:
- Et CometAPI-klientbibliotek. OpenAI Python SDK bruker CometAPIs API-base-URL vist i oppsettet nedenfor.
- Grok 4.7 som primærmodell. Gjeldende CometAPI modell-ID er
grok-4.7. - Et verktøyregister. Modellen kan foreslå et funksjonskall, men bare applikasjonskoden kan kjøre en funksjon på tillattlisten.
- En avgrenset agentløkke. Løkken stopper etter et fast antall modellrunder i stedet for å kjøre på ubestemt tid.
- En ordnet fallback-policy. Kompatible GPT-, Claude-, Gemini- eller DeepSeek-modell-ID-er forsøkes bare etter en gjentakbar modell-/API-feil.
Grok 4.7 støtter funksjonskall, og CometAPI dokumenterer for øyeblikket både rutene /v1/chat/completions og /v1/responses for modellen. Denne veiledningen bruker Chat Completions fordi dens OpenAI-kompatible tools, assistentverktøykall og samsvarende tool-resultatmeldinger kartlegges direkte til en kompakt, etterprøvbar Python-løkke. Transportkompatibilitet beviser ikke funksjonsparitet på tvers av alle modeller, så hver konfigurert fallback må bestå de samme kontrakttestene før den settes i produksjon.
Resonneringstilstand i flerturns Grok 4.7-agenter
Grok 4.7 aksepterer low, medium, high eller xhigh resonneringsinnsats, med high som standard. På xAIs Responses API inkluderer hvert Grok 4.7-svar reasoning.encrypted_content; en klientstyrt flerturnsløkke bør sende tilbake de returnerte resonnementselementene uendret i neste forespørsel. Lange løkker kan også bruke context compaction: bevar det returnerte komprimeringselementet som ugjennomsiktig tilstand og legg til nye runder etter det. Fordi dette er tilstandsfulle, leverandørspesifikke responsfelter, verifiser at den valgte CometAPI-ruten returnerer dem ende-til-ende før du gjør dem til en produksjonsavhengighet.
Agentarkitektur: Modellen foreslår, appen din bestemmer
En sikker verktøykallflyt er enkel:
Brukerforespørsel → modellrespons → valider verktøykall → kjør verktøy på tillattliste → legg ved verktøyresultat → modellrespons
Modellen mottar aldri databaselegitimasjon og kjører aldri Python direkte. Den produserer en strukturert forespørsel som “kall get_order_status med denne ordre-ID-en.” Applikasjonen din sjekker verktøynavnet, parser argumentene, anvender autorisasjon og forretningsregler, kjører funksjonen og returnerer et serialisert resultat.
Denne separasjonen betyr mer enn modellvalget. En fallback-modell bør arve den samme verktøygrensen—ikke en bredere—og verktøyresultater bør behandles som ikke-betrodd data når de inneholder eksternt innhold.
Hvordan bygge en Grok 4.7 AI-agent med Python
Trinn 1: Konfigurer OpenAI Python SDK for CometAPI
Installer OpenAI SDK:
pip install openai
Sett konfigurasjon 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 veiledningen bruker Chat Completions fordi de eksplisitte assistentverktøykallene og samsvarende verktøyresultatmeldinger gjør kontrollflyten lett å inspisere i et kompakt Python-eksempel. For lengre, tilstandsfulle løkker, vurder Responses API som beskrevet ovenfor. Ikke kopier gamle modell-ID-er fra en bloggpost til produksjon: hent CometAPIs offentlige GET /api/models-katalog under utrulling eller oppstart, og bekreft deretter kapabiliteter og priser i modelldirektoriet.
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 eksplisitte tidsavbruddsverdien og deaktiverte SDK-gjentakelser er bevisste. Applikasjonen vil klassifisere feil og avgjøre om forespørselen skal gjentas eller gå videre til neste modell. Skjulte gjentakelser gjør ventetid, dupliserte sideeffekter og fallback-oppførsel vanskeligere å forstå.
Trinn 2: Definer smale, skrivebeskyttede verktøy først
Start med verktøy som leser data i stedet for å endre dem. Følgende definisjoner lar agenten sjekke en ordre og slå opp lager. Implementasjonen returnerer demodata; erstatt dette med autentiserte kall til dine egne tjenester.
import json
TOOLS = [
{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Les gjeldende status for én ordre.",
"parameters": {
"type": "object",
"properties": {
"order_id": {"type": "string"}
},
"required": ["order_id"],
"additionalProperties": False,
},
},
},
{
"type": "function",
"function": {
"name": "check_inventory",
"description": "Les tilgjengelig lager for én SKU.",
"parameters": {
"type": "object",
"properties": {
"sku": {"type": "string"}
},
"required": ["sku"],
"additionalProperties": False,
},
},
},
]
def get_order_status(order_id: str) -> dict:
# Erstatter denne demoen med et autentisert, skrivebeskyttet tjenestekall.
return {"order_id": order_id, "status": "in_transit"}
def check_inventory(sku: str) -> dict:
# Erstatter denne demoen med et autentisert, skrivebeskyttet tjenestekall.
return {"sku": sku, "available_units": 12}
TOOL_REGISTRY = {
"get_order_status": get_order_status,
"check_inventory": check_inventory,
}
Et JSON-skjema forbedrer formen på forespørselen, men det er ikke autorisasjon. Valider argumentlengder og -formater, bekreft at gjeldende bruker kan få tilgang til den forespurte ordren eller SKU-en, og begrens størrelsen på hvert verktøyresultat før du returnerer det til modellen.
Trinn 3: Legg til en smal multi-modell fallback-policy
Fallback bør gjenopprette fra midlertidige ruteproblemer, ikke skjule ødelagte forespørsler. CometAPIs offisielle fallback-guide anbefaler å gå videre til neste konfigurert rute for tilkoblingsfeil, tidsavbrudd, HTTP 408, HTTP 429 og midlertidige 5xx-responser. Ugyldige legitimasjoner, ikke-støttede parametere og ugyldige forespørsler bør feile umiddelbart.
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("Ingen konfigurert modell fullførte forespørselen") from last_error
Modelllisten er konfigurasjon, ikke en kvalitetsrangering. Velg fallback-modeller som støtter samme meldingsroller, verktøyskjema, inputmodalitet, kontekstkrav og responsatferd som kreves av denne agenten. Logg valgt rute og feilen som forårsaket hver overgang.
Trinn 4: Kjør den avgrensede Grok 4.7-agentløkken
Løkken nedenfor sender samtalen, kjører eventuelle verktøykall på tillattlisten, legger til resultater med samsvarende tool_call_id, og ber den valgte modellen fullfø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"Verktøy ikke tillatt: {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"Ugyldige verktøyargumenter: {error}"})
def run_agent(user_text: str, max_turns: int = 4) -> dict:
messages = [
{
"role": "system",
"content": (
"Du er en kundestøtteagent. Bruk verktøy bare når det er nødvendig. "
"Finn aldri 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("Agenten stoppet etter å ha nådd maks antall runder")
result = run_agent("Hvor er ordre A-104, og er SKU BLUE-42 på lager?")
print(result["answer"])
print(result["routes"])
Koden støtter flere verktøykall i én modellrespons fordi den legger til et resultat for hvert returnerte kall. Hvis et verktøy endrer tilstand—sender en e-post, legger inn en ordre eller utsteder en refusjon—legg til en idempotensnøkkel og et menneskelig bekreftelsestrinn. Start aldri hele agentrunden blindt på nytt etter et tidsavbrudd hvis en sideeffekt allerede kan ha skjedd.
Hvordan GPT, Claude, Gemini og DeepSeek passer i samme app
CometAPI kan redusere duplisering på tilkoblingslaget: én konto, én OpenAI-kompatibel base-URL for den felles veien, og en modell-ID valgt av applikasjonskoden. Det gjør GPT, Claude, Gemini, DeepSeek og Grok til kandidater bak ett internt grensesnitt.
Det gjør ikke modellene ombyttbare. Før du legger til en fallback, verifiser:
- at gjeldende modell-ID returneres av CometAPI-katalogen;
- at ruten støtter nødvendig verktøyskjema og meldingsroller;
- at argumenter til verktøykall og oppførsel for flere kall samsvarer med agentkontrakten;
- at kontekstvindu og inputmodaliteter passer forespørselen;
- at responsen kan valideres før den når brukeren;
- at latens og kostnad holder seg innenfor produktbudsjettet.
Leverandørnative funksjoner kan kreve et eget endepunkt eller en separat adapter. Hold disse unntakene eksplisitte i stedet for å tvinge hver kapasitet gjennom det felles grensesnittet.
Grok 4.7 multi-modell fallback er ikke det samme som multi-agent
En multi-modell fallback-kjede velger en annen modell når en rute feiler. Et multi-agent-system tildeler ulike ansvarsområder til separate agenter—for eksempel en planlegger, en forsker og en gjennomleser. De to mønstrene løser ulike problemer.
Hvis du utvider denne Grok 4.7-agenten til en multi-agent-arbeidsflyt, gi hver arbeider en smal rolle, separat verktøy-tillattliste, avgrenset budsjett og strukturert overlevering. La ikke hver agent kalle alle verktøy eller videresende et ubegrenset transkript. Start med én agent til evalueringsdata beviser at rolleseparasjon forbedrer resultatet.
Produksjonsrekkverk for en Grok 4.7 AI-agent
Valider før verktøykjøring
Kontroller verktøynavn, argumentskjemaer, leietaker-eierskap, brukerrettigheter og raterestriksjoner i applikasjonskoden. Behandle verktøybeskrivelser som veiledning for modellen, ikke som en sikkerhetskontroll.
Skill leseverktøy fra skriveverktøy
Skrivebeskyttede verktøy kan ofte kjøres automatisk etter autorisasjon. Skriveverktøy bør kreve sterkere kontroller, idempotens og bekreftelse for konsekvensielle handlinger.
Avgrens hver løkke
Sett maksimum for modellrunder, verktøykall, veggklokketid, promptstørrelse og tokenbudsjett. Returner en kontrollert feil eller eskaleringsbane når en grense nås.
Registrer beslutningssporet
Logg den forespurte oppgaven, policyversjon, valgt modell-ID, fallback-årsak, verktøynavn, verktøylatens, valideringsresultat, tokenbruk og sluttstatus. Ikke logg hemmeligheter eller unødvendig kundedata.
Bruk kontrakttester, ikke antakelser
Kjør de samme fiksturene mot hver konfigurert modell. Et nyttig minimumssett dekker et normalt svar, ett verktøykall, flere verktøykall, feilformede argumenter, et ukjent verktøy, et verktøytidsavbrudd, en 429 fra primærmodellen og en ugyldig API-nøkkel som ikke skal utløse fallback.
En utrullingssjekkliste
- Hent gjeldende modell-ID-er og verifiser Grok 4.7-ruten før utrulling.
- Oppbevar CometAPI-nøkkelen i en hemmelighetshåndterer, aldri i kildekode eller prompts.
- Start med skrivebeskyttede verktøy og eksplisitte JSON-skjemaer.
- Bruk autentisering og leietakerautorisasjon før hvert verktøykall.
- Tillat fallback bare for klassifiserte forbigående feil.
- Test hver fallback mot den samme verktøykallkontrakten.
- Legg til idempotens og bekreftelse før du aktiverer skriveverktøy.
- Sett grenser for løkke, latens, kontekst og kostnad.
- Mål oppgavesuksess, ikke bare API-tilgjengelighet.
Hvorfor bygge denne agenten gjennom CometAPI?
CometAPI er nyttig her fordi den felles integrasjonen forblir liten. OpenAI Python SDK peker til én base-URL, Grok 4.7 velges ved modell-ID, og kompatible modeller fra andre leverandører kan plasseres bak den samme applikasjonseide rutepolicyen.
Det gir et team rom til å evaluere GPT, Claude, Gemini og DeepSeek uten å spre leverandørspesifikk tilkoblingskode gjennom produktet. Det bevarer også en viktig grense: CometAPI leverer tilgang, mens applikasjonen din eier kapabilitetskontroller, verktøykjøring, fallback-policy, evaluering og brukerrettet atferd.
Se gjennom den aktuelle Grok 4.7-modellsiden, konfigurer klienten fra CometAPI-quickstarten, og hent gjeldende modell-ID-er før du velger produksjons-fallbacks.
FAQ
Hvilket API bør jeg bruke for en app med GPT, Claude, Gemini og DeepSeek?
For den felles chat- og verktøykallbanen kan et OpenAI-kompatibelt samlet API som CometAPI redusere integrasjonsarbeid. Hold modellvalg og fallback-policy i applikasjonen din, og bruk leverandørnative adaptere når en nødvendig funksjon ikke passer den delte kontrakten.
Kan Grok 4.7 kalle Python-funksjoner direkte?
Grok 4.7 kan returnere strukturerte funksjonskallforespørsler. Python-applikasjonen din parser forespørselen, validerer den, kjører en funksjon på tillattlisten og sender resultatet tilbake til modellen. Selve modellen kjører ikke lokal Python.
Skal alle feil utløse en annen modell?
Nei. Bruk fallback for utvalgte tilkoblingsfeil, tidsavbrudd, 408, 429 og midlertidige 5xx-responser. Ugyldige forespørsler, autentiseringsfeil og ikke-støttede parametere bør fikses i stedet for å sendes til en annen modell.
Kan jeg bruke ett verktøyskjema med hver modell?
Bare etter testing. En delt transport garanterer ikke identisk verktøyoppførsel, argumentkvalitet, parallellkalloppførsel eller skemahåndheving. Legg til en modell i kjeden først etter at den består agentens kontrakttester.
Er et multi-modell fallback-system et multi-agent-system?
Nei. Fallback endrer modellen som brukes for en forespørsel etter en rutefeil. Multi-agent-arkitektur tildeler ulike oppgaver til separate agenter. Bygg dem som separate lag med egne tester og kontroller.