Következtetés kódoláshoz és hibakereséshez
Ezen az oldalon
A lecke frissítve: 2026. november 2. Az eredeti példák a Magistral modellt használták, amelyet 2026. július 31-én kivontak a forgalomból. Most a Mistral Small 4 (
mistral-small-2603) vagy a Mistral Large 4 (mistral-large-4-0) modelleket hívjuk meg areasoning_effort="high"paraméterrel, és a választ a 3. leckében bemutatottseparerfüggvénnyel dolgozzuk fel. Forrás: Reasoning (Mistral dokumentáció).
Hibakeresés: Egy következtetési feladat
Miért profitál jobban a hibakeresés a következtetéstől, mint a kódgenerálás? Mert a kódgenerálás egy előhívási gyakorlat – a modell millió rendező függvényt látott már –, addig a hibakeresés egy szembesítési gyakorlat. Két dolgot kell egyszerre fejben tartanod: azt, amit a kódnak tennie kellene, és azt, amit valójában csinál, majd meg kell találnod a kettő közötti eltérést. Pontosan ez az a feladat, ahol a válaszadás előtti gondolkodás megváltoztatja a végeredményt.
Egy hiba megtalálása alapvetően egy következtetési gyakorlat. Meg kell értened a szándékot, végig kell követned a végrehajtást, azonosítanod kell az elvárt és a tényleges viselkedés közötti eltérést, majd meg kell fogalmaznod a javítást. Pontosan itt teszi le a névjegyét a következtetés.
Klasszikus hibakeresés
Figyeld meg a kérés formáját ebben a példában. Nem azt mondjuk, hogy „javítsd meg ezt a kódot“. Ehelyett leírjuk a tünetet – azt, ami történnie kellett volna, szemben azzal, ami történik. Ugyanezt a fegyelmet alkalmazod egy emberi kollégával is: a tünetből kiinduló diagnózis megtalálja az okot, míg a puszta „javítsd meg“ kontextus nélkül gyakran olyan átírást eredményez, amely elfedi a hibát ahelyett, hogy megoldaná azt.
from mistralai.client import Mistral
client = Mistral(api_key="YOUR_API_KEY")
buggy_code = """
def merge_sorted_lists(list1, list2):
result = []
i = j = 0
while i < len(list1) and j < len(list2):
if list1[i] <= list2[j]:
result.append(list1[i])
i += 1
else:
result.append(list2[j])
j += 1
return result
# Test: merge_sorted_lists([1, 3, 5], [2, 4, 6])
# Expected result: [1, 2, 3, 4, 5, 6]
# Actual result: [1, 2, 3, 4, 5]
"""
response = client.chat.complete(
model="mistral-small-2603",
reasoning_effort="high",
messages=[
{"role": "system", "content": """Python debugging expert.
Method:
1. Trace execution mentally
2. Identify where behavior diverges
3. Explain the root cause
4. Propose a fix with a test"""},
{"role": "user", "content": f"This code has a bug. Diagnose and fix it:\n\n{buggy_code}"}
],
)
A modell azonosítani fogja, hogy a függvény nem kezeli a while ciklus után maradó elemeket (hiányzik a list1[i:] és list2[j:] farokrészek hozzáadása).
Komplex kódelemzés
A legacy kódok megértése a második fő felhasználási terület, és van egy érdekes tulajdonsága: a következtetési nyomvonal ugyanolyan értékes, mint maga a válasz. Azzal, hogy elolvasod, hogyan rekonstruálta a modell a logikát – milyen hipotéziseket alkotott, milyen ellenőrzéseket végzett –, egy olyan olvasási térképet kapsz a kódhoz, amelyet egy egyszerű végső magyarázat nem tud nyújtani.
complex_code = """
def process(data):
cache = {}
def helper(n, memo=cache):
if n in memo:
return memo[n]
if n < 2:
memo[n] = n
return n
result = helper(n-1) + helper(n-2)
memo[n] = result
return result
return [helper(x) for x in data if isinstance(x, int) and x >= 0]
"""
response = client.chat.complete(
model="mistral-small-2603",
reasoning_effort="high",
messages=[
{"role": "user", "content": f"""Analyze this code in depth:
1. What exactly does it do?
2. Are there any potential issues?
3. How can it be improved?
{complex_code}"""}
]
)
Specifikus hibák hibakeresése
Típushibák
type_error = """
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
Code:
def calculate_total(items):
total = None
for item in items:
price = item.get('price')
total = total + price
return total
"""
response = client.chat.complete(
model="mistral-small-2603",
reasoning_effort="high",
messages=[
{"role": "user", "content": f"Explain this error and fix the code:\n\n{type_error}"}
]
)
Teljesítménybeli problémák
slow_code = """
def find_duplicates(lst):
duplicates = []
for i in range(len(lst)):
for j in range(i + 1, len(lst)):
if lst[i] == lst[j] and lst[i] not in duplicates:
duplicates.append(lst[i])
return duplicates
# This code is very slow on large lists (100,000+ elements)
"""
response = client.chat.complete(
model="mistral-small-2603",
reasoning_effort="high",
messages=[
{"role": "system", "content": "Analyze the algorithmic complexity and propose an optimized version."},
{"role": "user", "content": f"Optimize this code:\n\n{slow_code}"}
]
)
Architektúra és refaktorálás
A következtetés az architektúrális döntésekre is alkalmazható:
architecture = """My Flask application has this structure:
app.py (2000 lines):
- API routes (20 endpoints)
- Business logic
- Database access
- Data validation
- Error handling
How should I restructure this application?"""
response = client.chat.complete(
model="mistral-small-2603",
reasoning_effort="high",
messages=[
{"role": "system", "content": """Senior software architect.
Reason through SOLID principles, separation of concerns,
and long-term maintainability."""},
{"role": "user", "content": architecture}
],
)
Minta: Kódreview asszisztens
Kombináld a következtetést a szisztematikus elemzéssel:
def code_review(client, code, language="python"):
"""Performs an in-depth code review with reasoning."""
review_prompt = f"""Perform a detailed code review of this {language} code.
Systematically analyze:
1. **Correctness**: Does the code do what it is supposed to do?
2. **Edge cases**: Are edge cases handled (None, empty, negative)?
3. **Performance**: What is the complexity? Is it optimal?
4. **Readability**: Is the code clear and well-named?
5. **Security**: Are there vulnerabilities (injection, XSS, etc.)?
For each issue found, indicate:
- The line number
- The severity (critical / major / minor)
- The recommended fix
Code to review:
```{language}
{code}
```"""
response = client.chat.complete(
model="mistral-small-2603",
reasoning_effort="high",
messages=[{"role": "user", "content": review_prompt}]
)
return separer(response.choices[0].message.content)[1] # the answer, without the reasoning
Small 4 vagy Large 4 kódhoz?
Hibakeresésnél és kódelemzésnél a két megközelítés közötti választás a probléma mélységétől függ. Egy egyszerű hiba – szintaktikai hiba, explicit kivétel, nyilvánvaló optimalizálás – kezelésére a Mistral Small 4 (mistral-small-2603) kiválóan alkalmas a reasoning_effort="high" paraméterrel, mérsékelt tokenköltség mellett. A Mistral Large 4 modellt (mistral-large-4-0, nyilvános előzetes verzió) olyan esetekre tartogasd, ahol az ok nem látható közvetlenül a kódban: architektúrális elemzések, olyan finom hibák, mint a versenyhelyzetek (race conditions) vagy memóriaszivárgások, amelyek csak éles környezetben jelentkeznek, valamint komplex kódreview-k, ahol egyensúlyt kell teremteni a helyesség, a teljesítmény és a biztonság között.
# Simple bug: Small is sufficient
simple_bug = "why does 'hello'.split('')[0] raise an error?"
response = client.chat.complete(
model="mistral-small-2603",
messages=[{"role": "user", "content": simple_bug}],
reasoning_effort="high"
)
# Complex bug: Large 4, evaluate on your own cases
complex_bug = "My Django application has a memory leak in production that does not appear in dev..."
response = client.chat.complete(
model="mistral-large-4-0",
reasoning_effort="high",
messages=[{"role": "user", "content": complex_bug}]
)
Főbb megállapítások
- A hibakeresés ideális következtetési gyakorlat a
reasoning_effort="high"beállításhoz - Irányítsd a modellt egy olyan rendszerüzenettel, amely strukturálja a diagnosztikai módszert
- A következtetés a finom hibáknál, a teljesítményelemzéseknél és az architektúránál ragyog
- A Small 4
highmódban elegendő a gyakori hibákhoz; a finom hibáknál és az architektúránál teszteld a Large 4 modellt - Kombináld a következtetést a szisztematikus kódreview-val a minőség maximalizálása érdekében
- Mindig kérj egy ellenőrző tesztet a javasolt javításhoz