🎓 Building a Smart LMS Assistant: RAG System with Pinecone for Multi-Source Learning Data

Student Query → Embedding Model → Pinecone Search → Context Retrieval
                                          ↓
                                    LLM (GPT-4) ← Combined Context
                                          ↓
                                   Accurate Answer

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from pinecone import Pinecone, ServerlessSpec

# Initialize Pinecone
pc = Pinecone(api_key="your-api-key")
index_name = "lms-knowledge-base"

# Create index if it doesn't exist
if index_name not in pc.list_indexes().names():
    pc.create_index(
        name=index_name,
        dimension=1536,  # OpenAI embedding dimension
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="us-east-1")
    )

index = pc.Index(index_name)

# Process PDFs
def process_pdf(pdf_path, course_id):
    loader = PyPDFLoader(pdf_path)
    documents = loader.load()

    # Split into chunks
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=1000,
        chunk_overlap=200,
        separators=["\n\n", "\n", " ", ""]
    )
    chunks = text_splitter.split_documents(documents)

    # Generate embeddings
    embeddings = OpenAIEmbeddings()

    # Upsert to Pinecone
    vectors = []
    for i, chunk in enumerate(chunks):
        vector_id = f"{course_id}_pdf_{i}"
        embedding = embeddings.embed_query(chunk.page_content)

        vectors.append({
            "id": vector_id,
            "values": embedding,
            "metadata": {
                "text": chunk.page_content,
                "source": pdf_path,
                "course_id": course_id,
                "type": "pdf"
            }
        })

    index.upsert(vectors=vectors)
    return len(vectors)

import psycopg2
from datetime import datetime

def fetch_student_context(student_id, query_embedding):
    # Get structured data from PostgreSQL
    conn = psycopg2.connect(
        host="localhost",
        database="lms_db",
        user="your_user",
        password="your_password"
    )

    cursor = conn.cursor()
    cursor.execute("""
        SELECT 
            s.name, 
            s.email,
            c.course_name,
            e.enrollment_date,
            a.assignment_name,
            a.due_date
        FROM students s
        JOIN enrollments e ON s.id = e.student_id
        JOIN courses c ON e.course_id = c.id
        LEFT JOIN assignments a ON c.id = a.course_id
        WHERE s.id = %s AND a.due_date > %s
    """, (student_id, datetime.now()))

    db_results = cursor.fetchall()
    cursor.close()
    conn.close()

    # Format as context
    db_context = "\n".join([
        f"Course: {row[2]}, Assignment: {row[4]}, Due: {row[5]}"
        for row in db_results
    ])

    return db_context

def hybrid_search(query, student_id):
    # Generate query embedding
    embeddings = OpenAIEmbeddings()
    query_embedding = embeddings.embed_query(query)

    # Search Pinecone for PDF content
    results = index.query(
        vector=query_embedding,
        top_k=5,
        include_metadata=True,
        filter={"type": "pdf"}  # Filter for course materials
    )

    # Get database context
    db_context = fetch_student_context(student_id, query_embedding)

    # Combine contexts
    pdf_context = "\n\n".join([
        match['metadata']['text'] 
        for match in results['matches']
    ])

    return {
        "pdf_context": pdf_context,
        "db_context": db_context,
        "sources": [match['metadata']['source'] for match in results['matches']]
    }

from openai import OpenAI

client = OpenAI(api_key="your-openai-key")

def answer_student_query(student_id, query):
    # Retrieve context
    context = hybrid_search(query, student_id)

    # Build prompt
    prompt = f"""You are an LMS assistant. Answer the student's question using the provided context.

DATABASE CONTEXT (Student's enrolled courses and deadlines):
{context['db_context']}

COURSE MATERIALS CONTEXT:
{context['pdf_context']}

STUDENT QUESTION: {query}

Provide a helpful answer with specific references. If information comes from course materials, mention the source."""

    # Generate response
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful LMS assistant."},
            {"role": "user", "content": prompt}
        ],
        temperature=0.7,
        max_tokens=500
    )

    return {
        "answer": response.choices[0].message.content,
        "sources": context['sources']
    }

# Example usage
result = answer_student_query(
    student_id=12345,
    query="When is my Data Structures assignment due and what topics does it cover?"
)

print(result['answer'])
print("\nSources:", result['sources'])