Update app.py

app.py

@@ -9,19 +9,6 @@ from dotenv import load_dotenv
 import autogen
 from autogen import AssistantAgent, UserProxyAgent
 
-# Import DeepSeek API or appropriate SDK here
-from deepseek_api import DeepSeekEmbeddings  # Hypothetical import
-from langchain_community.vecimport os
-import json
-import random
-import logging
-from typing import List, Dict, Any
-
-import streamlit as st
-from dotenv import load_dotenv
-import autogen
-from autogen import AssistantAgent, UserProxyAgent
-
 from langchain_community.embeddings import OpenAIEmbeddings
 from langchain_community.vectorstores import Chroma
 from langchain.docstore.document import Document
@@ -308,224 +295,3 @@ with st.form(key="query_form", clear_on_submit=True):
             st.markdown("### Response")
             st.write(response)
 
-torstores import Chroma
-from langchain.docstore.document import Document
-
-# Load environment variables
-load_dotenv()
-DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")  # Use DeepSeek API Key
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-st.set_page_config(page_title="IT Support System (RAG)", layout="centered")
-
-# Initialize session memory
-if "chat_history" not in st.session_state:
-    st.session_state.chat_history = [] 
-
-# Knowledge Base Setup
-kb_path = os.path.join(os.path.dirname(__file__), 'kb.json')
-with open(kb_path, encoding='utf-8') as f:
-    kb_entries = json.load(f)
-
-docs: List[Document] = []
-for entry in kb_entries:
-    docs.append(Document(
-        page_content=entry['answer'],
-        metadata={
-            'id': entry.get('id'),
-            'question': entry.get('question')
-        }
-    ))
-
-# Initialize DeepSeek embeddings (Assuming DeepSeek API provides embeddings service)
-embeddings = DeepSeekEmbeddings(api_key=DEEPSEEK_API_KEY)
-
-# Vector database setup
-vectordb = Chroma.from_documents(
-    documents=docs,
-    embedding=embeddings,
-    persist_directory='db/chroma'
-)
-retriever = vectordb.as_retriever(search_kwargs={"k": 3})
-
-def retrieve_docs(query: str) -> str:
-    """Retrieve relevant documentation from the knowledge base"""
-    hits = retriever.get_relevant_documents(query)
-    if not hits:
-        return "No relevant documentation found."
-    
-    results = []
-    for doc in hits:
-        question = doc.metadata.get('question', 'FAQ')
-        results.append(f"**Q: {question}**\nA: {doc.page_content}")
-    return "\n\n".join(results)
-
-def escalate_ticket(query: str, analysis: str = "") -> str:
-    """Create a ticket for issues that need human intervention"""
-    ticket_id = f"TICKET-{random.randint(1000, 9999)}"
-    description = f"User Query: {query}\nAnalysis: {analysis}"
-    # In a real system, you would send this to a ticketing system like JIRA, ServiceNow, etc.
-    logger.info(f"Escalating issue with ticket {ticket_id}: {description}")
-    return f"Escalated issue. Created ticket {ticket_id}. A support technician will contact you shortly."
-
-# LLM Configuration for DeepSeek
-llm_config = {
-    "model": "deepseek-model",  # Replace with actual DeepSeek model name
-    "api_key": DEEPSEEK_API_KEY,
-    "temperature": 0.5,  # Example parameter
-}
-
-# Agent Definitions (Same structure but using DeepSeek API)
-master_agent = AssistantAgent(
-    name="Master",
-    llm_config=llm_config,
-    system_message="""You are the Master Agent that orchestrates the IT support workflow..."""
-)
-
-planning_agent = AssistantAgent(
-    name="Planning",
-    llm_config=llm_config,
-    system_message="""You are the Planning Agent responsible for..."""
-)
-
-analysis_agent = AssistantAgent(
-    name="Analysis",
-    llm_config=llm_config,
-    system_message="""You are the Analysis Agent responsible for..."""
-)
-
-resolution_agent = AssistantAgent(
-    name="Resolution",
-    llm_config=llm_config,
-    system_message="""You are the Resolution Agent responsible for...""",
-    function_map={"retrieve_docs": retrieve_docs}
-)
-
-escalation_agent = AssistantAgent(
-    name="Escalation",
-    llm_config=llm_config,
-    system_message="""You are the Escalation Agent responsible for...""",
-    function_map={"escalate_ticket": escalate_ticket}
-)
-
-def handle_it_query(query: str) -> str:
-    """Process IT queries through the multi-agent workflow"""
-    query = query.strip()
-    if not query:
-        return "Please enter an IT question or issue."
-
-    workflow_logs = {"query": query}
-    
-    try:
-        # First determine if it's an IT issue through the Master Agent
-        master_proxy = UserProxyAgent(
-            name="MasterProxy", human_input_mode="NEVER", code_execution_config=False
-        )
-        master_prompt = f"User query: '{query}'. First, determine if this is an IT-related issue."
-        master_proxy.initiate_chat(master_agent, message=master_prompt, max_turns=1)
-        initial_assessment = master_proxy.chat_messages[master_agent][-1]["content"]
-        workflow_logs["initial_assessment"] = initial_assessment
-        
-        # If not IT-related, return the response directly
-        if "NOT IT-RELATED" in initial_assessment.upper():
-            return initial_assessment
-        
-        # Planning
-        plan_proxy = UserProxyAgent(
-            name="PlanningProxy", human_input_mode="NEVER", code_execution_config=False
-        )
-        plan_proxy.initiate_chat(planning_agent, message=query, max_turns=1)
-        planning_output = plan_proxy.chat_messages[planning_agent][-1]["content"]
-        workflow_logs["planning"] = planning_output
-        logger.info(f"Planning completed: {len(planning_output)} chars")
-
-        # 2: Analysis
-        analysis_proxy = UserProxyAgent(
-            name="AnalysisProxy", human_input_mode="NEVER", code_execution_config=False
-        )
-        analysis_proxy.initiate_chat(analysis_agent, message=planning_output, max_turns=1)
-        analysis_output = analysis_proxy.chat_messages[analysis_agent][-1]["content"]
-        workflow_logs["analysis"] = analysis_output
-        logger.info(f"Analysis completed: {len(analysis_output)} chars")
-
-        #  3: Resolution
-        res_proxy = UserProxyAgent(
-            name="ResolutionProxy", human_input_mode="NEVER", code_execution_config=False
-        )
-        resolution_input = f"User Query: {query}\n\nPlanning: {planning_output}\n\nAnalysis: {analysis_output}"
-        res_proxy.initiate_chat(resolution_agent, message=resolution_input, max_turns=1)
-        resolution_output = res_proxy.chat_messages[resolution_agent][-1]["content"]
-        workflow_logs["resolution"] = resolution_output
-        logger.info(f"Resolution completed: {len(resolution_output)} chars")
-
-        # Escalation if needed
-        escalation_output = None
-        if "ESCALATION NEEDED" in resolution_output.upper():
-            esc_proxy = UserProxyAgent(
-                name="EscalationProxy", human_input_mode="NEVER", code_execution_config=False
-            )
-            escalation_input = f"Original Query: {query}\n\nAnalysis: {analysis_output}\n\nResolution Attempt: {resolution_output}"
-            esc_proxy.initiate_chat(escalation_agent, message=escalation_input, max_turns=1)
-            escalation_output = esc_proxy.chat_messages[escalation_agent][-1]["content"]
-            workflow_logs["escalation"] = escalation_output
-            logger.info(f"Escalation completed: {len(escalation_output)} chars")
-
-        # Master summarizes
-        final_master_proxy = UserProxyAgent(
-            name="FinalMasterProxy", human_input_mode="NEVER", code_execution_config=False
-        )
-        
-        if escalation_output:
-            final_prompt = (
-                f"Complete workflow results for query: '{query}':\n\n"
-                f"Planning: {planning_output}\n\n"
-                f"Analysis: {analysis_output}\n\n"
-                f"Resolution: {resolution_output}\n\n"
-                f"Escalation: {escalation_output}\n\n"
-                f"Synthesize these results into a clear, helpful response for the user."
-            )
-        else:
-            final_prompt = (
-                f"Complete workflow results for query: '{query}':\n\n"
-                f"Planning: {planning_output}\n\n"
-                f"Analysis: {analysis_output}\n\n"
-                f"Resolution: {resolution_output}\n\n"
-                f"Synthesize these results into a clear, helpful response for the user."
-            )
-        
-        final_master_proxy.initiate_chat(master_agent, message=final_prompt, max_turns=1)
-        final_response = final_master_proxy.chat_messages[master_agent][-1]["content"]
-        workflow_logs["final_response"] = final_response
-
-        # Save to memory
-        st.session_state.chat_history.append({
-            "user": query, 
-            "assistant": final_response,
-            "workflow_logs": workflow_logs
-        })
-        
-        return final_response
-
-    except Exception as e:
-        logger.error(f"Error in workflow: {e}", exc_info=True)
-        return f"An error occurred during processing: {str(e)}\n\nPlease try rephrasing your question."
-
-# Streamlit UI Setup
-st.title("AI Help Desk")
-st.write("Ask any IT support question and our multi-agent system will assist you.")
-
-with st.form(key="query_form", clear_on_submit=True):
-    user_input = st.text_area("Describe your IT issue:", height=100)
-    show_logs = st.checkbox("Show workflow details", value=False)
-    submitted = st.form_submit_button("Submit")
-
-    if submitted:
-        if not user_input:
-            st.error("Please type a message before submitting.")
-        else:
-            with st.spinner("Processing your request through our agent workflow..."):
-                response = handle_it_query(user_input)
-            
-            st.markdown("### Response")
-            st.write(response)