Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Tfittxija Semantika tal-Kodiċi

Lezzjoni 6 / 18 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Iftixxar il-Kodiċi skont it-Tifsira
  2. L-Indiċjar ta’ Direttorju tal-Kodiċi
  3. Il-Kodifika u l-Indiċjar
  4. Tfittxija b’Lingwa Naturali
  5. Tfittxija Translingwistika
  6. Tfittxija skont il-Firma tal-Funzjoni
  7. Punti Ewlenin

Iftixxar il-Kodiċi skont it-Tifsira

It-tfittxija tradizzjonali tal-kodiċi tiddependi fuq kliem ewlieni: tikteb isem funzjoni jew kelma minn kumment. It-tfittxija semantika tal-kodiċi tmur lil hinn minn hekk: issib kodiċi skont it-tifsira jew l-intenzjoni tiegħu, anke jekk it-termini eżatti ma jaqblux.

B’codestral-embed, tista’ tfittex kodiċi billi tuża lingwa naturali. Mistoqsija bħal “funzjoni li tissortja lista” se ssib implimentazzjoni ta’ quicksort anke jekk il-kelma “sort” qatt ma tidher fil-kodiċi. Dan jirrifletti r-realtà ta’ kuljum ta’ żviluppatur li jingħaqad ma’ proġett eżistenti: tkun taf x’inhu qed tfittex, iżda m’għandek l-ebda idea ta’ kif it-tim ta’ qablek semmieh.

L-Indiċjar ta’ Direttorju tal-Kodiċi

L-ewwel pass huwa li testratti u tikkodifika kull fajl jew funzjoni f’proġett. Il-funzjoni hawn taħt timxi mal-ġerarkija tad-direttorji u teskludi l-folders li jkunu jistgħu jħawdu l-indiċi. node_modules waħdu jista’ jkun għaxar darbiet akbar mill-kodiċi li ktibt int stess, u l-ebda wieħed mill-fajls tiegħu mhu rilevanti għat-tfittxija tiegħek.

import os
import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def extract_code_files(directory, extensions=(".py", ".js", ".ts")):
    """Extract all code files from a directory."""
    code_files = []
    for root, dirs, files in os.walk(directory):
        # Ignore irrelevant directories
        dirs[:] = [d for d in dirs if d not in ("node_modules", ".git", "__pycache__", "venv")]
        for f in files:
            if any(f.endswith(ext) for ext in extensions):
                filepath = os.path.join(root, f)
                with open(filepath, "r", encoding="utf-8", errors="ignore") as fh:
                    content = fh.read()
                if content.strip():
                    code_files.append({
                        "path": filepath,
                        "content": content[:4000],  # Truncate if too long
                    })
    return code_files

# Extract files
code_files = extract_code_files("./my-project/")
print(f"{len(code_files)} code files found")

Żewġ dettalji ta’ implimentazzjoni jistħoqqilhom attenzjoni. Il-modifika ta’ dirs[:] fil-post mhix sempliċiment abbrevjazzjoni; hija l-uniku mod biex tipprevjeni lil os.walk milli jinżel f’dawk id-direttorji. Li terġa’ tassenja l-varjabbli mingħajr ma tuża s-slicing ma jkollu l-ebda effett. Għal dak li għandu x’jaqsam mat-trunkar f’4,000 karattru, dan jipproteġik minn fajls mostrużi li jistgħu jfaqqgħu t-talba, filwaqt li jżomm l-intestatura tal-fajl—l-importazzjonijiet, id-definizzjonijiet prinċipali—li ġġib l-aktar sinjal sinifikanti.

Il-Kodifika u l-Indiċjar

Il-kodifika sseħħ f’lottijiet ta’ għoxrin fajl, b’wirja tal-progress. Fuq repository b’ħafna mijiet ta’ fajls, dan iċ-ċiklu jgħaddi għal diversi minuti. Mingħajr counter, m’għandek l-ebda mod biex tgħarraf bejn ipproċessar bil-mod u sejħa mwaqqfa.

def index_code_files(code_files, batch_size=20):
    """Create embeddings for all code files."""
    all_embeddings = []

    for i in range(0, len(code_files), batch_size):
        batch = code_files[i:i + batch_size]
        inputs = [f["content"] for f in batch]

        response = client.embeddings.create(
            model="codestral-embed",
            inputs=inputs,
        )
        all_embeddings.extend([d.embedding for d in response.data])
        print(f"Encoded {min(i + batch_size, len(code_files))}/{len(code_files)}")

    return np.array(all_embeddings)

embeddings = index_code_files(code_files)
print(f"Index: {embeddings.shape}")

L-ordni tal-embeddings fil-matriċi taqbel eżattament mal-ordni ta’ code_files. Din il-korrispondenza impliċita hija ċ-ċerniera għal kull ma jmiss: tippermetti li indiċi rritornat mill-klassifikazzjoni jipponta lejn mogħdija speċifika ta’ fajl.

Tfittxija b’Lingwa Naturali

Il-vantaġġ ewlieni ta’ codestral-embed huwa li tista’ tfittex billi tuża mistoqsija bil-Malti, bil-Franċiż jew bl-Ingliż. Il-funzjoni tikkodifika l-mistoqsija bl-istess mudell, tikkalkula s-similaritajiet kontra l-indiċi kollu, u tirritorna l-aqwa riżultati top_k flimkien ma’ previżjoni tal-kontenut.

from sklearn.metrics.pairwise import cosine_similarity

def search_code(query, code_files, embeddings, top_k=5):
    """Search for code using natural language descriptions."""
    # Encode the query
    response = client.embeddings.create(
        model="codestral-embed",
        inputs=[query],
    )
    query_emb = np.array(response.data[0].embedding)

    # Calculate similarities
    sims = cosine_similarity([query_emb], embeddings)[0]

    # Top-k results
    top_indices = np.argsort(sims)[::-1][:top_k]

    results = []
    for idx in top_indices:
        results.append({
            "path": code_files[idx]["path"],
            "score": float(sims[idx]),
            "preview": code_files[idx]["content"][:200],
        })
    return results

# Natural language searches
queries = [
    "email validation function",
    "database connection",
    "HTTP error handling",
    "sorting algorithm",
]

for query in queries:
    print(f"\n--- Query: '{query}' ---")
    results = search_code(query, code_files, embeddings, top_k=3)
    for r in results:
        print(f"  [{r['score']:.3f}] {r['path']}")

Il-kamp preview għandu utilità prattika immedjata: jiffrankalek li tiftaħ ħames fajls biex tifhem liema wieħed jaqbel verament. F’integrazzjoni ma’ editur, dawn il-mitejn karattru jsiru l-linja ta’ previżjoni murija taħt kull riżultat.

Tfittxija Translingwistika

codestral-embed jifhem il-loġika irrispettivament mil-lingwa. Tista’ tfittex mudell f’Python u ssib l-ekwivalenti tiegħu f’JavaScript:

# Search using a code example in one language...
query_python = "def authenticate(username, password): check credentials and return token"

# ...and find the equivalent in another language
results = search_code(query_python, code_files, embeddings)
# May return a .js file with a similar function

Din il-kapaċità hija prezzjuża għal applikazzjonijiet maqsuma bejn backend f’Python u frontend f’TypeScript, fejn l-istess regola tan-negozju xi kultant tiġi implimentata fuq iż-żewġ naħat. Li ssib iż-żewġ implimentazzjonijiet minn mistoqsija waħda jgħinek tinduna bid-diverġenzi qabel ma bug jiżvelahom fil-produzzjoni.

Tfittxija skont il-Firma tal-Funzjoni

Tista’ wkoll tfittex skont il-forma mistennija aktar milli d-dominju funzjonali. Id-deskrizzjoni tal-istruttura—funzjoni asinkrona, klassi, middleware, test—tidderieġi t-tfittxija lejn tip ta’ oġġett tal-kodiċi aktar milli lejn suġġett.

technical_queries = [
    "async function that fetches data from API and handles errors",
    "class with CRUD methods for database operations",
    "middleware that checks authentication token",
    "unit test for user registration",
]

for q in technical_queries:
    results = search_code(q, code_files, embeddings, top_k=2)
    print(f"\n{q}:")
    for r in results:
        print(f"  -> {r['path']} (score: {r['score']:.3f})")

Ipprova dawn l-erba’ mistoqsijiet fuq ir-repository tiegħek stess qabel ma tkompli. Se tinduna li r-riżultati jiddeterjoraw b’mod sinifikanti fuq fajls twil ħafna, fejn it-trunkar ta’ 4,000 karattru qata’ l-parti utli. Dan huwa l-mument li tiddeċiedi jekk tridx tindiċizza fajls sħaħ jew, aħjar minn hekk, funzjonijiet maqsuma waħda waħda.

Punti Ewlenin

  • codestral-embed jippermettilek tfittex kodiċi billi tuża deskrizzjonijiet f’lingwa naturali
  • L-indiċjar jinvolvi l-kodifika tal-fajls kollha tal-kodiċi f’vetturi
  • It-tfittxija translingwistika taħdem: mudell f’Python isib l-ekwivalenti f’JS
  • Iffiltra d-direttorji mhux rilevanti (node_modules, .git, venv) matul l-estrazzjoni
  • Aqta’ l-fajls twil ħafna biex tibqa’ fil-limiti tal-mudell