Flat Chunk/Vector Retrieval (Tier 1)

pip install qdrant-client openai

pip install qdrant-client google-genai
export GEMINI_API_KEY="..."

pip install qdrant-client openai anthropic
# Anthropic does not provide an embeddings model.
# Use OpenAI for embeddings, Anthropic for generation.

pip install qdrant-client huggingface_hub openai
# huggingface_hub for embeddings, openai for the chat-compatible router

pip install qdrant-client openai
export GITHUB_TOKEN="gho_..."

pip install qdrant-client ollama
# Install local Ollama from ollama.com/download, then run:
ollama pull nomic-embed-text:latest
ollama pull qwen3.5:latest

pip install qdrant-client ollama
# Install local Ollama from ollama.com/download, then run:
ollama pull nomic-embed-text:latest
export OLLAMA_API_KEY="..."
export OLLAMA_MODEL="gpt-oss:20b"
# This path uses local Ollama for embeddings and Ollama Cloud for generation.

# retrieval/embed_and_store.py
"""Embed chunks and store them in a local Qdrant collection."""
import json
from pathlib import Path
from openai import OpenAI
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

CHUNKS_PATH = Path("retrieval/chunks.jsonl")
COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "text-embedding-3-small"
EMBEDDING_DIM = 1536
BATCH_SIZE = 50

client = OpenAI()
qdrant = QdrantClient(path="retrieval/qdrant_data")


def load_chunks() -> list[dict]:
    """Load chunk records from the JSONL file.

    Returns:
        list[dict]: Chunk payloads ready for embedding and storage.
    """
    chunks = []
    with open(CHUNKS_PATH) as f:
        for line in f:
            if line.strip():
                chunks.append(json.loads(line))
    return chunks


def embed_texts(texts: list[str]) -> list[list[float]]:
    """Embed a batch of chunk texts with the configured provider model.

    Args:
        texts: Chunk texts to convert into embedding vectors.

    Returns:
        list[list[float]]: Embedding vectors aligned with the input order.
    """
    response = client.embeddings.create(model=EMBEDDING_MODEL, input=texts)
    return [item.embedding for item in response.data]


def create_collection():
    """Create or recreate the Qdrant collection used for naive retrieval.

    Returns:
        None
    """
    collections = [c.name for c in qdrant.get_collections().collections]
    if COLLECTION_NAME in collections:
        qdrant.delete_collection(COLLECTION_NAME)
        print(f"Deleted existing collection '{COLLECTION_NAME}'")
    qdrant.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=EMBEDDING_DIM, distance=Distance.COSINE),
    )
    print(f"Created collection '{COLLECTION_NAME}'")


def embed_and_store():
    """Embed all indexed chunks and upsert them into Qdrant.

    Returns:
        None
    """
    chunks = load_chunks()
    create_collection()
    for batch_start in range(0, len(chunks), BATCH_SIZE):
        batch = chunks[batch_start:batch_start + BATCH_SIZE]
        texts = [c["text"] for c in batch]
        embeddings = embed_texts(texts)
        points = [
            PointStruct(
                id=batch_start + i, vector=embedding,
                payload={"chunk_id": chunk["chunk_id"], "file_path": chunk["file_path"],
                         "chunk_index": chunk["chunk_index"], "total_chunks": chunk["total_chunks"],
                         "text": chunk["text"]},
            )
            for i, (chunk, embedding) in enumerate(zip(batch, embeddings))
        ]
        qdrant.upsert(collection_name=COLLECTION_NAME, points=points)
        print(f"  Stored {batch_start + len(batch)}/{len(chunks)} chunks")
    print(f"\nDone. {len(chunks)} chunks embedded and stored in '{COLLECTION_NAME}'")


if __name__ == "__main__":
    embed_and_store()

# retrieval/embed_and_store.py
"""Embed chunks and store them in a local Qdrant collection."""
import json
from pathlib import Path
from google import genai
from google.genai import types
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

CHUNKS_PATH = Path("retrieval/chunks.jsonl")
COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "gemini-embedding-001"
EMBEDDING_DIM = 768
BATCH_SIZE = 50

client = genai.Client()
qdrant = QdrantClient(path="retrieval/qdrant_data")


def load_chunks() -> list[dict]:
    """Load chunk records from the JSONL file.

    Returns:
        list[dict]: Chunk payloads ready for embedding and storage.
    """
    chunks = []
    with open(CHUNKS_PATH) as f:
        for line in f:
            if line.strip():
                chunks.append(json.loads(line))
    return chunks


def embed_texts(texts: list[str]) -> list[list[float]]:
    """Embed a batch of chunk texts with the configured provider model.

    Args:
        texts: Chunk texts to convert into embedding vectors.

    Returns:
        list[list[float]]: Embedding vectors aligned with the input order.
    """
    response = client.models.embed_content(
        model=EMBEDDING_MODEL,
        contents=texts,
        config=types.EmbedContentConfig(
            task_type="RETRIEVAL_DOCUMENT",
            output_dimensionality=EMBEDDING_DIM,
        ),
    )
    return [item.values for item in response.embeddings]


def create_collection():
    """Create or recreate the Qdrant collection used for naive retrieval.

    Returns:
        None
    """
    collections = [c.name for c in qdrant.get_collections().collections]
    if COLLECTION_NAME in collections:
        qdrant.delete_collection(COLLECTION_NAME)
        print(f"Deleted existing collection '{COLLECTION_NAME}'")
    qdrant.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=EMBEDDING_DIM, distance=Distance.COSINE),
    )
    print(f"Created collection '{COLLECTION_NAME}'")


def embed_and_store():
    """Embed all indexed chunks and upsert them into Qdrant.

    Returns:
        None
    """
    chunks = load_chunks()
    create_collection()
    for batch_start in range(0, len(chunks), BATCH_SIZE):
        batch = chunks[batch_start:batch_start + BATCH_SIZE]
        texts = [c["text"] for c in batch]
        embeddings = embed_texts(texts)
        points = [
            PointStruct(
                id=batch_start + i, vector=embedding,
                payload={"chunk_id": chunk["chunk_id"], "file_path": chunk["file_path"],
                         "chunk_index": chunk["chunk_index"], "total_chunks": chunk["total_chunks"],
                         "text": chunk["text"]},
            )
            for i, (chunk, embedding) in enumerate(zip(batch, embeddings))
        ]
        qdrant.upsert(collection_name=COLLECTION_NAME, points=points)
        print(f"  Stored {batch_start + len(batch)}/{len(chunks)} chunks")
    print(f"\nDone. {len(chunks)} chunks embedded and stored in '{COLLECTION_NAME}'")


if __name__ == "__main__":
    embed_and_store()

# retrieval/embed_and_store.py
"""Embed chunks and store them in a local Qdrant collection.
Anthropic does not provide an embeddings model. This script uses
OpenAI for embeddings. Use Anthropic for generation in naive_retrieve.py.
"""
import json
from pathlib import Path
from openai import OpenAI
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

CHUNKS_PATH = Path("retrieval/chunks.jsonl")
COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "text-embedding-3-small"
EMBEDDING_DIM = 1536
BATCH_SIZE = 50

# OpenAI for embeddings only
client = OpenAI()
qdrant = QdrantClient(path="retrieval/qdrant_data")


def load_chunks() -> list[dict]:
    """Load chunk records from the JSONL file.

    Returns:
        list[dict]: Chunk payloads ready for embedding and storage.
    """
    chunks = []
    with open(CHUNKS_PATH) as f:
        for line in f:
            if line.strip():
                chunks.append(json.loads(line))
    return chunks


def embed_texts(texts: list[str]) -> list[list[float]]:
    """Embed a batch of chunk texts with the configured provider model.

    Args:
        texts: Chunk texts to convert into embedding vectors.

    Returns:
        list[list[float]]: Embedding vectors aligned with the input order.
    """
    response = client.embeddings.create(model=EMBEDDING_MODEL, input=texts)
    return [item.embedding for item in response.data]


def create_collection():
    """Create or recreate the Qdrant collection used for naive retrieval.

    Returns:
        None
    """
    collections = [c.name for c in qdrant.get_collections().collections]
    if COLLECTION_NAME in collections:
        qdrant.delete_collection(COLLECTION_NAME)
        print(f"Deleted existing collection '{COLLECTION_NAME}'")
    qdrant.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=EMBEDDING_DIM, distance=Distance.COSINE),
    )
    print(f"Created collection '{COLLECTION_NAME}'")


def embed_and_store():
    """Embed all indexed chunks and upsert them into Qdrant.

    Returns:
        None
    """
    chunks = load_chunks()
    create_collection()
    for batch_start in range(0, len(chunks), BATCH_SIZE):
        batch = chunks[batch_start:batch_start + BATCH_SIZE]
        texts = [c["text"] for c in batch]
        embeddings = embed_texts(texts)
        points = [
            PointStruct(
                id=batch_start + i, vector=embedding,
                payload={"chunk_id": chunk["chunk_id"], "file_path": chunk["file_path"],
                         "chunk_index": chunk["chunk_index"], "total_chunks": chunk["total_chunks"],
                         "text": chunk["text"]},
            )
            for i, (chunk, embedding) in enumerate(zip(batch, embeddings))
        ]
        qdrant.upsert(collection_name=COLLECTION_NAME, points=points)
        print(f"  Stored {batch_start + len(batch)}/{len(chunks)} chunks")
    print(f"\nDone. {len(chunks)} chunks embedded and stored in '{COLLECTION_NAME}'")


if __name__ == "__main__":
    embed_and_store()

# retrieval/embed_and_store.py
"""Embed chunks and store them in a local Qdrant collection."""
import json
import os
from pathlib import Path
from huggingface_hub import InferenceClient
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

CHUNKS_PATH = Path("retrieval/chunks.jsonl")
COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
EMBEDDING_DIM = 384
BATCH_SIZE = 50

client = InferenceClient(token=os.environ["HF_TOKEN"])
qdrant = QdrantClient(path="retrieval/qdrant_data")


def load_chunks() -> list[dict]:
    """Load chunk records from the JSONL file.

    Returns:
        list[dict]: Chunk payloads ready for embedding and storage.
    """
    chunks = []
    with open(CHUNKS_PATH) as f:
        for line in f:
            if line.strip():
                chunks.append(json.loads(line))
    return chunks


def embed_texts(texts: list[str]) -> list[list[float]]:
    """Embed a batch of chunk texts with the configured provider model.

    Args:
        texts: Chunk texts to convert into embedding vectors.

    Returns:
        list[list[float]]: Embedding vectors aligned with the input order.
    """
    # feature_extraction accepts a single string; call per-text
    embeddings = []
    for text in texts:
        vec = client.feature_extraction(text, model=EMBEDDING_MODEL)
        embeddings.append(vec.tolist() if hasattr(vec, "tolist") else vec)
    return embeddings


def create_collection():
    """Create or recreate the Qdrant collection used for naive retrieval.

    Returns:
        None
    """
    collections = [c.name for c in qdrant.get_collections().collections]
    if COLLECTION_NAME in collections:
        qdrant.delete_collection(COLLECTION_NAME)
        print(f"Deleted existing collection '{COLLECTION_NAME}'")
    qdrant.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=EMBEDDING_DIM, distance=Distance.COSINE),
    )
    print(f"Created collection '{COLLECTION_NAME}'")


def embed_and_store():
    """Embed all indexed chunks and upsert them into Qdrant.

    Returns:
        None
    """
    chunks = load_chunks()
    create_collection()
    for batch_start in range(0, len(chunks), BATCH_SIZE):
        batch = chunks[batch_start:batch_start + BATCH_SIZE]
        texts = [c["text"] for c in batch]
        embeddings = embed_texts(texts)
        points = [
            PointStruct(
                id=batch_start + i, vector=embedding,
                payload={"chunk_id": chunk["chunk_id"], "file_path": chunk["file_path"],
                         "chunk_index": chunk["chunk_index"], "total_chunks": chunk["total_chunks"],
                         "text": chunk["text"]},
            )
            for i, (chunk, embedding) in enumerate(zip(batch, embeddings))
        ]
        qdrant.upsert(collection_name=COLLECTION_NAME, points=points)
        print(f"  Stored {batch_start + len(batch)}/{len(chunks)} chunks")
    print(f"\nDone. {len(chunks)} chunks embedded and stored in '{COLLECTION_NAME}'")


if __name__ == "__main__":
    embed_and_store()

import os
from openai import OpenAI

# Same as the OpenAI embed_and_store.py file,
# but point the client at GitHub Models.
EMBEDDING_MODEL = "openai/text-embedding-3-small"
EMBEDDING_DIM = 1536

client = OpenAI(
    base_url="https://models.github.ai/inference",
    api_key=os.environ["GITHUB_TOKEN"],
    default_headers={
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2026-03-10",
    },
)
# Keep the rest of the OpenAI file unchanged:
# same Qdrant collection lifecycle, same batching,
# same stored payload fields.

# retrieval/embed_and_store.py
"""Embed chunks and store them in a local Qdrant collection."""
import json
from pathlib import Path
from ollama import Client
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

CHUNKS_PATH = Path("retrieval/chunks.jsonl")
COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "nomic-embed-text:latest"
EMBEDDING_DIM = 768
BATCH_SIZE = 50

# Run `ollama pull nomic-embed-text:latest` first.
client = Client(host="http://localhost:11434")
qdrant = QdrantClient(path="retrieval/qdrant_data")


def load_chunks() -> list[dict]:
    """Load chunk records from the JSONL file.

    Returns:
        list[dict]: Chunk payloads ready for embedding and storage.
    """
    chunks = []
    with open(CHUNKS_PATH) as f:
        for line in f:
            if line.strip():
                chunks.append(json.loads(line))
    return chunks


def embed_texts(texts: list[str]) -> list[list[float]]:
    """Embed a batch of chunk texts with the configured provider model.

    Args:
        texts: Chunk texts to convert into embedding vectors.

    Returns:
        list[list[float]]: Embedding vectors aligned with the input order.
    """
    embeddings = []
    for text in texts:
        response = client.embed(model=EMBEDDING_MODEL, input=text)
        embeddings.append(response.embeddings[0])
    return embeddings


def create_collection():
    """Create or recreate the Qdrant collection used for naive retrieval.

    Returns:
        None
    """
    collections = [c.name for c in qdrant.get_collections().collections]
    if COLLECTION_NAME in collections:
        qdrant.delete_collection(COLLECTION_NAME)
        print(f"Deleted existing collection '{COLLECTION_NAME}'")
    qdrant.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=EMBEDDING_DIM, distance=Distance.COSINE),
    )
    print(f"Created collection '{COLLECTION_NAME}'")


def embed_and_store():
    """Embed all indexed chunks and upsert them into Qdrant.

    Returns:
        None
    """
    chunks = load_chunks()
    create_collection()
    for batch_start in range(0, len(chunks), BATCH_SIZE):
        batch = chunks[batch_start:batch_start + BATCH_SIZE]
        texts = [c["text"] for c in batch]
        embeddings = embed_texts(texts)
        points = [
            PointStruct(
                id=batch_start + i, vector=embedding,
                payload={"chunk_id": chunk["chunk_id"], "file_path": chunk["file_path"],
                         "chunk_index": chunk["chunk_index"], "total_chunks": chunk["total_chunks"],
                         "text": chunk["text"]},
            )
            for i, (chunk, embedding) in enumerate(zip(batch, embeddings))
        ]
        qdrant.upsert(collection_name=COLLECTION_NAME, points=points)
        print(f"  Stored {batch_start + len(batch)}/{len(chunks)} chunks")
    print(f"\nDone. {len(chunks)} chunks embedded and stored in '{COLLECTION_NAME}'")


if __name__ == "__main__":
    embed_and_store()

# retrieval/embed_and_store.py
"""Embed chunks and store them for the hybrid Ollama path."""
import json
import os
from pathlib import Path
from ollama import Client
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

CHUNKS_PATH = Path("retrieval/chunks.jsonl")
COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "nomic-embed-text:latest"
EMBEDDING_DIM = 768
BATCH_SIZE = 50

# Hybrid path: local Ollama handles embeddings.
client = Client(host=os.environ.get("OLLAMA_HOST", "http://localhost:11434"))
qdrant = QdrantClient(path="retrieval/qdrant_data")


def load_chunks() -> list[dict]:
    """Load chunk records from the JSONL file.

    Returns:
        list[dict]: Chunk payloads ready for embedding and storage.
    """
    chunks = []
    with open(CHUNKS_PATH) as f:
        for line in f:
            if line.strip():
                chunks.append(json.loads(line))
    return chunks


def embed_texts(texts: list[str]) -> list[list[float]]:
    """Embed a batch of chunk texts with the configured provider model.

    Args:
        texts: Chunk texts to convert into embedding vectors.

    Returns:
        list[list[float]]: Embedding vectors aligned with the input order.
    """
    embeddings = []
    for text in texts:
        response = client.embed(model=EMBEDDING_MODEL, input=text)
        embeddings.append(response.embeddings[0])
    return embeddings


def create_collection():
    """Create or recreate the Qdrant collection used for naive retrieval.

    Returns:
        None
    """
    collections = [c.name for c in qdrant.get_collections().collections]
    if COLLECTION_NAME in collections:
        qdrant.delete_collection(COLLECTION_NAME)
        print(f"Deleted existing collection '{COLLECTION_NAME}'")
    qdrant.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=EMBEDDING_DIM, distance=Distance.COSINE),
    )
    print(f"Created collection '{COLLECTION_NAME}'")


def embed_and_store():
    """Embed all indexed chunks and upsert them into Qdrant.

    Returns:
        None
    """
    chunks = load_chunks()
    create_collection()
    for batch_start in range(0, len(chunks), BATCH_SIZE):
        batch = chunks[batch_start:batch_start + BATCH_SIZE]
        texts = [c["text"] for c in batch]
        embeddings = embed_texts(texts)
        points = [
            PointStruct(
                id=batch_start + i, vector=embedding,
                payload={"chunk_id": chunk["chunk_id"], "file_path": chunk["file_path"],
                         "chunk_index": chunk["chunk_index"], "total_chunks": chunk["total_chunks"],
                         "text": chunk["text"]},
            )
            for i, (chunk, embedding) in enumerate(zip(batch, embeddings))
        ]
        qdrant.upsert(collection_name=COLLECTION_NAME, points=points)
        print(f"  Stored {batch_start + len(batch)}/{len(chunks)} chunks")
    print(f"\nDone. {len(chunks)} chunks embedded and stored in '{COLLECTION_NAME}'")


if __name__ == "__main__":
    embed_and_store()

# retrieval/naive_retrieve.py
"""Naive vector retrieval: embed the query, find top-k chunks, return them."""
import sys
from openai import OpenAI
from qdrant_client import QdrantClient

COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "text-embedding-3-small"
TOP_K = 5

client = OpenAI()
qdrant = QdrantClient(path="retrieval/qdrant_data")

SYSTEM_PROMPT = (
    "You are a code assistant. Answer the question using ONLY the "
    "retrieved code context below. If the context doesn't contain "
    "enough information, say so."
)


def retrieve(query: str, top_k: int = TOP_K) -> list[dict]:
    """Retrieve the top matching chunks for a query.

    Args:
        query: Natural-language or code query to embed and search.
        top_k: Number of top-ranked chunks to return.

    Returns:
        list[dict]: Retrieved chunk metadata with scores and text previews.
    """
    response = client.embeddings.create(model=EMBEDDING_MODEL, input=[query])
    query_vector = response.data[0].embedding
    results = qdrant.query_points(
        collection_name=COLLECTION_NAME, query=query_vector, limit=top_k,
    )
    return [
        {"file_path": hit.payload["file_path"], "chunk_id": hit.payload["chunk_id"],
         "score": round(hit.score, 4), "text": hit.payload["text"]}
        for hit in results.points
    ]


def retrieve_and_answer(question: str, model: str = "gpt-4o-mini") -> dict:
    """Retrieve evidence and generate an answer from the naive vector baseline.

    Args:
        question: User question to answer from retrieved chunks.
        model: Generation model used for the answer step.

    Returns:
        dict: Final answer, supporting chunks, and retrieval-method metadata.
    """
    chunks = retrieve(question)
    context = "\n\n---\n\n".join(
        f"File: {c['file_path']} (score: {c['score']})\n{c['text']}" for c in chunks
    )
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": f"{SYSTEM_PROMPT}\n\nRetrieved context:\n{context}"},
            {"role": "user", "content": question},
        ],
        temperature=0,
    )
    return {"answer": response.choices[0].message.content, "chunks_used": chunks,
            "retrieval_method": "naive_vector"}


if __name__ == "__main__":
    question = sys.argv[1] if len(sys.argv) > 1 else "What are the main modules in this repository?"
    print(f"Question: {question}\n")
    chunks = retrieve(question)
    print(f"Top {len(chunks)} chunks:")
    for c in chunks:
        print(f"  [{c['score']}] {c['file_path']}: {c['text'][:80]}...")
    print()
    result = retrieve_and_answer(question)
    print(f"Answer:\n{result['answer']}")

# retrieval/naive_retrieve.py
"""Naive vector retrieval using Gemini for embeddings and generation."""
import sys
from google import genai
from google.genai import types
from qdrant_client import QdrantClient

COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "gemini-embedding-001"
GENERATION_MODEL = "gemini-2.5-flash"
EMBEDDING_DIM = 768
TOP_K = 5

client = genai.Client()
qdrant = QdrantClient(path="retrieval/qdrant_data")

SYSTEM_PROMPT = (
    "You are a code assistant. Answer the question using ONLY the "
    "retrieved code context below. If the context doesn't contain "
    "enough information, say so."
)


def retrieve(query: str, top_k: int = TOP_K) -> list[dict]:
    """Retrieve the top matching chunks for a query.

    Args:
        query: Natural-language or code query to embed and search.
        top_k: Number of top-ranked chunks to return.

    Returns:
        list[dict]: Retrieved chunk metadata with scores and text previews.
    """
    response = client.models.embed_content(
        model=EMBEDDING_MODEL,
        contents=[query],
        config=types.EmbedContentConfig(
            task_type="RETRIEVAL_QUERY",
            output_dimensionality=EMBEDDING_DIM,
        ),
    )
    query_vector = response.embeddings[0].values
    results = qdrant.query_points(
        collection_name=COLLECTION_NAME, query=query_vector, limit=top_k,
    )
    return [
        {"file_path": hit.payload["file_path"], "chunk_id": hit.payload["chunk_id"],
         "score": round(hit.score, 4), "text": hit.payload["text"]}
        for hit in results.points
    ]


def retrieve_and_answer(question: str, model: str = GENERATION_MODEL) -> dict:
    """Retrieve evidence and generate an answer from the naive vector baseline.

    Args:
        question: User question to answer from retrieved chunks.
        model: Generation model used for the answer step.

    Returns:
        dict: Final answer, supporting chunks, and retrieval-method metadata.
    """
    chunks = retrieve(question)
    context = "\n\n---\n\n".join(
        f"File: {c['file_path']} (score: {c['score']})\n{c['text']}" for c in chunks
    )
    response = client.models.generate_content(
        model=model,
        contents=question,
        config=types.GenerateContentConfig(
            system_instruction=f"{SYSTEM_PROMPT}\n\nRetrieved context:\n{context}",
            temperature=0,
        ),
    )
    return {"answer": response.text, "chunks_used": chunks,
            "retrieval_method": "naive_vector"}


if __name__ == "__main__":
    question = sys.argv[1] if len(sys.argv) > 1 else "What are the main modules in this repository?"
    print(f"Question: {question}\n")
    chunks = retrieve(question)
    print(f"Top {len(chunks)} chunks:")
    for c in chunks:
        print(f"  [{c['score']}] {c['file_path']}: {c['text'][:80]}...")
    print()
    result = retrieve_and_answer(question)
    print(f"Answer:\n{result['answer']}")

# retrieval/naive_retrieve.py
"""Naive vector retrieval.

Anthropic does not provide an embeddings model, so this script
uses OpenAI for embeddings and Anthropic for generation. This
mixed-provider pattern is normal in AI engineering.
"""
import sys
from openai import OpenAI
from anthropic import Anthropic
from qdrant_client import QdrantClient

COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "text-embedding-3-small"
TOP_K = 5

# Anthropic has no embeddings API. Use OpenAI for embeddings here.
embed_client = OpenAI()
gen_client = Anthropic()
qdrant = QdrantClient(path="retrieval/qdrant_data")

SYSTEM_PROMPT = (
    "You are a code assistant. Answer the question using ONLY the "
    "retrieved code context below. If the context doesn't contain "
    "enough information, say so."
)


def retrieve(query: str, top_k: int = TOP_K) -> list[dict]:
    """Retrieve the top matching chunks for a query.

    Args:
        query: Natural-language or code query to embed and search.
        top_k: Number of top-ranked chunks to return.

    Returns:
        list[dict]: Retrieved chunk metadata with scores and text previews.
    """
    response = embed_client.embeddings.create(model=EMBEDDING_MODEL, input=[query])
    query_vector = response.data[0].embedding
    results = qdrant.query_points(
        collection_name=COLLECTION_NAME, query=query_vector, limit=top_k,
    )
    return [
        {"file_path": hit.payload["file_path"], "chunk_id": hit.payload["chunk_id"],
         "score": round(hit.score, 4), "text": hit.payload["text"]}
        for hit in results.points
    ]


def retrieve_and_answer(question: str, model: str = "claude-sonnet-4-6") -> dict:
    """Retrieve evidence and generate an answer from the naive vector baseline.

    Args:
        question: User question to answer from retrieved chunks.
        model: Generation model used for the answer step.

    Returns:
        dict: Final answer, supporting chunks, and retrieval-method metadata.
    """
    chunks = retrieve(question)
    context = "\n\n---\n\n".join(
        f"File: {c['file_path']} (score: {c['score']})\n{c['text']}" for c in chunks
    )
    response = gen_client.messages.create(
        model=model,
        max_tokens=1024,
        system=f"{SYSTEM_PROMPT}\n\nRetrieved context:\n{context}",
        messages=[{"role": "user", "content": question}],
    )
    return {"answer": response.content[0].text, "chunks_used": chunks,
            "retrieval_method": "naive_vector"}


if __name__ == "__main__":
    question = sys.argv[1] if len(sys.argv) > 1 else "What are the main modules in this repository?"
    print(f"Question: {question}\n")
    chunks = retrieve(question)
    print(f"Top {len(chunks)} chunks:")
    for c in chunks:
        print(f"  [{c['score']}] {c['file_path']}: {c['text'][:80]}...")
    print()
    result = retrieve_and_answer(question)
    print(f"Answer:\n{result['answer']}")

# retrieval/naive_retrieve.py
"""Naive vector retrieval using Hugging Face for embeddings and generation."""
import os
import sys
from huggingface_hub import InferenceClient
from openai import OpenAI
from qdrant_client import QdrantClient

COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
GENERATION_MODEL = "meta-llama/Llama-3.1-8B-Instruct"
TOP_K = 5

embed_client = InferenceClient(token=os.environ["HF_TOKEN"])
gen_client = OpenAI(
    base_url="https://router.huggingface.co/v1",
    api_key=os.environ["HF_TOKEN"],
)
qdrant = QdrantClient(path="retrieval/qdrant_data")

SYSTEM_PROMPT = (
    "You are a code assistant. Answer the question using ONLY the "
    "retrieved code context below. If the context doesn't contain "
    "enough information, say so."
)


def retrieve(query: str, top_k: int = TOP_K) -> list[dict]:
    """Retrieve the top matching chunks for a query.

    Args:
        query: Natural-language or code query to embed and search.
        top_k: Number of top-ranked chunks to return.

    Returns:
        list[dict]: Retrieved chunk metadata with scores and text previews.
    """
    vec = embed_client.feature_extraction(query, model=EMBEDDING_MODEL)
    query_vector = vec.tolist() if hasattr(vec, "tolist") else vec
    results = qdrant.query_points(
        collection_name=COLLECTION_NAME, query=query_vector, limit=top_k,
    )
    return [
        {"file_path": hit.payload["file_path"], "chunk_id": hit.payload["chunk_id"],
         "score": round(hit.score, 4), "text": hit.payload["text"]}
        for hit in results.points
    ]


def retrieve_and_answer(question: str) -> dict:
    """Retrieve evidence and generate an answer from the naive vector baseline.

    Args:
        question: User question to answer from retrieved chunks.

    Returns:
        dict: Final answer, supporting chunks, and retrieval-method metadata.
    """
    chunks = retrieve(question)
    context = "\n\n---\n\n".join(
        f"File: {c['file_path']} (score: {c['score']})\n{c['text']}" for c in chunks
    )
    response = gen_client.chat.completions.create(
        model=GENERATION_MODEL,
        messages=[
            {"role": "system", "content": f"{SYSTEM_PROMPT}\n\nRetrieved context:\n{context}"},
            {"role": "user", "content": question},
        ],
        temperature=0,
    )
    return {"answer": response.choices[0].message.content, "chunks_used": chunks,
            "retrieval_method": "naive_vector"}


if __name__ == "__main__":
    question = sys.argv[1] if len(sys.argv) > 1 else "What are the main modules in this repository?"
    print(f"Question: {question}\n")
    chunks = retrieve(question)
    print(f"Top {len(chunks)} chunks:")
    for c in chunks:
        print(f"  [{c['score']}] {c['file_path']}: {c['text'][:80]}...")
    print()
    result = retrieve_and_answer(question)
    print(f"Answer:\n{result['answer']}")

import os
from openai import OpenAI

# Same as the OpenAI naive_retrieve.py file,
# but use GitHub Models for both embeddings and generation.
EMBEDDING_MODEL = "openai/text-embedding-3-small"
GENERATION_MODEL = "openai/gpt-4.1"

client = OpenAI(
    base_url="https://models.github.ai/inference",
    api_key=os.environ["GITHUB_TOKEN"],
    default_headers={
        "Accept": "application/vnd.github+json",
        "X-GitHub-Api-Version": "2026-03-10",
    },
)
# Keep the rest of the OpenAI flow unchanged:
# use client.embeddings.create(...) for retrieval,
# client.chat.completions.create(...) for the answer step,
# and log the benchmark with provider="github-models".

# retrieval/naive_retrieve.py
"""Naive vector retrieval using Ollama for embeddings and generation."""
import sys
from ollama import Client
from qdrant_client import QdrantClient

COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "nomic-embed-text:latest"
GENERATION_MODEL = "qwen3.5:latest"
TOP_K = 5

# Run `ollama pull nomic-embed-text:latest && ollama pull qwen3.5:latest` first.
client = Client(host="http://localhost:11434")
qdrant = QdrantClient(path="retrieval/qdrant_data")

SYSTEM_PROMPT = (
    "You are a code assistant. Answer the question using ONLY the "
    "retrieved code context below. If the context doesn't contain "
    "enough information, say so."
)


def retrieve(query: str, top_k: int = TOP_K) -> list[dict]:
    """Retrieve the top matching chunks for a query.

    Args:
        query: Natural-language or code query to embed and search.
        top_k: Number of top-ranked chunks to return.

    Returns:
        list[dict]: Retrieved chunk metadata with scores and text previews.
    """
    response = client.embed(model=EMBEDDING_MODEL, input=query)
    query_vector = response.embeddings[0]
    results = qdrant.query_points(
        collection_name=COLLECTION_NAME, query=query_vector, limit=top_k,
    )
    return [
        {"file_path": hit.payload["file_path"], "chunk_id": hit.payload["chunk_id"],
         "score": round(hit.score, 4), "text": hit.payload["text"]}
        for hit in results.points
    ]


def retrieve_and_answer(question: str) -> dict:
    """Retrieve evidence and generate an answer from the naive vector baseline.

    Args:
        question: User question to answer from retrieved chunks.

    Returns:
        dict: Final answer, supporting chunks, and retrieval-method metadata.
    """
    chunks = retrieve(question)
    context = "\n\n---\n\n".join(
        f"File: {c['file_path']} (score: {c['score']})\n{c['text']}" for c in chunks
    )
    response = client.chat(
        model=GENERATION_MODEL,
        messages=[
            {"role": "system", "content": f"{SYSTEM_PROMPT}\n\nRetrieved context:\n{context}"},
            {"role": "user", "content": question},
        ],
    )
    return {"answer": response.message.content, "chunks_used": chunks,
            "retrieval_method": "naive_vector"}


if __name__ == "__main__":
    question = sys.argv[1] if len(sys.argv) > 1 else "What are the main modules in this repository?"
    print(f"Question: {question}\n")
    chunks = retrieve(question)
    print(f"Top {len(chunks)} chunks:")
    for c in chunks:
        print(f"  [{c['score']}] {c['file_path']}: {c['text'][:80]}...")
    print()
    result = retrieve_and_answer(question)
    print(f"Answer:\n{result['answer']}")

# retrieval/naive_retrieve.py
"""Naive vector retrieval using local Ollama embeddings and Ollama Cloud generation."""
import os
import sys
from ollama import Client
from qdrant_client import QdrantClient

COLLECTION_NAME = "anchor-repo-naive"
EMBEDDING_MODEL = "nomic-embed-text:latest"
GENERATION_MODEL = os.environ.get("OLLAMA_MODEL", "gpt-oss:20b")
TOP_K = 5

# Hybrid path: local Ollama for embeddings, direct Ollama Cloud for generation.
embed_client = Client(host=os.environ.get("OLLAMA_HOST", "http://localhost:11434"))
gen_client = Client(
    host="https://ollama.com",
    headers={"Authorization": "Bearer " + os.environ["OLLAMA_API_KEY"]},
)
qdrant = QdrantClient(path="retrieval/qdrant_data")

SYSTEM_PROMPT = (
    "You are a code assistant. Answer the question using ONLY the "
    "retrieved code context below. If the context doesn't contain "
    "enough information, say so."
)


def retrieve(query: str, top_k: int = TOP_K) -> list[dict]:
    """Retrieve the top matching chunks for a query.

    Args:
        query: Natural-language or code query to embed and search.
        top_k: Number of top-ranked chunks to return.

    Returns:
        list[dict]: Retrieved chunk metadata with scores and text previews.
    """
    response = embed_client.embed(model=EMBEDDING_MODEL, input=query)
    query_vector = response.embeddings[0]
    results = qdrant.query_points(
        collection_name=COLLECTION_NAME, query=query_vector, limit=top_k,
    )
    return [
        {"file_path": hit.payload["file_path"], "chunk_id": hit.payload["chunk_id"],
         "score": round(hit.score, 4), "text": hit.payload["text"]}
        for hit in results.points
    ]


def retrieve_and_answer(question: str, model: str = GENERATION_MODEL) -> dict:
    """Retrieve evidence and generate an answer from the naive vector baseline.

    Args:
        question: User question to answer from retrieved chunks.
        model: Generation model used for the answer step.

    Returns:
        dict: Final answer, supporting chunks, and retrieval-method metadata.
    """
    chunks = retrieve(question)
    context = "\n\n---\n\n".join(
        f"File: {c['file_path']} (score: {c['score']})\n{c['text']}" for c in chunks
    )
    response = gen_client.chat(
        model=model,
        messages=[
            {"role": "system", "content": f"{SYSTEM_PROMPT}\n\nRetrieved context:\n{context}"},
            {"role": "user", "content": question},
        ],
        options={"temperature": 0},
    )
    return {"answer": response.message.content, "chunks_used": chunks,
            "retrieval_method": "naive_vector"}


if __name__ == "__main__":
    question = sys.argv[1] if len(sys.argv) > 1 else "What are the main modules in this repository?"
    print(f"Question: {question}\n")
    chunks = retrieve(question)
    print(f"Top {len(chunks)} chunks:")
    for c in chunks:
        print(f"  [{c['score']}] {c['file_path']}: {c['text'][:80]}...")
    print()
    result = retrieve_and_answer(question)
    print(f"Answer:\n{result['answer']}")