تشغيل RAG للإنتاج الفعلي بذاكرة 6 جيجابايت VRAM: نموذج Qwen3.5 4B مع nomic-embed

# Install Ollama (Linux)
curl -fsSL https://ollama.ai/install.sh | sh

# Pull Qwen3.5 4B Q4_K_M — this is the GGUF quantized version
ollama pull qwen3.5:4b-instruct-q4_K_M

# Pull nomic-embed-text for embeddings
ollama pull nomic-embed-text

# Verify GPU detection
ollama run qwen3.5:4b-instruct-q4_K_M "Hello" 2>&1 | grep -i gpu
# Should show: GPU: NVIDIA ...

# Create a Modelfile for production RAG settings
cat > Modelfile << 'EOF'
FROM qwen3.5:4b-instruct-q4_K_M

# System prompt for constrained RAG responses
SYSTEM """You are a precise knowledge assistant. Answer questions ONLY based on the provided context.
If the answer is not in the context, say exactly: "This information is not in the available documents."
Always cite the document name and section when quoting or paraphrasing.
Be concise. Avoid speculation."""

# Production parameters
PARAMETER temperature 0.1      # low temp for factual tasks
PARAMETER top_p 0.9
PARAMETER num_ctx 8192          # context window
PARAMETER num_predict 512       # max response tokens
PARAMETER repeat_penalty 1.1   # reduce repetition
EOF

ollama create verel-rag -f Modelfile

# Run Qdrant with Docker (persistent storage)
docker run -d \
  --name qdrant \
  -p 6333:6333 \
  -p 6334:6334 \
  -v $(pwd)/qdrant_storage:/qdrant/storage:z \
  qdrant/qdrant:latest

# Verify it's running
curl http://localhost:6333/healthz
# {"status":"ok","time":0.000...}

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader, DirectoryLoader
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct
import ollama
import uuid

# ── Configuration ──────────────────────────────────────────────
CHUNK_SIZE       = 512     # tokens per chunk
CHUNK_OVERLAP    = 64      # overlap to preserve cross-boundary context
EMBED_MODEL      = "nomic-embed-text"
COLLECTION_NAME  = "enterprise_docs"
EMBED_DIM        = 768     # nomic-embed-text output dimension

# ── Initialize Qdrant ──────────────────────────────────────────
qdrant = QdrantClient(host="localhost", port=6333)

# Create collection if it doesn't exist
if COLLECTION_NAME not in [c.name for c in qdrant.get_collections().collections]:
    qdrant.create_collection(
        collection_name=COLLECTION_NAME,
        vectors_config=VectorParams(size=EMBED_DIM, distance=Distance.COSINE),
    )

# ── Text splitter ──────────────────────────────────────────────
splitter = RecursiveCharacterTextSplitter(
    chunk_size=CHUNK_SIZE,
    chunk_overlap=CHUNK_OVERLAP,
    separators=["\n\n", "\n", ". ", "! ", "? ", " ", ""],
)

# ── Embedding function ─────────────────────────────────────────
def embed_texts(texts: list[str]) -> list[list[float]]:
    """Batch embed with nomic-embed-text via Ollama."""
    response = ollama.embed(model=EMBED_MODEL, input=texts)
    return response["embeddings"]

# ── Ingestion ──────────────────────────────────────────────────
def ingest_directory(path: str, namespace: str = "default"):
    """
    Ingest all PDFs from a directory.
    namespace: use for tenant isolation in multi-client deployments
    """
    loader = DirectoryLoader(path, glob="**/*.pdf", loader_cls=PyPDFLoader)
    docs   = loader.load()
    chunks = splitter.split_documents(docs)
    
    print(f"Ingesting {len(chunks)} chunks from {len(docs)} documents...")
    
    # Process in batches of 32 for embedding
    BATCH_SIZE = 32
    points = []
    
    for i in range(0, len(chunks), BATCH_SIZE):
        batch = chunks[i : i + BATCH_SIZE]
        texts = [c.page_content for c in batch]
        vecs  = embed_texts(texts)
        
        for chunk, vec in zip(batch, vecs):
            points.append(PointStruct(
                id=str(uuid.uuid4()),
                vector=vec,
                payload={
                    "text":      chunk.page_content,
                    "source":    chunk.metadata.get("source", "unknown"),
                    "page":      chunk.metadata.get("page", 0),
                    "namespace": namespace,
                }
            ))
    
    qdrant.upsert(collection_name=COLLECTION_NAME, points=points)
    print(f"✓ Ingested {len(points)} vectors")

from openai import OpenAI  # Ollama uses OpenAI-compatible API

# Connect to local Ollama via OpenAI SDK
llm_client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # Ollama doesn't require a real API key
)

def retrieve(query: str, namespace: str = "default", top_k: int = 6) -> list[dict]:
    """Retrieve top-k relevant chunks with namespace filtering."""
    query_vec = embed_texts([query])[0]
    
    results = qdrant.search(
        collection_name=COLLECTION_NAME,
        query_vector=query_vec,
        limit=top_k,
        query_filter={
            "must": [{"key": "namespace", "match": {"value": namespace}}]
        },
        with_payload=True,
        score_threshold=0.6,   # discard low-relevance chunks
    )
    
    return [
        {
            "text":   r.payload["text"],
            "source": r.payload["source"],
            "page":   r.payload["page"],
            "score":  r.score,
        }
        for r in results
    ]

def generate(query: str, namespace: str = "default") -> dict:
    """Full RAG pipeline: retrieve → format context → generate → cite."""
    
    chunks = retrieve(query, namespace)
    
    if not chunks:
        return {
            "answer":   "This information is not in the available documents.",
            "sources":  [],
            "chunks_used": 0,
        }
    
    # Format context with source attribution
    context_parts = []
    for i, c in enumerate(chunks, 1):
        context_parts.append(
            f"[Source {i}: {c['source']}, p.{c['page']}]\n{c['text']}"
        )
    context = "\n\n---\n\n".join(context_parts)
    
    prompt = f"""Answer the following question using ONLY the provided context.
Cite sources using [Source N] notation when referencing specific information.

Context:
{context}

Question: {query}

Answer:"""
    
    response = llm_client.chat.completions.create(
        model="verel-rag",  # our custom Modelfile model
        messages=[{"role": "user", "content": prompt}],
        stream=False,
    )
    
    answer = response.choices[0].message.content
    
    # Extract referenced sources from the answer
    cited_sources = []
    for i, c in enumerate(chunks, 1):
        if f"[Source {i}]" in answer:
            cited_sources.append({
                "index":  i,
                "file":   c["source"],
                "page":   c["page"],
                "score":  round(c["score"], 3),
            })
    
    return {
        "answer":       answer,
        "sources":      cited_sources,
        "chunks_used":  len(chunks),
    }

# Each client gets a unique namespace
# Data is stored in the same collection but isolated by filter
result = qdrant.search(
    collection_name=COLLECTION_NAME,
    query_vector=query_vec,
    query_filter={"must": [{"key": "namespace", "match": {"value": client_id}}]},
    limit=6,
)

from qdrant_client.models import SparseVector, NamedSparseVector
from fastembed import SparseTextEmbedding

sparse_model = SparseTextEmbedding(model_name="Qdrant/bm25")

def hybrid_retrieve(query: str, namespace: str, top_k: int = 6) -> list[dict]:
    # Dense vector (semantic)
    dense_vec = embed_texts([query])[0]
    
    # Sparse vector (BM25 keyword)
    sparse_result = list(sparse_model.query_embed(query))[0]
    sparse_vec = SparseVector(
        indices=sparse_result.indices.tolist(),
        values=sparse_result.values.tolist(),
    )
    
    results = qdrant.query_points(
        collection_name=COLLECTION_NAME,
        prefetch=[
            {"query": dense_vec,  "limit": 20},
            {"query": NamedSparseVector(name="text-sparse", vector=sparse_vec), "limit": 20},
        ],
        query=SparseVector(indices=[], values=[]),  # fusion
        using="rrf",    # Reciprocal Rank Fusion
        limit=top_k,
        query_filter={"must": [{"key": "namespace", "match": {"value": namespace}}]},
    )
    
    return [{"text": r.payload["text"], "source": r.payload["source"], ...} for r in results.points]