import os
import sys
from pathlib import Path
from langchain_community.document_loaders import PyPDFLoader, TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# Ensure you have your environment variables set or load them here
# from dotenv import load_dotenv
# load_dotenv()

def main():
    print("--- LangChain Educational Demo: Loader & Splitter ---")

    # 1. Get input file path from user
    file_path_str = input("Enter the absolute path to your file (PDF or TXT): ").strip()

    # Remove quotes if user added them
    if file_path_str.startswith('"') and file_path_str.endswith('"'):
        file_path_str = file_path_str[1:-1]

    file_path = Path(file_path_str)

    if not file_path.exists():
        print(f"Error: File not found at {file_path}")
        return

    # 2. Load the document
    print(f"\n[1] Loading file: {file_path.name}...")
    docs = []
    try:
        if file_path.suffix.lower() == ".pdf":
            loader = PyPDFLoader(str(file_path))
            docs.extend(loader.load())
        elif file_path.suffix.lower() in [".txt", ".md", ".log"]:
            loader = TextLoader(str(file_path), encoding="utf-8")
            docs.extend(loader.load())
        else:
            print("Error: Unsupported file type. Please use .pdf, .txt, .md, or .log")
            return
    except Exception as e:
        print(f"Error loading file: {e}")
        return

    print(f" -> Successfully loaded {len(docs)} page(s)/document(s).")

    # 3. Split the document (Chunking)
    print("\n[2] Splitting text into chunks...")
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=150,
        separators=["\n\n", "\n", " ", ""]
    )

    chunks = splitter.split_documents(docs)

    print(f" -> Created {len(chunks)} chunks.")

    # 4. Print Chunks
    print("\n[3] Printing Chunks (Preview first 3):")
    print("="*60)
    for i, chunk in enumerate(chunks[:3]):
        print(f"CHUNK {i+1}:")
        print(f"Metadata: {chunk.metadata}")
        print(f"Content Length: {len(chunk.page_content)}")
        print("-" * 20)
        print(chunk.page_content[:500] + "..." if len(chunk.page_content) > 500 else chunk.page_content)
        print("="*60)

    if len(chunks) > 3:
        print(f"... and {len(chunks) - 3} more chunks.")

if __name__ == "__main__":
    main()

import os
import sys
from dotenv import load_dotenv
from langchain_chroma import Chroma
from langchain_community.embeddings import SentenceTransformerEmbeddings
from langchain_core.documents import Document

# Load env for proper setup if needed, though local embeddings might not need API keys
load_dotenv()

def main():
    print("--- ChromaDB Educational Demo: Embedding & Search ---")
    print("(Note: This runs in-memory and does NOT save to disk)")

    # 1. Setup Embedding Model
    model_name = "sentence-transformers/all-MiniLM-L6-v2"
    print(f"\n[1] Initializing Embedding Model ({model_name})...")
    embeddings = SentenceTransformerEmbeddings(model_name=model_name)

    # Initialize ephemeral Chroma (no persist_directory)
    vectorstore = Chroma(
        collection_name="demo_collection",
        embedding_function=embeddings,
        # persist_directory=None # Passing None typically implies in-memory/ephemeral in newer versions or default
    )

    # 2. Get Data Input
    print("\n[2] Enter texts to add to the database (type 'DONE' on a new line to finish):")
    texts_to_add = []
    while True:
        line = input(f"Text {len(texts_to_add)+1}: ")
        if line.strip().upper() == 'DONE':
            break
        if line.strip():
            texts_to_add.append(line)

    if not texts_to_add:
        print("No text provided. Exiting.")
        return

    # 3. Embed and Add to Chroma
    print(f"\n[3] Embedding and adding {len(texts_to_add)} texts to Vector Store...")
    # Wrap in Document objects as typical RAG would
    docs = [Document(page_content=t, metadata={"id": i}) for i, t in enumerate(texts_to_add)]

    vectorstore.add_documents(docs)
    print(" -> Done.")

    # 4. Search
    while True:
        query = input("\n[4] Enter a query to search (or 'quit' to exit): ").strip()
        if query.lower() in ['quit', 'exit']:
            break

        print(f" Searching for: '{query}'")

        # Perform similarity search
        results = vectorstore.similarity_search_with_score(query, k=2)

        print(f" -> Found {len(results)} matches:\n")
        for doc, score in results:
            print(f" * Score: {score:.4f}")
            print(f" * Content: {doc.page_content}")
            print(" " + "-"*30)

if __name__ == "__main__":
    main()

from fastapi import FastAPI, UploadFile

app = FastAPI()

# Endpoint 1: File Upload
@app.post("/upload")
async def upload_file(file: UploadFile):
    return {"filename": file.filename, "status": "Ingested"}

# Endpoint 2: Query
@app.post("/query")
async def query_endpoint(payload: QueryRequest):
    answer = rag_system.ask(payload.question)
    return {"answer": answer}

import os
import sys
from dotenv import load_dotenv
from langchain_groq import ChatGroq
from langchain_core.prompts import ChatPromptTemplate

load_dotenv()

def main():
    print("--- Groq API Educational Demo: LLM Interaction ---")

    api_key = os.getenv("GROQ_API_KEY")
    if not api_key:
        print("Error: GROQ_API_KEY not found in .env file.")
        return

    model_name = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")

    # 1. Initialize ChatGroq
    print(f"\n[1] Initializing Groq Client (Model: {model_name})...")
    llm = ChatGroq(
        api_key=api_key,
        model=model_name,
        temperature=0.7
    )

    # 2. Interactive Loop
    print("\n[2] Start Chatting (type 'quit' to exit)")

    # We can use a simple prompt template
    system_prompt = "You are a helpful assistant explaining concepts clearly."

    while True:
        user_input = input("\nYou: ").strip()
        if user_input.lower() in ['quit', 'exit']:
            break

        if not user_input:
            continue

        print("Groq: Generating response...", end="\r")

        try:
            # invocating the model
            messages = [
                ("system", system_prompt),
                ("human", user_input),
            ]
            response = llm.invoke(messages)

            # Clear the loading line
            print(" " * 30, end="\r")
            print(f"Groq: {response.content}")

        except Exception as e:
            print(f"\nError interacting with Groq: {e}")

if __name__ == "__main__":
    main()