AI-Powered Professor Rating Assistant With RAG and Pinecone

npm install @mui/material @emotion/react @emotion/styled @pinecone-database/pinecone @vercel/analytics openai

{
    "Reviews": [
      {
        "professor": "Dr. Emily Johnson",
        "subject": "Computer Science",
        "rating": 5,
        "reviews": "Excellent professor! Very knowledgeable and approachable."
      },
      {
        "professor": "Dr. John Smith",
        "subject": "Mathematics",
        "rating": 4,
        "reviews": "Great at explaining complex concepts but sometimes a bit fast-paced."
      },

      {
        "professor": "Dr. Susan Harris",
        "subject": "Physics",
        "rating": 3,
        "reviews": "Challenging course, but the professor was helpful."
      },
      {
        "professor": "Dr. Joseph Allen",
        "subject": "Philosophy",
        "rating": 5,
        "reviews": "Insightful and encourages deep thinking."
      },
      {
        "professor": "Dr. Carol Nelson",
        "subject": "Linguistics",
        "rating": 4,
        "reviews": "Very engaging and knowledgeable in the subject."
      },
      {
        "professor": "Dr. Thomas King",
        "subject": "Engineering",
        "rating": 3,
        "reviews": "Tough course, but the professor is fair."
      },
	// ...similarly add more reviews ...
    ]
}

# Importing necessary libraries
from dotenv import load_dotenv  # Loads environment variables from a .env file
load_dotenv()  # Activates the environment variables
import os  # To access environment variables and interact with the operating system
from openai import OpenAI  # OpenAI client for interacting with OpenAI APIs
from pinecone import Pinecone, ServerlessSpec  # Pinecone client and configurations for vector database

# Initialize the Pinecone client using the API key from environment variables
pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"))

# Create a new Pinecone index named "rag" with the specified dimensions and metric
# Dimension is set to 1536, matching the output size of the embedding model
# The metric "cosine" will be used for similarity calculations
# ServerlessSpec specifies the cloud provider (AWS) and region (us-east-1)
pc.create_index(
    name="rag",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1")
)

# Load the dataset containing professor reviews from a JSON file
import json
data = json.load(open("reviews.json"))  # Reads the JSON file into a Python dictionary
reviews = data['Reviews']  # Extract the "Reviews" key, which contains the review data

# Prepare to process reviews into embeddings
processed_data = []  # Initialize an empty list to store processed data
client = OpenAI()  # Initialize the OpenAI client for creating embeddings

# Iterate over each review in the dataset
for review in reviews:
    # Use OpenAI's embedding model to create an embedding for the review text
    response = client.embeddings.create(
        input=review['reviews'],  # The review text to generate embeddings for
        model="text-embedding-3-small"  # The specific embedding model to use
    )
    embedding = response.data[0].embedding  # Extract the embedding from the response
    
    # Structure the processed data with embedding values, ID, and metadata
    processed_data.append({
        "values": embedding,
        "id": review["professor"],
        "metadata": {
            "review": review["reviews"],
            "subject": review["subject"], 
            "stars": review["rating"]
        }
    })

# Print the first processed data entry to verify the output
print(processed_data[0])

# Retrieve the index created earlier for uploading the vectors
index = pc.Index('rag')

# Upsert (insert or update) the processed data into the Pinecone index
index.upsert(
    vectors=processed_data,  # The list of vectors to add to the index
    namespace="ns1"  # A namespace to logically separate vectors
)

# Describe the current statistics of the index (e.g., vector count, memory usage)
stats = index.describe_index_stats()
print(stats)

import { NextResponse } from "next/server"; 
import OpenAI from 'openai'; 
import { Pinecone } from '@pinecone-database/pinecone';

const systemPrompt = `
You are an AI assistant designed to help students find professors based on their queries using a Retrieval-Augmented Generation (RAG) approach.

Your Capabilities:
You have access to a comprehensive and accurate database of professor reviews, including information such as professor names, subjects, teaching styles, ratings, and student feedback. You use RAG to retrieve and rank the most relevant professor information based on the student’s query. Your primary goal is to provide factually correct and highly relevant information without generating unsupported or speculative content.

Your Responses Should:
- Be concise yet informative, focusing on verifiable details for each professor.
- Include the professor's name, subject, star rating, and a brief summary of their strengths or notable comments.
- Highlight specific aspects mentioned in the student's query (e.g., teaching style, course difficulty, etc.).
- Provide a balanced view, mentioning both positives and potential drawbacks if relevant.
- Avoid any content that cannot be directly supported by the data retrieved. Only provide information that is found in the database or directly retrieved.

Response Format:
For each query, structure your response as follows:

1. Introduction: Address the student's specific request.
2. Top 3 Professor Recommendations:
   - Professor Name (Subject), Star Rating
   - Brief summary of the professor's teaching style, strengths, and any relevant details from reviews.
3. Conclusion: Provide any additional advice or suggestions for the student.

Guidelines:
- Accuracy and Relevance: Ensure all provided information is directly supported by retrieved data and relevant to the student’s query.
- Clarity and Conciseness: Responses should be clear, to the point, and avoid unnecessary detail while still providing valuable information.
- Respect Privacy: Avoid sharing any sensitive or personal information that could identify students or professors outside the professional context.
- Ethical Considerations: Do not provide biased recommendations or omit important information that could influence a student’s decision unfairly.
- Neutral Tone: Maintain a neutral and professional tone in all responses, providing balanced information that helps the student make an informed choice.
- Avoid Repetition: If a professor has already been recommended in a previous query, avoid suggesting them again unless specifically relevant.
- Content Limitations: Do not copy full reviews or content verbatim from any source. Summarize and paraphrase the information, ensuring it is within the context of the student’s needs.

IMPORTANT: Always base your responses on the data retrieved and avoid generating any content that cannot be substantiated by the available information.
`;

/**
 * Handles a POST request to generate a response based on user-provided data, using OpenAI for embeddings and chat completions,
 * and Pinecone for vector-based database queries.
 *
 * @param {Request} req - The HTTP POST request containing user data in JSON format.
 * @returns {Response} - A readable stream with the AI-generated response or an error message.
 */
export async function POST(req) {
    try {
        // Parse the JSON payload from the incoming request
        const data = await req.json();

        // Initialize the Pinecone client for vector database interaction
        const pc = new Pinecone({
            apiKey: process.env.PINECONE_API_KEY, // API key for authenticating with Pinecone
        });

        // Access a specific index and namespace in the Pinecone vector database
        const index = pc.index('rag').namespace('ns1');

        // Initialize the OpenAI client for embeddings and chat completions
        const openai = new OpenAI({
            apiKey: process.env.OPENAI_API_KEY, // API key for authenticating with OpenAI
        });

        // Extract the content of the last message from the user input
        const text = data[data.length - 1].content;

        // Generate a text embedding using OpenAI's embedding model
        const embeddingResponse = await openai.embeddings.create({
            model: "text-embedding-ada-002", // Model used for creating embeddings
            input: text, // The text to be embedded
        });

        // Extract the generated embedding from the response
        const embedding = embeddingResponse.data[0].embedding;

        // Query the Pinecone vector database for similar embeddings
        const results = await index.query({
            topK: 5, // Retrieve the top 5 similar results
            includeMetadata: true, // Include metadata in the response
            vector: embedding, // The embedding vector to query
        });

        // Initialize a string to store the results of the query
        let resultString = '\n\nReturned Ratings from vector db:';

        // Iterate over the query results and append relevant metadata to the result string
        for (const match of results.matches) {
            resultString += `
            Professor: ${match.id}
            Review: ${match.metadata.review}
            Subject: ${match.metadata.subject}
            Rating: ${match.metadata.stars}
            `;
        }

        // Append the query results to the user's last message
        const lastMessageContent = data[data.length - 1].content + resultString;

        // Prepare the previous messages, excluding the last one
        const previousMessages = data.slice(0, data.length - 1);

        // Generate a chat completion using OpenAI's chat model
        const completion = await openai.chat.completions.create({
            messages: [
                { role: 'system', content: systemPrompt }, // Add system-level context
                ...previousMessages, // Include prior conversation messages
                { role: 'user', content: lastMessageContent } // Include the updated last message
            ],
            model: 'gpt-4o-mini', // Chat model used for completion
            stream: true, // Stream the response for real-time output
        });

        // Create a readable stream to return the AI-generated response
        const stream = new ReadableStream({
            async start(controller) {
                const encoder = new TextEncoder();
                try {
                    // Stream the completion in chunks
                    for await (const chunk of completion) {
                        const content = chunk.choices[0]?.delta?.content;
                        if (content) {
                            controller.enqueue(encoder.encode(content)); // Enqueue the content
                        }
                    }
                } catch (err) {
                    controller.error(err); // Handle errors during streaming
                } finally {
                    controller.close(); // Close the stream
                }
            },
        });

        // Return the readable stream as the response
        return new NextResponse(stream);

    } catch (error) {
        // Log and handle errors that occur during the request
        console.error('Error processing request:', error);
        return new NextResponse('Internal Server Error', { status: 500 });
    }
}

'use client';
import { useState } from "react";

export default function Home() {
  const [messages, setMessages] = useState([
    {
      role: "assistant",
      content: "Hi! Welcome to ProfTalk - Your Professor Guide. How can I assist you today?"
    }
  ]);

  const [message, setMessage] = useState('');

  const sendMessage = async () => {
    const newMessages = [
      ...messages,
      { role: "user", content: message },
      { role: "assistant", content: '...' }, 
    ];
    setMessages(newMessages);
    setMessage('');

    try {
      const response = await fetch('/api/chat', {
        method: "POST",
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(newMessages)
      });

      if (!response.body) {
        throw new Error('Response body is null');
      }

      const reader = response.body.getReader();
      const decoder = new TextDecoder();
      let result = '';

      const processText = async ({ done, value }: { done: boolean, value?: Uint8Array }) => {
        if (done) {
          setMessages((prevMessages) => {
            let lastMessage = prevMessages[prevMessages.length - 1];
            lastMessage.content = result;
            return [...prevMessages];
          });
          return;
        }

        const text = decoder.decode(value || new Uint8Array(), { stream: true });
        result += text;

        setMessages((prevMessages) => {
          let lastMessage = prevMessages[prevMessages.length - 1];
          lastMessage.content = result;
          return [...prevMessages];
        });

        reader.read().then(processText);
      };

      reader.read().then(processText);
    } catch (error) {
      console.error("Failed to send message:", error);
    }
  };

  return (
    <div style={{ display: 'flex', height: '100vh', fontFamily: 'Arial, sans-serif' }}>
      <div style={{ flex: 1, padding: '20px', display: 'flex', flexDirection: 'column', backgroundColor: '#f5f7fa' }}>
        <h1 style={{ textAlign: 'center', marginBottom: '20px', fontSize: '26px', color: '#2c3e50', fontWeight: 'bold' }}>
          ProfTalk - Your Professor Guide
        </h1>

        <div style={{ flex: 1, border: '1px solid #ddd', borderRadius: '10px', padding: '20px', overflowY: 'scroll', backgroundColor: '#fff', boxShadow: '0px 4px 10px rgba(0, 0, 0, 0.1)' }}>
          {messages.map((msg, index) => (
            <div key={index} style={{ margin: '10px 0', display: 'flex', justifyContent: msg.role === 'user' ? 'flex-end' : 'flex-start', animation: 'fadeIn 0.5s' }}>
              <div style={{ maxWidth: '75%', padding: '10px 15px', borderRadius: '15px', backgroundColor: msg.role === 'user' ? '#007BFF' : '#f1f1f1', color: msg.role === 'user' ? 'white' : '#333', boxShadow: '0px 2px 5px rgba(0, 0, 0, 0.1)' }}>
                <strong style={{ color: msg.role === 'user' ? 'white' : '#333' }}>{msg.role === 'user' ? 'You' : 'Assistant'}:</strong>
                <p style={{ margin: '5px 0 0' }}>{msg.content}</p>
              </div>
            </div>
          ))}
        </div>

        <div style={{ display: 'flex', marginTop: '10px' }}>
          <input 
            type="text" 
            value={message} 
            onChange={(e) => setMessage(e.target.value)} 
            style={{ flex: 1, padding: '15px', borderRadius: '30px', border: '1px solid #ddd', fontSize: '16px', color: '#333', outline: 'none', boxShadow: 'inset 0px 1px 3px rgba(0, 0, 0, 0.1)' }} 
            placeholder="Type your message here..." 
          />
          <button 
            onClick={sendMessage} 
            style={{ padding: '10px 25px', marginLeft: '10px', borderRadius: '30px', backgroundColor: '#007BFF', color: 'white', border: 'none', fontSize: '16px', cursor: 'pointer', transition: 'background-color 0.3s' }}
            onMouseOver={(e) => e.currentTarget.style.backgroundColor = '#0056b3'}
            onMouseOut={(e) => e.currentTarget.style.backgroundColor = '#007BFF'}
          >
            Send
          </button>
        </div>
      </div>

      <div className="background-image" style={{ flex: 1 }} />
    </div>
  );
}