Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import chromadb | |
| from chromadb.utils import embedding_functions | |
| import groq | |
| from typing import Dict | |
| import os | |
| class CourseAdvisor: | |
| def __init__(self, db_path: str = "./chroma_db"): | |
| """Initialize the course advisor with existing ChromaDB database.""" | |
| # Initialize persistent client with path | |
| self.chroma_client = chromadb.PersistentClient(path=db_path) | |
| # Initialize embedding function | |
| self.embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction( | |
| model_name="jinaai/jina-embeddings-v2-base-en" | |
| ) | |
| # Get existing collection | |
| self.collection = self.chroma_client.get_collection( | |
| name="courses", | |
| embedding_function=self.embedding_function | |
| ) | |
| def query_courses(self, query_text: str, chat_history: str, api_key: str, n_results: int = 3) -> Dict: | |
| """Query the vector database and get course recommendations.""" | |
| # Initialize Groq client with provided API key | |
| groq_client = groq.Groq(api_key=api_key) | |
| try: | |
| # Get relevant documents from vector DB | |
| results = self.collection.query( | |
| query_texts=[query_text], | |
| n_results=min(n_results, self.collection.count()), | |
| include=['documents', 'metadatas'] | |
| ) | |
| # Prepare context from retrieved documents | |
| docs_context = "\n\n".join(results['documents'][0]) | |
| except Exception as e: | |
| st.error(f"Error querying database: {str(e)}") | |
| return { | |
| 'llm_response': "I encountered an error while searching the course database. Please try again.", | |
| 'retrieved_courses': [] | |
| } | |
| # Create prompt with chat history | |
| prompt = f"""Previous conversation: | |
| {chat_history} | |
| Current user query: {query_text} | |
| Relevant course information: | |
| {docs_context} | |
| Please provide course recommendations based on the entire conversation context. Format your response as: | |
| 1. Understanding of the user's needs (based on conversation history) | |
| 2. Overall recommendation with reasoning | |
| 3. Specific benefits of each recommended course | |
| 4. Learning path suggestion (if applicable) | |
| 5. Any prerequisites or important notes""" | |
| try: | |
| # Get response from Groq | |
| completion = groq_client.chat.completions.create( | |
| messages=[ | |
| {"role": "system", "content": "You are a helpful course advisor who provides detailed, relevant course recommendations based on the user's needs and conversation history. Keep responses clear and well-structured."}, | |
| {"role": "user", "content": prompt} | |
| ], | |
| model="mixtral-8x7b-32768", | |
| temperature=0.7, | |
| ) | |
| return { | |
| 'llm_response': completion.choices[0].message.content, | |
| 'retrieved_courses': results['metadatas'][0] | |
| } | |
| except Exception as e: | |
| st.error(f"Error with Groq API: {str(e)}") | |
| return { | |
| 'llm_response': "I encountered an error while generating recommendations. Please check your API key and try again.", | |
| 'retrieved_courses': [] | |
| } | |
| def initialize_session_state(): | |
| """Initialize session state variables.""" | |
| if 'messages' not in st.session_state: | |
| st.session_state.messages = [] | |
| if 'course_advisor' not in st.session_state: | |
| st.session_state.course_advisor = CourseAdvisor() | |
| if 'api_key' not in st.session_state: | |
| st.session_state.api_key = "" | |
| def get_chat_history() -> str: | |
| """Format chat history for LLM context.""" | |
| history = [] | |
| for message in st.session_state.messages[-5:]: # Only use last 5 messages for context | |
| role = message["role"] | |
| content = message["content"] | |
| history.append(f"{role}: {content}") | |
| return "\n".join(history) | |
| def display_course_card(course: Dict): | |
| """Display a single course recommendation in a card format.""" | |
| with st.container(): | |
| # Add a light background and padding | |
| with st.container(): | |
| st.markdown(""" | |
| <style> | |
| .course-card { | |
| background-color: #f8f9fa; | |
| padding: 1rem; | |
| border-radius: 0.5rem; | |
| margin-bottom: 1rem; | |
| } | |
| </style> | |
| """, unsafe_allow_html=True) | |
| with st.container(): | |
| st.markdown('<div class="course-card">', unsafe_allow_html=True) | |
| # Course title | |
| st.markdown(f"### {course['title']}") | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| # Handle categories - convert to list if string | |
| categories = course.get('categories', 'N/A') | |
| if isinstance(categories, str): | |
| # Split by comma if it's a comma-separated string | |
| categories = [cat.strip() for cat in categories.split(',')] | |
| elif not isinstance(categories, list): | |
| categories = [str(categories)] | |
| # Display categories as bullet points if multiple | |
| if len(categories) > 1: | |
| st.markdown("**Categories:**") | |
| for category in categories: | |
| st.markdown(f"- {category}") | |
| else: | |
| st.markdown(f"**Category:** {categories[0]}") | |
| st.markdown(f"**Lessons:** {course.get('lessons', 'N/A')}") | |
| with col2: | |
| st.markdown(f"**Price:** {course.get('price', 'N/A')}") | |
| if 'url' in course: | |
| st.markdown(f"**[Visit Course]({course['url']})**") | |
| st.markdown('</div>', unsafe_allow_html=True) | |
| st.markdown("---") | |
| def main(): | |
| st.set_page_config( | |
| page_title="Course Recommender", | |
| page_icon="📚", | |
| layout="wide" | |
| ) | |
| st.title("📚 AI Course Recommender") | |
| # Initialize session state | |
| initialize_session_state() | |
| # Display collection info | |
| collection = st.session_state.course_advisor.collection | |
| st.sidebar.info(f"Connected to database with {collection.count()} courses") | |
| # Sidebar | |
| with st.sidebar: | |
| st.header("Settings") | |
| # API key input | |
| api_key = st.text_input("Enter Groq API Key", | |
| type="password", | |
| value=st.session_state.api_key) | |
| if api_key != st.session_state.api_key: | |
| st.session_state.api_key = api_key | |
| # Clear chat button | |
| if st.button("Clear Chat History"): | |
| st.session_state.messages = [] | |
| # Main chat interface | |
| st.header("Chat with AI Course Advisor") | |
| # Display chat history | |
| for message in st.session_state.messages: | |
| with st.chat_message(message["role"]): | |
| st.markdown(message["content"]) | |
| # Chat input | |
| if prompt := st.chat_input("What would you like to learn?"): | |
| # Check if API key is provided | |
| if not st.session_state.api_key: | |
| st.error("Please enter your Groq API key in the sidebar.") | |
| return | |
| # Add user message to chat history | |
| st.session_state.messages.append({"role": "user", "content": prompt}) | |
| with st.chat_message("user"): | |
| st.markdown(prompt) | |
| # Get AI response | |
| with st.chat_message("assistant"): | |
| with st.spinner("Thinking..."): | |
| # Get formatted chat history | |
| chat_history = get_chat_history() | |
| # Query courses with chat history | |
| response = st.session_state.course_advisor.query_courses( | |
| prompt, | |
| chat_history, | |
| st.session_state.api_key | |
| ) | |
| # Display AI recommendation | |
| st.markdown(response['llm_response']) | |
| # Display course cards if any courses were retrieved | |
| if response['retrieved_courses']: | |
| st.markdown("### 📋 Recommended Courses") | |
| for course in response['retrieved_courses']: | |
| display_course_card(course) | |
| # Add assistant response to chat history | |
| st.session_state.messages.append({ | |
| "role": "assistant", | |
| "content": response['llm_response'] + "\n\n" + "### Recommended Courses\n" + | |
| "\n".join([f"- {course['title']}" for course in response['retrieved_courses']]) | |
| }) | |
| if __name__ == "__main__": | |
| main() |