Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Slučaj upotrebe: Ugradnje koda

Lekcija 8 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Izvan pretraživanja
  2. Analitika repozitorija
  3. Otkrivanje duplikata
  4. Grupiranje po funkcionalnosti
  5. Kontekstualni asistent za kod
  6. Metrike kvalitete koda
  7. Ključne točke

Izvan pretraživanja

Ugradnje koda ne služe samo za semantičko pretraživanje. One otključavaju napredne primjene: analitiku repozitorija, grupiranje, otkrivanje duplikata i asistente za razvoj. U ovoj lekciji istražit ćeš ove slučajeve upotrebe uz konkretan Python kod.

Ova četiri slučaja upotrebe dijele zajedničku osobinu: iskorištavaju geometriju indeksa umjesto upita. Jednom kada su tvoje datoteke smještene u vektorski prostor, njihovi relativni položaji pričaju priču o samom projektu: što nalikuje čemu, što se ponavlja i što se ističe.

Analitika repozitorija

Analiziraj semantičku strukturu projekta kako bi razumio kako je kod organiziran. K-Means grupira datoteke u pet obitelji na temelju njihove vektorske blizine, bez ikakvog gledanja u stablo mapa. Rezultat je često poučan: na neurednom projektu vidjet ćeš kako datoteke iz vrlo različitih direktorija završavaju u istom klasteru jer se zapravo bave istom temom.

import numpy as np
from sklearn.cluster import KMeans
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def analyze_repo(code_files, n_clusters=5):
    """Analyze the semantic structure of a repository."""
    # Encode all files
    inputs = [f["content"][:3000] for f in code_files]
    response = client.embeddings.create(
        model="codestral-embed",
        inputs=inputs,
    )
    embeddings = np.array([d.embedding for d in response.data])

    # K-Means Clustering
    kmeans = KMeans(n_clusters=n_clusters, random_state=42, n_init=10)
    labels = kmeans.fit_predict(embeddings)

    # Group files by cluster
    clusters = {}
    for i, label in enumerate(labels):
        if label not in clusters:
            clusters[label] = []
        clusters[label].append(code_files[i]["path"])

    return clusters

# Usage
clusters = analyze_repo(code_files, n_clusters=5)
for cluster_id, files in clusters.items():
    print(f"\nCluster {cluster_id} ({len(files)} files):")
    for f in files[:5]:
        print(f"  - {f}")

Parametar random_state=42 fiksira inicijalizaciju: bez njega bi dva uzastopna pokretanja dala različite brojeve klastera, što bi onemogućilo usporedbu analiza tijekom vremena.

Otkrivanje duplikata

Identificiraj duplicirani ili gotovo duplicirani kod u svojoj bazi. Za razliku od klasičnog alata za detekciju koji uspoređuje tekst, ovaj pristup također uočava prepisane duplikate – datoteku kopiranu iz jednog modula u drugi, preimenovanu, s različitim varijablama, ali istom logikom.

from sklearn.metrics.pairwise import cosine_similarity

def find_duplicates(code_files, embeddings, threshold=0.95):
    """Find pairs of near-identical files."""
    sim_matrix = cosine_similarity(embeddings)
    duplicates = []

    for i in range(len(code_files)):
        for j in range(i + 1, len(code_files)):
            if sim_matrix[i][j] >= threshold:
                duplicates.append({
                    "file_a": code_files[i]["path"],
                    "file_b": code_files[j]["path"],
                    "similarity": float(sim_matrix[i][j]),
                })

    # Sort by decreasing similarity
    duplicates.sort(key=lambda x: x["similarity"], reverse=True)
    return duplicates

# Find duplicates
dupes = find_duplicates(code_files, embeddings, threshold=0.92)
print(f"{len(dupes)} potential duplicate pairs found:")
for d in dupes[:10]:
    print(f"  {d['similarity']:.3f} : {d['file_a']} <-> {d['file_b']}")

Unutarnja petlja počinje od i + 1 kako bi se svaki par usporedio samo jednom. Ipak, pazi na trošak: matrica sličnosti je kvadratna, a nakon nekoliko tisuća datoteka morat ćeš prijeći na približni indeks umjesto na iscrpni izračun. Smanjenje praga s 0,95 na 0,92 baca širu mrežu za obrađene duplikate, uz cijenu od nekoliko lažno pozitivnih rezultata koje trebaš ručno sortirati.

Grupiranje po funkcionalnosti

K-Means zahtijeva da unaprijed znaš broj grupa, što je rijetko slučaj kada istražuješ projekt. DBSCAN rješava ovo ograničenje: sam određuje broj grupa i, što je ključno, dopušta da datoteka ne pripada nijednoj – što je značenje oznake „Neklasificirano“ u kodu ispod.

from sklearn.cluster import DBSCAN

def cluster_by_functionality(code_files, embeddings, eps=0.3, min_samples=2):
    """Group code by functionality using DBSCAN."""
    # DBSCAN on cosine distances
    distance_matrix = 1 - cosine_similarity(embeddings)
    clustering = DBSCAN(eps=eps, min_samples=min_samples, metric="precomputed")
    labels = clustering.fit_predict(distance_matrix)

    # Organize by cluster
    groups = {}
    for i, label in enumerate(labels):
        group_name = f"Group {label}" if label >= 0 else "Unclassified"
        if group_name not in groups:
            groups[group_name] = []
        groups[group_name].append(code_files[i]["path"])

    return groups

groups = cluster_by_functionality(code_files, embeddings)
for name, files in groups.items():
    print(f"\n{name} ({len(files)} files):")
    for f in files[:3]:
        print(f"  - {f}")

Pretvorba putem 1 - cosine_similarity pretvara sličnost u udaljenost, format koji DBSCAN očekuje s metric="precomputed". Parametar eps=0.3 stoga znači da su dvije datoteke susjedi počevši od kosinusne sličnosti od 0,7.

Kontekstualni asistent za kod

Ovaj posljednji primjer sastavlja prethodne gradivne blokove u pravi RAG sustav za kod: traženje relevantnih datoteka, izgradnja konteksta, a zatim poziv LLM-u. Prag od 0,5 filtrira unaprijed – bolje je modelu dati dvije datoteke koje su doista povezane s pitanjem nego tri, od kojih je jedna izvan teme i zavarat će ga.

def code_assistant(question, code_files, embeddings, top_k=3):
    """Find relevant code to answer a question."""
    # Encode the question
    response = client.embeddings.create(
        model="codestral-embed",
        inputs=[question],
    )
    query_emb = np.array(response.data[0].embedding)

    # Find the most relevant code
    sims = cosine_similarity([query_emb], embeddings)[0]
    top_indices = np.argsort(sims)[::-1][:top_k]

    context_parts = []
    for idx in top_indices:
        if sims[idx] > 0.5:  # Minimum threshold
            context_parts.append(
                f"# File: {code_files[idx]['path']}\n"
                f"{code_files[idx]['content'][:1500]}"
            )

    context = "\n\n---\n\n".join(context_parts)

    # Build the prompt for the LLM
    prompt = f"""Here is relevant code from our project:

{context}

Developer question: {question}

Answer based on the code above."""

    # Call the LLM with context
    chat_response = client.chat.complete(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}],
    )

    return chat_response.choices[0].message.content

# Usage
answer = code_assistant(
    "How does authentication work in this project?",
    code_files,
    embeddings,
)
print(answer)

Putanja datoteke ubacuje se kao komentar iznad svakog isječka. To nije dekorativno: model to koristi za citiranje izvora, a programer koji čita odgovor odmah zna gdje provjeriti.

Metrike kvalitete koda

Konačno, ugradnje pomažu uočiti ono što strši kao neobično. Funkcija izračunava centroid indeksa – „prosječnu datoteku“ projekta – zatim mjeri koliko svaka od njih odstupa. Z-rezultat veći od 2 signalizira datoteku koja ne nalikuje ničem drugom: ponekad je to dio koda generiran ili kopiran izvana, ponekad jednostavno jedina datoteka napisana u starom stilu. U oba slučaja, to je dobar kandidat za pregled.

def detect_outliers(code_files, embeddings, threshold=2.0):
    """Detect atypical code files."""
    # Calculate the centroid (mean vector)
    centroid = embeddings.mean(axis=0)

    # Distance of each file to the centroid
    distances = np.linalg.norm(embeddings - centroid, axis=1)

    # Files beyond N standard deviations
    mean_dist = distances.mean()
    std_dist = distances.std()

    outliers = []
    for i, dist in enumerate(distances):
        z_score = (dist - mean_dist) / std_dist
        if z_score > threshold:
            outliers.append({
                "path": code_files[i]["path"],
                "z_score": float(z_score),
            })

    outliers.sort(key=lambda x: x["z_score"], reverse=True)
    return outliers

outliers = detect_outliers(code_files, embeddings)
print(f"{len(outliers)} atypical files:")
for o in outliers:
    print(f"  z={o['z_score']:.2f} : {o['path']}")

Zapamti da „atipično“ ne znači „loše“. Alat ti daje popis datoteka koje trebaš pogledati, a ne presudu: to je polazište za ljudski pregled, nikada metrika za prikaz na nadzornoj ploči kvalitete.

Ključne točke

  • Ugradnje koda omogućuju automatsko grupiranje po funkcionalnosti
  • Otkrivanje duplikata koristi prag kosinusne sličnosti (0,92–0,95)
  • Asistent za kod kombinira semantičko pretraživanje s LLM-om za kodni RAG
  • Atipične datoteke (outliers) mogu signalizirati kod koji treba pregled
  • DBSCAN je poželjniji od K-Meansa kada broj grupa nije poznat