Upload 3 files

app.py

@@ -0,0 +1,155 @@
+import streamlit as st
+import time
+from autism_chatbot import *
+
+class StreamHandler:
+    def __init__(self, placeholder):
+        self.text = ""
+        self.text_container = placeholder
+
+    def append_text(self, text: str) -> None:
+        self.text += text
+        self.text_container.markdown(self.text)
+
+class StreamingGroqLLM(GroqLLM):
+    stream_handler: Any = Field(None, description="Stream handler for real-time output")
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs: Any) -> str:
+        completion = self.client.chat.completions.create(
+            messages=[{"role": "user", "content": prompt}],
+            model=self.model_name,
+            stream=True,
+            **kwargs
+        )
+        
+        collected_chunks = []
+        collected_messages = []
+
+        for chunk in completion:
+            chunk_message = chunk.choices[0].delta.content
+            if chunk_message is not None:
+                collected_chunks.append(chunk_message)
+                collected_messages.append(chunk_message)
+                if self.stream_handler:
+                    self.stream_handler.append_text(chunk_message)
+                    time.sleep(0.05)
+
+        return ''.join(collected_messages)
+
+class StreamingAutismResearchBot(AutismResearchBot):
+    def __init__(self, groq_api_key: str, stream_handler: StreamHandler, index_path: str = "faiss_index"):
+        self.llm = StreamingGroqLLM(
+            groq_api_key=groq_api_key,
+            model_name="llama-3.3-70b-versatile",
+            stream_handler=stream_handler
+        )
+        
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="./local_model",
+            model_kwargs={'device': 'cpu'}
+        )
+        self.db = FAISS.load_local(index_path, self.embeddings, allow_dangerous_deserialization=True)
+        
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True,
+            output_key="answer"
+        )
+        
+        self.qa_chain = self._create_qa_chain()
+
+def main():
+    # Page configuration
+    st.set_page_config(
+        page_title="Autism Research Assistant",
+        page_icon="🧩",
+        layout="wide"
+    )
+
+    # Add custom CSS
+    st.markdown("""
+        <style>
+        .stApp {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        .stMarkdown {
+            font-size: 16px;
+        }
+        .chat-message {
+            padding: 1rem;
+            border-radius: 0.5rem;
+            margin-bottom: 1rem;
+        }
+        .timestamp {
+            font-size: 0.8em;
+            color: #666;
+        }
+        </style>
+    """, unsafe_allow_html=True)
+
+    # Header
+    st.title("🧩 Autism Research Assistant")
+    st.markdown("""
+    Welcome to your AI-powered autism research assistant. I'm here to provide evidence-based 
+    assessments and therapy recommendations based on scientific research.
+    """)
+
+    # Initialize session state
+    if 'messages' not in st.session_state:
+        st.session_state.messages = [
+            {"role": "assistant", "content": "Hello! I'm your autism research assistant. How can I help you today?"}
+        ]
+
+    # Initialize bot
+    if 'bot' not in st.session_state:
+        st.session_state.stream_container = None
+        st.session_state.bot = None
+
+    # Display chat messages
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.write(f"{message['content']}")
+            st.caption(f"{time.strftime('%I:%M %p')}")
+
+    # Chat input
+    if prompt := st.chat_input("Type your message here..."):
+        # Display user message
+        with st.chat_message("user"):
+            st.write(prompt)
+            st.caption(f"{time.strftime('%I:%M %p')}")
+        
+        # Add to session state
+        st.session_state.messages.append({"role": "user", "content": prompt})
+
+        # Create a new chat message container for the assistant's response
+        assistant_message = st.chat_message("assistant")
+        with assistant_message:
+            # Create a placeholder for the streaming text
+            stream_placeholder = st.empty()
+            
+            # Initialize the bot with the new stream handler if not already initialized
+            if st.session_state.bot is None:
+                stream_handler = StreamHandler(stream_placeholder)
+                st.session_state.bot = StreamingAutismResearchBot(
+                    groq_api_key="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",
+                    stream_handler=stream_handler,
+                )
+            else:
+                # Update the stream handler with the new placeholder
+                st.session_state.bot.llm.stream_handler.text = ""
+                st.session_state.bot.llm.stream_handler.text_container = stream_placeholder
+
+            # Generate response
+            response = st.session_state.bot.answer_question(prompt)
+            
+            # Clear the streaming placeholder and display the final message
+            stream_placeholder.empty()
+            st.write(response['answer'])
+            st.caption(f"{time.strftime('%I:%M %p')}")
+            
+        # Add bot response to session state
+        st.session_state.messages.append({"role": "assistant", "content": response['answer']})
+
+if __name__ == "__main__":
+    main()

autism_chatbot.py

@@ -0,0 +1,194 @@
+from langchain.chains import ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+from langchain.prompts import PromptTemplate
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain.llms.base import LLM
+from groq import Groq
+from typing import Any, List, Optional, Dict
+from pydantic import Field, BaseModel
+import os
+
+
+class GroqLLM(LLM, BaseModel):
+    groq_api_key: str = Field(..., description="Groq API Key")
+    model_name: str = Field(default="llama-3.3-70b-versatile", description="Model name to use")
+    client: Optional[Any] = None
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.client = Groq(api_key=self.groq_api_key)
+    
+    @property
+    def _llm_type(self) -> str:
+        return "groq"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None, **kwargs: Any) -> str:
+        completion = self.client.chat.completions.create(
+            messages=[{"role": "user", "content": prompt}],
+            model=self.model_name,
+            **kwargs
+        )
+        return completion.choices[0].message.content
+    
+    @property
+    def _identifying_params(self) -> Dict[str, Any]:
+        """Get the identifying parameters."""
+        return {
+            "model_name": self.model_name
+        }
+
+
+class AutismResearchBot:
+    def __init__(self, groq_api_key: str, index_path: str = "faiss_index"):
+        # Initialize the Groq LLM
+        self.llm = GroqLLM(
+            groq_api_key=groq_api_key,
+            model_name="llama-3.3-70b-versatile"  # You can adjust the model as needed
+        )
+        
+        # Load the FAISS index
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name="pritamdeka/S-PubMedBert-MS-MARCO",
+            model_kwargs={'device': 'cpu'}
+        )
+
+        self.db = FAISS.load_local(index_path, self.embeddings, allow_dangerous_deserialization = True)
+        
+        # Initialize memory
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True,
+            output_key = "answer"
+        )
+        
+        # Create the RAG chain
+        self.qa_chain = self._create_qa_chain()
+    
+    def _create_qa_chain(self):
+        # Define the prompt template
+        template = """You are an expert AI assistant specialized in autism research and diagnostics. You have access to a database of scientific papers, research documents, and diagnostic tools about autism. Use this knowledge to ask targeted questions, gather relevant information, and provide an accurate, evidence-based assessment of the type of autism the person may have. Finally, offer appropriate therapy recommendations.
+
+Context from scientific papers use these context details only when you will at the end provide therapies don't dicusss these midway betwenn the conversation:
+
+{context}
+
+Chat History:
+{chat_history}
+
+Objective:
+
+Ask a series of insightful, diagnostic questions to gather comprehensive information about the individual's or their child's behaviors, challenges, and strengths.
+Analyze the responses given to these questions using knowledge from the provided research context.
+Determine the type of autism the individual may have based on the gathered data.
+Offer evidence-based therapy recommendations tailored to the identified type of autism.
+Instructions:
+
+Introduce yourself in the initial message. Please note not to reintroduce yourself in subsequent messages within the same chat.
+Each question should be clear, accessible, and empathetic while maintaining scientific accuracy.
+Ensure responses and questions demonstrate sensitivity to the diverse experiences of individuals with autism and their families.
+Cite specific findings or conclusions from the research context where relevant.
+Acknowledge any limitations or uncertainties in the research when analyzing responses.
+Aim for conciseness in responses, ensuring clarity and brevity without losing essential details.
+Initial Introduction:
+“”"
+
+Hello, I am an AI assistant specialized in autism research and diagnostics. I am here to gather some information to help provide an evidence-based assessment and recommend appropriate therapies.
+
+“”"
+
+Initial Diagnostic Question:
+“”"
+
+To begin, can you describe some of the behaviors or challenges that prompted you to seek this assessment?
+
+“”"
+
+Subsequent Questions: (Questions should follow based on the user's answers, aiming to gather necessary details concisely)
+
+question :
+{question}
+
+Answer:"""
+
+        PROMPT = PromptTemplate(
+            template=template,
+            input_variables=["context", "chat_history", "question"]
+        )
+        
+        # Create the chain
+        chain = ConversationalRetrievalChain.from_llm(
+            llm=self.llm,
+            chain_type="stuff",
+            retriever=self.db.as_retriever(
+                search_type="similarity",
+                search_kwargs={"k": 3}
+            ),
+            memory=self.memory,
+            combine_docs_chain_kwargs={
+                "prompt": PROMPT
+            },
+            # verbose = True,
+            return_source_documents=True
+        )
+        
+        return chain
+    
+    def answer_question(self, question: str):
+        """
+        Process a question and return the answer along with source documents
+        """
+        result = self.qa_chain({"question": question})
+        
+        # Extract answer and sources
+        answer = result['answer']
+        sources = result['source_documents']
+        
+        # Format sources for reference
+        source_info = []
+        for doc in sources:
+            source_info.append({
+                'content': doc.page_content[:200] + "...",
+                'metadata': doc.metadata
+            })
+        
+        return {
+            'answer': answer,
+            'sources': source_info
+        }
+
+# Example usage
+if __name__ == "__main__":
+    groq_api_key = "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"
+    
+    # Initialize the bot
+    bot = AutismResearchBot(groq_api_key=groq_api_key)
+    
+    # Example question
+    # question = "What are the latest findings regarding sensory processing in autism?"
+    # response = bot.answer_question(question)
+    while(1):
+        print("*"*40)
+        print("*"*40)
+        print("*"*40)
+        question = input("Enter your question (or 'quit' to exit): ")
+        if question.lower() == 'quit':
+            break
+        response = bot.answer_question(question)
+        print("\nAnswer:")
+        print(response['answer'])
+        # print("\nSources used:")
+        # for source in response['sources']:
+        #     print(f"\nSource metadata: {source['metadata']}")
+        #     print(f"Content preview: {source['content']}")
+        #     bot.answer_question
+    # Print response
+    # print("\nAnswer:")
+    # print(response['answer'])
+    # print("\nSources used:")
+    # for source in response['sources']:
+    #     print(f"\nSource metadata: {source['metadata']}")
+    #     print(f"Content preview: {source['content']}")
+
+
+    

requirements.txt

@@ -0,0 +1,5 @@
+langchain
+langchain-community
+groq
+sentence-transformer
+streamlit