TypeError: string indices must be integers, not 'str'
La OpenAI, `item.arguments` dintr-un `function_call` este text JSON, nu dicționar, deci `item.arguments["oras"]` dă eroarea. Parsează-l întâi: `args = json.loads(item.arguments)`, apoi `args["oras"]`.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Mesajul vine din Python: ai folosit paranteze drepte cu un text ("oras") pe o valoare care e șir de caractere. Pe un șir, [...] acceptă doar poziții numerice (s[0]), nu chei.
În function calling cu OpenAI (Responses API și Chat Completions), modelul întoarce argumentele funcției ca text JSON: item.arguments == '{"oras": "Constanța"}'. E o diferență importantă față de Claude, unde bloc.input e deja dicționar. Cine trece de la un SDK la altul sau scrie din memorie accesează direct item.arguments["oras"] și primește această eroare.
În versiunile mai vechi de Python, mesajul este TypeError: string indices must be integers. Aceeași cauză apare oriunde ai un JSON încă neparsat: un răspuns text al modelului, un câmp citit din fișier sau dintr-o bază de date.
De ce apare: cauzele frecvente
1Argumentele OpenAI folosite fără json.loads
for item in r.output:
if item.type == "function_call":
oras = item.arguments["oras"]for item in r.output:
if item.type == "function_call":
args = json.loads(item.arguments)
oras = args["oras"]arguments e text JSON; după json.loads devine dicționar și accepți cheile.
2Chat Completions, aceeași capcană
call = r.choices[0].message.tool_calls[0]
oras = call.function.arguments["oras"]call = r.choices[0].message.tool_calls[0]
oras = json.loads(call.function.arguments)["oras"]Și la Chat Completions argumentele vin ca text JSON, în function.arguments.
3Răspuns text JSON folosit ca dicționar
date = r.output_text
print(date["categorie"])date = json.loads(r.output_text)
print(date["categorie"])Orice JSON primit ca text trebuie parsat înainte să-i citești cheile.
Repară eroarea, direct în pagină
Programul de mai jos folosește function calling cu OpenAI și dă TypeError: string indices must be integers, not 'str' la citirea argumentelor. Repară citirea: parsează apel.arguments cu json.loads înainte să iei orașul. Programul afișează Oraș cerut: ... și răspunsul final.
import json
from openai import OpenAI
MODEL = "gpt-6-luna"
client = OpenAI()
TOOLS = [{
"type": "function",
"name": "vremea",
"description": "Vremea de azi într-un oraș din România.",
"parameters": {
"type": "object",
"properties": {"oras": {"type": "string"}},
"required": ["oras"],
"additionalProperties": False,
},
"strict": True,
}]
def vremea(oras):
return "18 grade, senin"
intrari = [{"role": "user", "content": "Cum e vremea azi la Constanța?"}]
r = client.responses.create(model=MODEL, tools=TOOLS, input=intrari)
intrari += r.output
for apel in r.output:
if apel.type == "function_call":
oras = apel.arguments["oras"]
print("Oraș cerut:", oras)
intrari.append({"type": "function_call_output", "call_id": apel.call_id, "output": vremea(oras)})
r = client.responses.create(model=MODEL, tools=TOOLS, input=intrari)
print(r.output_text)Oraș cerut: Constanța Azi în Constanța: 18 grade, senin.
Indiciu
apel.arguments e un text JSON; json.loads îl face dicționar.
Reparația
import json
from openai import OpenAI
MODEL = "gpt-6-luna"
client = OpenAI()
TOOLS = [{
"type": "function",
"name": "vremea",
"description": "Vremea de azi într-un oraș din România.",
"parameters": {
"type": "object",
"properties": {"oras": {"type": "string"}},
"required": ["oras"],
"additionalProperties": False,
},
"strict": True,
}]
def vremea(oras):
return "18 grade, senin"
intrari = [{"role": "user", "content": "Cum e vremea azi la Constanța?"}]
r = client.responses.create(model=MODEL, tools=TOOLS, input=intrari)
intrari += r.output
for apel in r.output:
if apel.type == "function_call":
args = json.loads(apel.arguments)
oras = args["oras"]
print("Oraș cerut:", oras)
intrari.append({"type": "function_call_output", "call_id": apel.call_id, "output": vremea(oras)})
r = client.responses.create(model=MODEL, tools=TOOLS, input=intrari)
print(r.output_text)De ce merge
OpenAI întoarce argumentele funcției ca text JSON. Pe un text, ["oras"] nu are sens, de aici eroarea. După json.loads, ai un dicționar cu cheia oras, iar restul buclei (trimiterea rezultatului cu function_call_output) merge ca înainte. La Claude, situația e diferită: bloc.input e deja dicționar și se folosește direct.
Alte forme ale mesajului
TypeError: string indices must be integers
Cum o eviți pe viitor
- Reține diferența: OpenAI
arguments= text JSON; Claudeinput= dicționar. - Parsează argumentele într-un singur loc, în dispecerul de tool-uri, cu
try/except json.JSONDecodeError. - Validează argumentele parsate (chei obligatorii, tipuri) înainte să apelezi funcția.
- La depanare, afișează
type(apel.arguments): dacă vezistr, mai ai un pas de parsare înainte să citești cheile.
Întrebări frecvente
De ce OpenAI trimite argumentele ca text?
Așa e definit formatul API-ului: modelul generează textul JSON al argumentelor, iar SDK-ul ți-l dă neschimbat. Parsarea rămâne în grija ta.
Poate fi JSON-ul argumentelor invalid?
Cu "strict": True în definiția tool-ului, argumentele respectă schema. Fără strict, rar, pot apărea argumente incomplete, deci prinde json.JSONDecodeError și trimite modelului un rezultat de eroare.
Erori înrudite
TypeError: the JSON object must be str, bytes or bytearray, not list Ai dat lui `json.loads` lista de blocuri `raspuns.content`, nu textul din ea. `json.loads` primește doar text: folosește `json.loads(raspuns.content[0].text)` (sau textul lipit din blocurile `text`). openai.BadRequestError: Error code: 400 - No tool call found for function call output with call_id call_abc123. Ai trimis la OpenAI un `function_call_output`, dar în `input` nu există apelul de funcție (`function_call`) cu același `call_id`. Înainte să adaugi rezultatele, adaugă în listă item-urile din răspunsul modelului: `intrari += r.output`. TypeError: verifica_stoc() got an unexpected keyword argument 'marime' Ai apelat funcția tool-ului cu argumentele modelului (`functie(**bloc.input)`), iar modelul a trimis un argument pe care funcția nu îl are. Fă funcția să accepte toate proprietățile din schemă (cu valori implicite pentru cele opționale) și validează argumentele înainte de apel. Învață Aplicații AI cu LLM de la zero, cu exerciții la fiecare lecție
Curs Aplicații AI cu Claude și OpenAI: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 8 lecții sunt gratuite.
