Upload 25 files

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+COPY backend/requirements.txt /app/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade pip && \
+	pip install --no-cache-dir -r /app/requirements.txt
+
+COPY backend /app
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn app:app --host 0.0.0.0 --port 7860"]

backend/.dockerignore

@@ -0,0 +1,17 @@
+.git
+.gitignore
+.env
+.venv
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+.mypy_cache/
+.vscode/
+frontend/node_modules/
+frontend/dist/
+instance/
+uploads/
+vectorstores/
+database.db

backend/Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+COPY backend/requirements.txt /app/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade pip && \
+	pip install --no-cache-dir -r /app/requirements.txt
+
+COPY backend /app
+
+EXPOSE 7860
+
+CMD ["sh", "-c", "uvicorn app:app --host 0.0.0.0 --port 7860"]

backend/app.py

@@ -0,0 +1,365 @@
+import os
+from datetime import datetime, timedelta, timezone
+from typing import Generator
+
+from fastapi import Depends, FastAPI, File, HTTPException, UploadFile, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from jose import JWTError, jwt
+from langchain_core.messages import AIMessage, HumanMessage
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+from werkzeug.security import check_password_hash, generate_password_hash
+from werkzeug.utils import secure_filename
+
+try:
+    from .config import Config
+    from .lang_service import create_vectorstore, get_rag_response
+    from .langgraph_service import get_response
+    from .models import Chat, Message, SessionLocal, UploadedFile as ModelUploadedFile, User, init_db
+except ImportError:
+    from config import Config
+    from lang_service import create_vectorstore, get_rag_response
+    from langgraph_service import get_response
+    from models import Chat, Message, SessionLocal, UploadedFile as ModelUploadedFile, User, init_db
+
+
+app = FastAPI(title="AI Chatbot API")
+security = HTTPBearer()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=Config.CORS_ORIGINS,
+    allow_origin_regex=Config.CORS_ORIGIN_REGEX,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+UPLOAD_FOLDER = Config.UPLOAD_DIR
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(Config.VECTORSTORE_DIR, exist_ok=True)
+init_db()
+
+
+class RegisterInput(BaseModel):
+    username: str
+    password: str
+
+
+class LoginInput(BaseModel):
+    username: str
+    password: str
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+
+class UserOut(BaseModel):
+    id: int
+    username: str
+
+
+class ChatOut(BaseModel):
+    id: int
+    user_id: int
+    title: str
+    mode: str
+    is_pinned: bool
+    is_archived: bool
+    created_at: datetime
+
+
+class MessageInput(BaseModel):
+    message: str
+
+
+class MessageOut(BaseModel):
+    id: int
+    chat_id: int
+    role: str
+    content: str
+    timestamp: datetime
+
+
+class UploadedFileOut(BaseModel):
+    id: int
+    chat_id: int
+    filename: str
+    filepath: str
+    uploaded_at: datetime
+
+
+class ChatDetailOut(BaseModel):
+    chat: ChatOut
+    messages: list[MessageOut]
+    files: list[UploadedFileOut]
+
+
+class AboutOut(BaseModel):
+    app_name: str
+    stack: list[str]
+
+
+def get_db() -> Generator[Session, None, None]:
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+def create_access_token(user_id: int) -> str:
+    expire = datetime.now(timezone.utc) + timedelta(minutes=Config.ACCESS_TOKEN_EXPIRE_MINUTES)
+    payload = {"sub": str(user_id), "exp": expire}
+    return jwt.encode(payload, Config.JWT_SECRET_KEY, algorithm="HS256")
+
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    db: Session = Depends(get_db),
+) -> User:
+    token = credentials.credentials
+    try:
+        payload = jwt.decode(token, Config.JWT_SECRET_KEY, algorithms=["HS256"])
+        user_id = int(payload.get("sub"))
+    except (JWTError, TypeError, ValueError) as exc:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token") from exc
+
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
+    return user
+
+
+def chat_to_out(chat: Chat) -> ChatOut:
+    return ChatOut(
+        id=chat.id,
+        user_id=chat.user_id,
+        title=chat.title,
+        mode=chat.mode,
+        is_pinned=chat.is_pinned,
+        is_archived=chat.is_archived,
+        created_at=chat.created_at,
+    )
+
+
+def message_to_out(message: Message) -> MessageOut:
+    return MessageOut(
+        id=message.id,
+        chat_id=message.chat_id,
+        role=message.role,
+        content=message.content,
+        timestamp=message.timestamp,
+    )
+
+
+def file_to_out(uploaded_file: ModelUploadedFile) -> UploadedFileOut:
+    return UploadedFileOut(
+        id=uploaded_file.id,
+        chat_id=uploaded_file.chat_id,
+        filename=uploaded_file.filename,
+        filepath=uploaded_file.filepath,
+        uploaded_at=uploaded_file.uploaded_at,
+    )
+
+
+def get_user_chat_or_404(db: Session, chat_id: int, user_id: int) -> Chat:
+    chat = db.query(Chat).filter(Chat.id == chat_id, Chat.user_id == user_id).first()
+    if not chat:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Chat not found")
+    return chat
+
+
+@app.get("/")
+def root():
+    return {"message": "FastAPI backend is running"}
+
+
+@app.post("/api/auth/register", response_model=UserOut)
+def register(payload: RegisterInput, db: Session = Depends(get_db)):
+    exists = db.query(User).filter(User.username == payload.username).first()
+    if exists:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Username already exists")
+
+    user = User(username=payload.username, password=generate_password_hash(payload.password))
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+
+    return UserOut(id=user.id, username=user.username)
+
+
+@app.post("/api/auth/login", response_model=TokenResponse)
+def login(payload: LoginInput, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.username == payload.username).first()
+    if not user or not check_password_hash(user.password, payload.password):
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
+
+    token = create_access_token(user.id)
+    return TokenResponse(access_token=token)
+
+
+@app.get("/api/auth/me", response_model=UserOut)
+def me(current_user: User = Depends(get_current_user)):
+    return UserOut(id=current_user.id, username=current_user.username)
+
+
+@app.get("/api/chats", response_model=list[ChatOut])
+def list_chats(current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    chats = (
+        db.query(Chat)
+        .filter(Chat.user_id == current_user.id, Chat.is_archived.is_(False))
+        .order_by(Chat.is_pinned.desc(), Chat.created_at.desc())
+        .all()
+    )
+    return [chat_to_out(chat) for chat in chats]
+
+
+@app.post("/api/chats", response_model=ChatOut)
+def create_chat(current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    chat = Chat(user_id=current_user.id, mode="normal")
+    db.add(chat)
+    db.commit()
+    db.refresh(chat)
+    return chat_to_out(chat)
+
+
+@app.get("/api/chats/{chat_id}", response_model=ChatDetailOut)
+def get_chat(chat_id: int, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    chat = get_user_chat_or_404(db, chat_id, current_user.id)
+
+    messages = db.query(Message).filter(Message.chat_id == chat_id).order_by(Message.timestamp).all()
+    files = db.query(ModelUploadedFile).filter(ModelUploadedFile.chat_id == chat_id).all()
+
+    return ChatDetailOut(
+        chat=chat_to_out(chat),
+        messages=[message_to_out(message) for message in messages],
+        files=[file_to_out(uploaded_file) for uploaded_file in files],
+    )
+
+
+@app.post("/api/chats/{chat_id}/messages", response_model=MessageOut)
+def send_message(
+    chat_id: int,
+    payload: MessageInput,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    chat = get_user_chat_or_404(db, chat_id, current_user.id)
+
+    user_input = payload.message.strip()
+    if not user_input:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Message cannot be empty")
+
+    if chat.title == "New Chat":
+        chat.title = " ".join(user_input.split()[:6])
+
+    messages = db.query(Message).filter(Message.chat_id == chat_id).order_by(Message.timestamp).all()
+
+    if chat.mode == "rag":
+        try:
+            ai_text = get_rag_response(chat_id, user_input)
+        except Exception:
+            ai_text = "Error retrieving document context."
+    else:
+        history = []
+        for msg in messages:
+            if msg.role == "user":
+                history.append(HumanMessage(content=msg.content))
+            else:
+                history.append(AIMessage(content=msg.content))
+
+        history.append(HumanMessage(content=user_input))
+        try:
+            ai_response = get_response(history)
+            ai_text = ai_response.content
+        except Exception:
+            ai_text = "AI service is not configured. Please set GROQ_API_KEY on the server."
+
+    db.add(Message(chat_id=chat_id, role="user", content=user_input))
+    ai_message = Message(chat_id=chat_id, role="ai", content=ai_text)
+    db.add(ai_message)
+    db.commit()
+    db.refresh(ai_message)
+
+    return message_to_out(ai_message)
+
+
+@app.post("/api/chats/{chat_id}/upload", response_model=UploadedFileOut)
+async def upload_file(
+    chat_id: int,
+    file: UploadFile = File(...),
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    chat = get_user_chat_or_404(db, chat_id, current_user.id)
+
+    filename = secure_filename(file.filename or "document.txt")
+    if not filename:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Invalid filename")
+
+    filepath = os.path.join(UPLOAD_FOLDER, f"{chat_id}_{filename}")
+
+    content = await file.read()
+    with open(filepath, "wb") as out_file:
+        out_file.write(content)
+
+    try:
+        create_vectorstore(filepath, chat_id)
+    except Exception as exc:
+        if os.path.exists(filepath):
+            os.remove(filepath)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Failed to process file. Upload a text-based document (txt, md, csv, json) or re-save the file as UTF-8.",
+        ) from exc
+
+    uploaded = ModelUploadedFile(chat_id=chat_id, filename=filename, filepath=filepath)
+    chat.mode = "rag"
+
+    db.add(uploaded)
+    db.commit()
+    db.refresh(uploaded)
+
+    return file_to_out(uploaded)
+
+
+@app.post("/api/chats/{chat_id}/pin", response_model=ChatOut)
+def pin_chat(chat_id: int, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    chat = get_user_chat_or_404(db, chat_id, current_user.id)
+    chat.is_pinned = not chat.is_pinned
+    db.commit()
+    db.refresh(chat)
+    return chat_to_out(chat)
+
+
+@app.post("/api/chats/{chat_id}/archive", response_model=ChatOut)
+def archive_chat(chat_id: int, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    chat = get_user_chat_or_404(db, chat_id, current_user.id)
+    chat.is_archived = True
+    db.commit()
+    db.refresh(chat)
+    return chat_to_out(chat)
+
+
+@app.delete("/api/chats/{chat_id}")
+def delete_chat(chat_id: int, current_user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    chat = get_user_chat_or_404(db, chat_id, current_user.id)
+
+    db.query(Message).filter(Message.chat_id == chat_id).delete()
+    db.query(ModelUploadedFile).filter(ModelUploadedFile.chat_id == chat_id).delete()
+    db.delete(chat)
+    db.commit()
+
+    return {"deleted": True}
+
+
+@app.get("/api/about", response_model=AboutOut)
+def about():
+    return AboutOut(
+        app_name="AI Chatbot",
+        stack=["FastAPI", "React", "LangGraph", "FAISS", "Groq"],
+    )

backend/config.py

@@ -0,0 +1,27 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+BACKEND_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = BACKEND_DIR.parent
+
+load_dotenv(PROJECT_ROOT / ".env")
+load_dotenv(BACKEND_DIR / ".env")
+
+
+class Config:
+    SECRET_KEY = os.getenv("SECRET_KEY", "change-me")
+    JWT_SECRET_KEY = os.getenv("JWT_SECRET_KEY", SECRET_KEY)
+    SQLALCHEMY_DATABASE_URI = os.getenv("DATABASE_URL", f"sqlite:///{BACKEND_DIR / 'database.db'}")
+    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+    ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "10080"))
+    CORS_ORIGINS = [
+        origin.strip()
+        for origin in os.getenv("CORS_ORIGINS", "http://localhost:5173,http://127.0.0.1:5173").split(",")
+        if origin.strip()
+    ]
+    CORS_ORIGIN_REGEX = os.getenv("CORS_ORIGIN_REGEX", r"^https://.*\.vercel\.app$").strip() or None
+    UPLOAD_DIR = str(BACKEND_DIR / "uploads")
+    VECTORSTORE_DIR = str(BACKEND_DIR / "vectorstores")

backend/lang_service.py

@@ -0,0 +1,105 @@
+import os
+
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.document_loaders import TextLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnablePassthrough
+from langchain_groq import ChatGroq
+
+try:
+    from .config import Config
+except ImportError:
+    from config import Config
+
+VECTOR_STORE_PATH = Config.VECTORSTORE_DIR
+
+
+# ================= CREATE VECTOR STORE =================
+def create_vectorstore(filepath, chat_id):
+    extension = os.path.splitext(filepath)[1].lower()
+
+    if extension == ".pdf":
+        loader = PyPDFLoader(filepath)
+    else:
+        # Try UTF-8 first, then automatically detect compatible text encodings.
+        loader = TextLoader(filepath, encoding="utf-8", autodetect_encoding=True)
+
+    documents = loader.load()
+
+    if not documents or not any(doc.page_content.strip() for doc in documents):
+        raise ValueError("Uploaded file has no readable text content")
+
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500,
+        chunk_overlap=100
+    )
+
+    docs = splitter.split_documents(documents)
+
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/all-MiniLM-L6-v2"
+    )
+
+    vectorstore = FAISS.from_documents(docs, embeddings)
+
+    path = os.path.join(VECTOR_STORE_PATH, str(chat_id))
+    os.makedirs(path, exist_ok=True)
+
+    vectorstore.save_local(path)
+
+
+# ================= GET RAG RESPONSE =================
+def get_rag_response(chat_id, query):
+    path = os.path.join(VECTOR_STORE_PATH, str(chat_id))
+
+    if not Config.GROQ_API_KEY:
+        raise RuntimeError("GROQ_API_KEY is not configured")
+
+    embeddings = HuggingFaceEmbeddings(
+        model_name="sentence-transformers/all-MiniLM-L6-v2"
+    )
+
+    vectorstore = FAISS.load_local(
+        path,
+        embeddings,
+        allow_dangerous_deserialization=True
+    )
+
+    retriever = vectorstore.as_retriever()
+
+    llm = ChatGroq(
+        groq_api_key=Config.GROQ_API_KEY,
+        model="llama-3.1-8b-instant",
+        temperature=0
+    )
+
+    # 🔥 Modern RAG Chain (LCEL)
+    prompt = ChatPromptTemplate.from_template(
+        """Answer the question based only on the context below.
+
+Context:
+{context}
+
+Question:
+{question}
+"""
+    )
+
+    def format_docs(docs):
+        return "\n\n".join(doc.page_content for doc in docs)
+
+    rag_chain = (
+        {
+            "context": retriever | format_docs,
+            "question": RunnablePassthrough(),
+        }
+        | prompt
+        | llm
+        | StrOutputParser()
+    )
+
+    return rag_chain.invoke(query)

backend/langgraph_service.py

@@ -0,0 +1,66 @@
+from langchain_groq import ChatGroq
+from langchain_core.messages import AIMessage, SystemMessage
+from langgraph.graph import StateGraph
+from typing import TypedDict, List
+try:
+    from .config import Config
+except ImportError:
+    from config import Config
+
+llm = None
+
+
+def get_llm():
+    global llm
+    if llm is None:
+        if not Config.GROQ_API_KEY:
+            raise RuntimeError("GROQ_API_KEY is not configured")
+        llm = ChatGroq(
+            groq_api_key=Config.GROQ_API_KEY,
+            model="llama-3.1-8b-instant"
+        )
+    return llm
+
+class State(TypedDict):
+    messages: List
+
+
+SYSTEM_PROMPT = (
+    "You are a helpful assistant. "
+    "Answer clearly and directly. "
+    "Do not repeat your previous response verbatim."
+)
+
+
+def call_model(state):
+    history = state["messages"]
+    model = get_llm()
+    response = model.invoke([SystemMessage(content=SYSTEM_PROMPT), *history])
+
+    last_ai_message = next(
+        (message for message in reversed(history) if isinstance(message, AIMessage)),
+        None,
+    )
+
+    # If the model repeats exactly, ask for a reformulated answer one time.
+    if last_ai_message and response.content.strip() == last_ai_message.content.strip():
+        response = model.invoke(
+            [
+                SystemMessage(content=SYSTEM_PROMPT),
+                *history,
+                SystemMessage(
+                    content="Rephrase and improve the answer. Add useful new detail and avoid repetition."
+                ),
+            ]
+        )
+
+    return {"messages": history + [response]}
+
+graph = StateGraph(State)
+graph.add_node("chatbot", call_model)
+graph.set_entry_point("chatbot")
+app_graph = graph.compile()
+
+def get_response(history):
+    result = app_graph.invoke({"messages": history})
+    return result["messages"][-1]

backend/models.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+
+from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String, Text, create_engine
+from sqlalchemy.orm import declarative_base, relationship, sessionmaker
+
+try:
+    from .config import Config
+except ImportError:
+    from config import Config
+
+
+DATABASE_URL = Config.SQLALCHEMY_DATABASE_URI
+connect_args = {"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
+
+engine = create_engine(DATABASE_URL, connect_args=connect_args)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+class User(Base):
+    __tablename__ = "user"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String(150), unique=True, nullable=False, index=True)
+    password = Column(String(200), nullable=False)
+
+    chats = relationship("Chat", back_populates="user", cascade="all, delete-orphan")
+
+
+class Chat(Base):
+    __tablename__ = "chat"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("user.id"), nullable=False)
+
+    title = Column(String(200), default="New Chat")
+    mode = Column(String(20), default="normal")
+
+    is_pinned = Column(Boolean, default=False)
+    is_archived = Column(Boolean, default=False)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    user = relationship("User", back_populates="chats")
+    messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan")
+    files = relationship("UploadedFile", back_populates="chat", cascade="all, delete-orphan")
+
+
+class Message(Base):
+    __tablename__ = "message"
+
+    id = Column(Integer, primary_key=True, index=True)
+    chat_id = Column(Integer, ForeignKey("chat.id"), nullable=False, index=True)
+
+    role = Column(String(50), nullable=False)
+    content = Column(Text, nullable=False)
+    timestamp = Column(DateTime, default=datetime.utcnow)
+
+    chat = relationship("Chat", back_populates="messages")
+
+
+class UploadedFile(Base):
+    __tablename__ = "uploaded_file"
+
+    id = Column(Integer, primary_key=True, index=True)
+    chat_id = Column(Integer, ForeignKey("chat.id"), nullable=False, index=True)
+
+    filename = Column(String(200), nullable=False)
+    filepath = Column(String(300), nullable=False)
+    uploaded_at = Column(DateTime, default=datetime.utcnow)
+
+    chat = relationship("Chat", back_populates="files")
+
+
+def init_db():
+    Base.metadata.create_all(bind=engine)

backend/render.yaml

@@ -0,0 +1,18 @@
+services:
+  - type: web
+    name: chat-bot-api
+    env: docker
+    dockerfilePath: ./Dockerfile
+    autoDeploy: true
+    healthCheckPath: /
+    envVars:
+      - key: SECRET_KEY
+        sync: false
+      - key: JWT_SECRET_KEY
+        sync: false
+      - key: GROQ_API_KEY
+        sync: false
+      - key: ACCESS_TOKEN_EXPIRE_MINUTES
+        value: "10080"
+      - key: CORS_ORIGINS
+        sync: false

backend/requirements.txt

@@ -0,0 +1,15 @@
+fastapi
+uvicorn[standard]
+sqlalchemy
+python-multipart
+python-jose[cryptography]
+werkzeug
+python-dotenv
+langchain
+langgraph
+langchain-groq
+langchain-community
+langchain-text-splitters
+sentence-transformers
+faiss-cpu
+pypdf

backend/uploads/1_Deepak_Kushwaha_Resume.pdf

@@ -0,0 +1,74 @@
+%PDF-1.4
+%���� ReportLab Generated PDF document (opensource)
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/Contents 8 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 7 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+5 0 obj
+<<
+/PageMode /UseNone /Pages 7 0 R /Type /Catalog
+>>
+endobj
+6 0 obj
+<<
+/Author (\(anonymous\)) /CreationDate (D:20260329223300+00'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260329223300+00'00') /Producer (ReportLab PDF Library - \(opensource\)) 
+  /Subject (\(unspecified\)) /Title (\(anonymous\)) /Trapped /False
+>>
+endobj
+7 0 obj
+<<
+/Count 1 /Kids [ 4 0 R ] /Type /Pages
+>>
+endobj
+8 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1939
+>>
+stream
+Gat=+9lh45&A@sBoOY_](1?/^Ng%qDD%\`d71?/#HkA/D7R87n,RlZ2r:k]B)8O7:;mk^:o.fO^h6110M_:RYY8dKh"]9bAa+H!e:MDkfmTJ_3VB`[D*rJ"]2CIBg;"sXpcGdc7$Wu<f9Y)1-o.DSOBKlRH.<SE'kp68=N/k':/B*3)<Be/6\TgQln$U2\Ni%<Rd0JuJ-ENnJPY/KbI(+HGnon+?V)sMcnF[#$5$##aPc9aG1]Hr)NOXlNp>*]%2aT<."RQZ_OD^/<acqq9.?fl)<@U_9];*i=e(8fAVrr:f^O&ED^a4QpcJmL3<[JPI+X1J'mfWqAoI?fXj'>:H?WKJ(k`MG36qNS5R^6E'(IJ!/9bp?:R5.=?s2d""Xd0J0f#uuU<11ZWlMsQi!,M'M]*V4LY7ZT42P-0'.a*GLBX":i;C#[WBu'OlAq`nD#T:=H3jk3,][[`EK8?ZP8iYg,@oSXFUDAhj+h&eEgis^kHg.InCt6bjGimbRj5.?N)pTq0;[tdM;qP&a`10H<B)(\gns.SeB-ab(``H_ch32AIR4++0m6WAV/EG)W=jD/gP#+/,)2[qlZ1h.!"qlK_nWhigs1s`4W^Y!FDI('hj?ooK'>_91`n)--ePo@\1#k';4sl[Wl[9]e9K6^Z.7d<\!m;^*.?UrlOM%L>fpS.[mlV3;<r5BcRH-g`J;=R%q_UMM-EBN]rVK:i@Q",s9/0#..`2JhB],O4VVX\g,;jND22'pR$bpB&eTYES(>VSrTg_oLA)0E)H`lbc\g.N(U)#5c[1j+B`h5SIM9f0V?>]Z57C&!tkE)j^ljWH<P8eUs^$<MVqN*^o.(9u*iUP.uB1.o8)]CFn#XqEXjn!/u4irN0>B^[BhC._["B6mb2/?(XgP#F?j$X8Y9r*5piiS=:OZPfI#L;D"SC*U,8o8R<L5)1U\F4,]1tpG.0.E41/t`B)aY85OVS\i!fSs"P:Ns"NWSDXR^84"S+HVf$KYYuIF:Z!H$VILaN':!T^qo,Co!kR)pgTpX4+NY:77-ZEOL(f([18mInp%'8K"'?q.J:\JScUZgZ-@FmLBW@B"PD>b\i0c<.#pP<$"27VEU0jIV9.c8b(D(P+a4GDPRlb!B9?4*F]a3o"$4lnLHH`M'Y4aulBM2-]1g)brA&7#lmjCC7[Hpq9ea1\F\sJ#i[][da?Ws8Tso6?]o)D0%ZqHHJoaNrQkiDKViAhroq_/p(=GKm*m28+U/!Frr3OP,CG#Xq2F:]T3:n)t!Pn1om@%aa%-B6>UWkdQX!THrK/?\*O6/IFZ_"(X5)k<tFjRLpj:`n8^lN:0N"7c!MBi)E-9_&e1e8K5ZZq^`h-.[N8Zk[9BuGjm##_<L<U)kIOFddcP7u32MN&h&1+FZO,cF%]6Gou<c[*EB!BqpJN:UeEC!,N)+:g/Jg7dL=pTJM59oj+AC9H1#<:RM'I))"VJ1HBcdGU-?a>gN/=^/MdD`S=Edl2-0%Dp=XR+WBI<7!sZSFH#n#Un>O502p0gf=LKVp:TUk@piVU@ophp1F9bo8^koQS4S74\jB8NGb1cM-<#0%@ZB9D!hhGdg)/rf[H)tKh?$=P+`g=F\_MaXs_S.$1=n_s/iYk".uQ91F2[lpNZ0pj4j.k%#]St]#2F`LMI)>UJLtDS(9'If<`A-S*J,gnCb5=(P.tbj5)]+bFJ=*a+\[\MCKElHCAq&*T#!;1)=:A>b'n2P@Whr$M-Jr/r7:+r2fMPO-d/aP]c'[]kLi2Oks[t2_1p(0Jpo>\E;`fcOB\0H^Z_Hi-:OV"VTS.f6c[:Y&g0&*&Y1+j'kN;IT4kEba$#mf_*0-),gkTH:Dn]^9j0CD@nsR]lY^_D00j1Vmusu?MOOWr/+/*`oZpNE@[_=kUpH:*o`qMODRn!V;F[o?Thccp[jful1UIiQNK;D(OHia)u~>endstream
+endobj
+xref
+0 9
+0000000000 65535 f 
+0000000061 00000 n 
+0000000102 00000 n 
+0000000209 00000 n 
+0000000321 00000 n 
+0000000524 00000 n 
+0000000592 00000 n 
+0000000872 00000 n 
+0000000931 00000 n 
+trailer
+<<
+/ID 
+[<478a1d1eebd9bba5b78c7646e29ef381><478a1d1eebd9bba5b78c7646e29ef381>]
+% ReportLab generated PDF document -- digest (opensource)
+
+/Info 6 0 R
+/Root 5 0 R
+/Size 9
+>>
+startxref
+2961
+%%EOF

backend/vectorstores/1/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7dd3458e48b73fdfd88113db464a644bef16d6b6b2bed0da8f64f5feacbbf002
+size 4699

backend/vectorstores/3/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4983bd2145b2cf24574513b052f73e43efdab485a01dd4c0a5e7ba574a19c780
+size 19732