Create portfolio project for generative ai. Project is started.

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.env

.python-version

@@ -0,0 +1 @@
+3.10

app/config.py

@@ -0,0 +1,27 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    # Ollama
+    ollama_base_url: str = "http://localhost:11434"
+    ollama_model: str = "llama3.1"
+    
+    # Qdrant
+    qdrant_host: str = "localhost"
+    qdrant_port: int = 6333
+    qdrant_collection_name: str = "documents"
+    
+    # Embeddings
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"
+    embedding_dimension: int = 384
+    
+    # App
+    app_host: str = "0.0.0.0"
+    app_port: int = 8000
+    
+    class Config:
+        env_file = ".env"
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()

app/core/embeddings.py

@@ -0,0 +1,17 @@
+from sentence_transformers import SentenceTransformer
+from typing import List
+
+class EmbeddingGenerator:
+    def __init__(self, model_name: str):
+        self.model = SentenceTransformer(model_name)
+        self.dimension = self.model.get_sentence_embedding_dimension()
+    
+    def generate(self, texts: List[str]) -> List[List[float]]:
+        """Generate embeddings for a list of texts"""
+        embeddings = self.model.encode(texts, convert_to_numpy=True)
+        return embeddings.tolist()
+    
+    def generate_single(self, text: str) -> List[float]:
+        """Generate embedding for a single text"""
+        embedding = self.model.encode([text], convert_to_numpy=True)
+        return embedding[0].tolist()

app/core/llm.py

@@ -0,0 +1,43 @@
+from langchain_ollama import ChatOllama
+try:
+    from langchain.prompts import PromptTemplate
+except ImportError:
+    from langchain_core.prompts import PromptTemplate
+
+from langchain_core.output_parsers import StrOutputParser
+
+class OllamaLLM:
+    def __init__(self, base_url: str, model: str):
+        self.llm = ChatOllama(
+            base_url=base_url,
+            model=model,
+            temperature=0.2,  # Lower for more factual responses
+        )
+        
+        # RAG-specific prompt template
+        self.prompt_template = PromptTemplate(
+            template="""You are a helpful AI assistant. Use the following context to answer the question accurately and concisely.
+
+Context:
+{context}
+
+Question: {question}
+
+Instructions:
+- Answer based ONLY on the provided context
+- If the answer is not in the context, say "I don't have enough information to answer that"
+- Keep your answer clear and concise (max 3-5 sentences)
+- Cite specific parts of the context when relevant
+
+Answer:""",
+            input_variables=["context", "question"]
+        )
+        
+        self.chain = self.prompt_template | self.llm | StrOutputParser()
+    
+    def generate(self, question: str, context: str) -> str:
+        """Generate answer using RAG context"""
+        return self.chain.invoke({
+            "question": question,
+            "context": context
+        })

app/core/vector_store.py

@@ -0,0 +1,59 @@
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct
+from typing import List, Dict
+import uuid
+
+class VectorStore:
+    def __init__(self, host: str, port: int, collection_name: str, vector_size: int):
+        self.client = QdrantClient(host=host, port=port)
+        self.collection_name = collection_name
+        self.vector_size = vector_size
+        self._ensure_collection()
+    
+    def _ensure_collection(self):
+        """Create collection if it doesn't exist"""
+        collections = self.client.get_collections().collections
+        collection_names = [col.name for col in collections]
+        
+        if self.collection_name not in collection_names:
+            self.client.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=VectorParams(
+                    size=self.vector_size,
+                    distance=Distance.COSINE
+                )
+            )
+    
+    def add_documents(self, texts: List[str], embeddings: List[List[float]], 
+                     metadata: List[Dict] = None):
+        """Add documents to vector store"""
+        points = []
+        for idx, (text, embedding) in enumerate(zip(texts, embeddings)):
+            point_id = str(uuid.uuid4())
+            payload = {"text": text}
+            if metadata and idx < len(metadata):
+                payload.update(metadata[idx])
+            
+            points.append(
+                PointStruct(
+                    id=point_id,
+                    vector=embedding,
+                    payload=payload
+                )
+            )
+        
+        self.client.upsert(
+            collection_name=self.collection_name,
+            points=points
+        )
+    
+    def search(self, query_embedding: List[float], limit: int = 5, 
+              score_threshold: float = 0.7):
+        """Search for similar documents"""
+        results = self.client.search(
+            collection_name=self.collection_name,
+            query_vector=query_embedding,
+            limit=limit,
+            score_threshold=score_threshold
+        )
+        return results

app/main.py

@@ -0,0 +1,102 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from app.config import get_settings
+from app.core.embeddings import EmbeddingGenerator
+from app.core.vector_store import VectorStore
+from app.core.llm import OllamaLLM
+from app.services.document_processor import DocumentProcessor
+from app.services.rag_chain import RAGChain
+from app.models.schemas import QueryRequest, QueryResponse, IngestResponse
+import tempfile
+import os
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="RAG Portfolio Project",
+    description="Production-grade Retrieval-Augmented Generation system",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize components
+settings = get_settings()
+
+embedding_generator = EmbeddingGenerator(settings.embedding_model)
+vector_store = VectorStore(
+    host=settings.qdrant_host,
+    port=settings.qdrant_port,
+    collection_name=settings.qdrant_collection_name,
+    vector_size=embedding_generator.dimension
+)
+llm = OllamaLLM(settings.ollama_base_url, settings.ollama_model)
+document_processor = DocumentProcessor()
+
+rag_chain = RAGChain(embedding_generator, vector_store, llm)
+
+@app.get("/")
+async def root():
+    return {
+        "message": "RAG Portfolio Project API",
+        "status": "running",
+        "docs": "/docs"
+    }
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "ollama_connected": True}
+
+@app.post("/ingest/file", response_model=IngestResponse)
+async def ingest_file(file: UploadFile = File(...)):
+    """Upload and ingest a document into the RAG system"""
+    try:
+        # Save uploaded file temporarily
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file.filename) as tmp:
+            content = await file.read()
+            tmp.write(content)
+            tmp_path = tmp.name
+        
+        # Process document
+        chunks = document_processor.process_document(tmp_path)
+        
+        # Ingest into RAG system
+        result = rag_chain.ingest_documents(chunks)
+        
+        # Clean up
+        os.unlink(tmp_path)
+        
+        return IngestResponse(**result, message=f"Successfully ingested {file.filename}")
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/query", response_model=QueryResponse)
+async def query(request: QueryRequest):
+    """Query the RAG system"""
+    try:
+        result = rag_chain.query(request.question, request.top_k)
+        return QueryResponse(**result)
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/reset")
+async def reset_collection():
+    """Reset the vector collection (delete all documents)"""
+    try:
+        vector_store.client.delete_collection(settings.qdrant_collection_name)
+        vector_store._ensure_collection()
+        return {"status": "success", "message": "Collection reset successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host=settings.app_host, port=settings.app_port)

app/models/schemas.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class DocumentUpload(BaseModel):
+    filename: str
+    content: str
+
+class QueryRequest(BaseModel):
+    question: str
+    top_k: Optional[int] = 5
+
+class SourceInfo(BaseModel):
+    source: str
+    score: float
+    chunk_index: int
+
+class QueryResponse(BaseModel):
+    question: str
+    answer: str
+    sources: List[SourceInfo]
+    context_used: int
+
+class IngestResponse(BaseModel):
+    status: str
+    documents_ingested: int
+    message: Optional[str] = None

app/services/document_processor.py

@@ -0,0 +1,64 @@
+from typing import List, Dict
+from pathlib import Path
+import pypdf
+from docx import Document
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+
+class DocumentProcessor:
+    def __init__(self, chunk_size: int = 500, chunk_overlap: int = 50):
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""]
+        )
+    
+    def load_pdf(self, file_path: str) -> str:
+        """Load text from PDF"""
+        with open(file_path, 'rb') as file:
+            reader = pypdf.PdfReader(file)
+            text = ""
+            for page in reader.pages:
+                text += page.extract_text()
+        return text
+    
+    def load_docx(self, file_path: str) -> str:
+        """Load text from DOCX"""
+        doc = Document(file_path)
+        return "\n".join([paragraph.text for paragraph in doc.paragraphs])
+    
+    def load_txt(self, file_path: str) -> str:
+        """Load text from TXT"""
+        with open(file_path, 'r', encoding='utf-8') as file:
+            return file.read()
+    
+    def process_document(self, file_path: str) -> List[Dict]:
+        """Process document and return chunks with metadata"""
+        path = Path(file_path)
+        
+        # Load based on extension
+        if path.suffix == '.pdf':
+            text = self.load_pdf(file_path)
+        elif path.suffix == '.docx':
+            text = self.load_docx(file_path)
+        elif path.suffix == '.txt':
+            text = self.load_txt(file_path)
+        else:
+            raise ValueError(f"Unsupported file type: {path.suffix}")
+        
+        # Split into chunks
+        chunks = self.text_splitter.split_text(text)
+        
+        # Add metadata
+        chunk_data = []
+        for idx, chunk in enumerate(chunks):
+            chunk_data.append({
+                "text": chunk,
+                "metadata": {
+                    "source": path.name,
+                    "chunk_index": idx,
+                    "total_chunks": len(chunks)
+                }
+            })
+        
+        return chunk_data

app/services/rag_chain.py

@@ -0,0 +1,67 @@
+from app.core.embeddings import EmbeddingGenerator
+from app.core.vector_store import VectorStore
+from app.core.llm import OllamaLLM
+from typing import List, Dict
+
+class RAGChain:
+    def __init__(
+        self,
+        embedding_generator: EmbeddingGenerator,
+        vector_store: VectorStore,
+        llm: OllamaLLM
+    ):
+        self.embedding_generator = embedding_generator
+        self.vector_store = vector_store
+        self.llm = llm
+    
+    def ingest_documents(self, documents: List[Dict]):
+        """Ingest documents into vector store"""
+        texts = [doc["text"] for doc in documents]
+        metadata = [doc["metadata"] for doc in documents]
+        
+        # Generate embeddings
+        embeddings = self.embedding_generator.generate(texts)
+        
+        # Store in vector database
+        self.vector_store.add_documents(texts, embeddings, metadata)
+        
+        return {"status": "success", "documents_ingested": len(documents)}
+    
+    def query(self, question: str, top_k: int = 5) -> Dict:
+        """Query the RAG system"""
+        # Generate query embedding
+        query_embedding = self.embedding_generator.generate_single(question)
+        
+        # Retrieve relevant documents
+        search_results = self.vector_store.search(
+            query_embedding,
+            limit=top_k,
+            score_threshold=0.6
+        )
+        
+        # Format context from retrieved documents
+        context_parts = []
+        sources = []
+        
+        for result in search_results:
+            context_parts.append(result.payload["text"])
+            sources.append({
+                "source": result.payload.get("source", "unknown"),
+                "score": result.score,
+                "chunk_index": result.payload.get("chunk_index", 0)
+            })
+        
+        context = "\n\n".join(context_parts)
+        
+        # Generate answer using LLM
+        if not context:
+            answer = "I don't have any relevant information to answer this question."
+        else:
+            answer = self.llm.generate(question, context)
+        
+        return {
+            "question": question,
+            "answer": answer,
+            "sources": sources,
+            "context_used": len(search_results)
+        }

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from generative-ai-portfolio-project!")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "generative-ai-portfolio-project"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "fastapi>=0.119.1",
+    "langchain>=1.0.2",
+    "langchain-community>=0.4",
+    "langchain-ollama>=1.0.0",
+    "langchain-text-splitters>=1.0.0",
+    "pypdf>=6.1.3",
+    "python-docx>=1.2.0",
+    "python-multipart>=0.0.20",
+    "qdrant-client>=1.15.1",
+    "sentence-transformers>=5.1.2",
+    "unstructured>=0.18.15",
+    "uvicorn>=0.38.0",
+]
+
+[dependency-groups]
+dev = [
+    "black>=25.9.0",
+    "pytest>=8.4.2",
+    "ruff>=0.14.1",
+]