cleaned branch, added final streaming callback handler

{innovation_pathfinder_ai/backend/app → app}/api/v1/agents/hf_mixtral_agent.py

@@ -5,8 +5,13 @@ from langchain.agents.format_scratchpad import format_log_to_str
 from langchain.agents.output_parsers import ReActJsonSingleInputOutputParser
 # Import things that are needed generically
 from langchain.tools.render import render_text_description
+from app.schemas.message_schema import (
+    IChatResponse,
+)
+from app.utils.utils import generate_uuid
 import os
 from dotenv import load_dotenv
+from app.utils.adaptive_cards.cards import create_adaptive_card
 from app.structured_tools.structured_tools import (
     arxiv_search, get_arxiv_paper, google_search, wikipedia_search, knowledgeBase_search, memory_search
 )
@@ -17,43 +22,59 @@ from app.utils import logger
 from app.utils import utils
 from langchain.globals import set_llm_cache
 from langchain.cache import SQLiteCache
-from app.utils.callback import CustomAsyncCallbackHandler
+from app.utils.callback import (
+    CustomAsyncCallbackHandler,
+    CustomFinalStreamingStdOutCallbackHandler,
+)
+from langchain.memory import ConversationBufferMemory
+from app.core.config import settings
 
-set_llm_cache(SQLiteCache(database_path=".cache.db"))
+local_cache=settings.LOCAL_CACHE
+set_llm_cache(SQLiteCache(database_path=local_cache))
 logger = logger.get_console_logger("hf_mixtral_agent")
 
 config = load_dotenv(".env")
 HUGGINGFACEHUB_API_TOKEN = os.getenv('HUGGINGFACEHUB_API_TOKEN')
 GOOGLE_CSE_ID = os.getenv('GOOGLE_CSE_ID')
 GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
-LANGCHAIN_TRACING_V2 = "true"
-LANGCHAIN_ENDPOINT = "https://api.smith.langchain.com"
-LANGCHAIN_API_KEY = os.getenv('LANGCHAIN_API_KEY')
-LANGCHAIN_PROJECT = os.getenv('LANGCHAIN_PROJECT')
+# LANGCHAIN_TRACING_V2 = "true"
+# LANGCHAIN_ENDPOINT = "https://api.smith.langchain.com"
+# LANGCHAIN_API_KEY = os.getenv('LANGCHAIN_API_KEY')
+# LANGCHAIN_PROJECT = os.getenv('LANGCHAIN_PROJECT')
+# GOOGLE_CSE_ID=settings.GOOGLE_CSE_ID
+# GOOGLE_API_KEY=settings.GOOGLE_API_KEY
+# HUGGINGFACEHUB_API_TOKEN=settings.HUGGINGFACEHUB_API_TOKEN
+# print(HUGGINGFACEHUB_API_TOKEN)
 
 router = APIRouter()
 
+memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
 @router.websocket("/agent")
 async def websocket_endpoint(websocket: WebSocket):
     await websocket.accept()
+    if not settings.HUGGINGFACEHUB_API_TOKEN.startswith("hf_"):
+        await websocket.send_json({"error": "HUGGINGFACEHUB_API_TOKEN is not set"})
+        return
 
     while True:
         try:
             data = await websocket.receive_json()
             user_message = data["message"]
+            user_message_card = create_adaptive_card(user_message)
             chat_history = []#data["history"]
 
-            # resp = IChatResponse(
-            #     sender="you",
-            #     message=user_message_card.to_dict(),
-            #     type="start",
-            #     message_id=generate_uuid(),
-            #     id=generate_uuid(),
-            # )
+            resp = IChatResponse(
+                sender="you",
+                message=user_message_card.to_dict(),
+                type="start",
+                message_id=generate_uuid(),
+                id=generate_uuid(),
+            )
 
-            # await websocket.send_json(resp.dict())
+            await websocket.send_json(resp.model_dump())
             message_id: str = utils.generate_uuid()
-            custom_handler = CustomAsyncCallbackHandler(
+            custom_handler = CustomFinalStreamingStdOutCallbackHandler(
                  websocket, message_id=message_id
              )
 
@@ -106,6 +127,7 @@ async def websocket_endpoint(websocket: WebSocket):
                 #max_execution_time=60,  # timout at 60 sec
                 return_intermediate_steps=True,
                 handle_parsing_errors=True,
+                #memory=memory
                 )
             
             await agent_executor.arun(input=user_message, chat_history=chat_history, callbacks=[custom_handler])

{innovation_pathfinder_ai/backend/app → app}/core/config.py

@@ -1,5 +1,6 @@
 import os
-from pydantic import AnyHttpUrl, BaseSettings
+from pydantic import AnyHttpUrl, ConfigDict
+from pydantic_settings import BaseSettings
 from enum import Enum
 
 
@@ -15,9 +16,6 @@ class Settings(BaseSettings):
     MODE: ModeEnum = ModeEnum.development
     API_VERSION: str = "v1"
     API_V1_STR: str = f"/api/{API_VERSION}"
-    OPENAI_API_KEY: str
-    UNSPLASH_API_KEY: str
-    SERP_API_KEY: str
     HUGGINGFACEHUB_API_TOKEN: str
     GOOGLE_CSE_ID: str
     GOOGLE_API_KEY: str
@@ -25,10 +23,11 @@ class Settings(BaseSettings):
     CONVERSATION_COLLECTION_NAME: str
     EMBEDDING_MODEL: str
     SOURCES_CACHE: str
+    LOCAL_CACHE: str
 
     class Config:
         case_sensitive = True
-        env_file = os.path.expanduser("~/.env")
+        env_file = os.path.expanduser(".env")
 
 
 settings = Settings()

{innovation_pathfinder_ai/backend/app → app}/crud/db_handler.py

@@ -2,11 +2,13 @@ from sqlmodel import SQLModel, create_engine, Session, select
 from app.database.db_schema import Sources
 from app.utils.logger import get_console_logger
 import os
-from dotenv import load_dotenv
+from app.core.config import settings
+#from dotenv import load_dotenv
 
-load_dotenv()
+#load_dotenv()
 
-sqlite_file_name = os.getenv('SOURCES_CACHE')
+#sqlite_file_name = os.getenv('SOURCES_CACHE')
+sqlite_file_name = settings.SOURCES_CACHE
 
 sqlite_url = f"sqlite:///{sqlite_file_name}"
 engine = create_engine(sqlite_url, echo=False)

{innovation_pathfinder_ai/backend/app → app}/main.py

@@ -1,18 +1,23 @@
 from fastapi import FastAPI
 from app.api.v1.api import api_router as api_router_v1
 from fastapi.responses import HTMLResponse
+from app.core.config import settings
 from app.templates.chat import chat_html
 #from app.core.config import settings
 from fastapi.middleware.cors import CORSMiddleware
 
-app = FastAPI()
-BACKEND_CORS_ORIGINS = ["*"]
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    version=settings.API_VERSION,
+    openapi_url=f"{settings.API_V1_STR}/openapi.json",
+)
+#BACKEND_CORS_ORIGINS = ["*"]
 # CORS Middleware setup for allowing frontend requests
 # ToDO: replace with settings.BACKEND_CORS_ORIGINS once core/config.py is implemented
-if BACKEND_CORS_ORIGINS:
+if settings.BACKEND_CORS_ORIGINS:
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=[str(origin) for origin in BACKEND_CORS_ORIGINS],
+        allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
         allow_credentials=True,
         allow_methods=["*"],
         allow_headers=["*"],

{innovation_pathfinder_ai/backend/app → app}/structured_tools/structured_tools.py

@@ -8,9 +8,10 @@ from langchain_community.utilities import GoogleSearchAPIWrapper
 from langchain_community.embeddings.sentence_transformer import (
     SentenceTransformerEmbeddings,
 )
+from app.core.config import settings
 from langchain_community.vectorstores import Chroma
 import arxiv
-import ast
+#import ast
 
 import chromadb
 
@@ -34,7 +35,8 @@ from app.utils.utils import (
 import os
 # from app.utils import create_wikipedia_urls_from_text
 
-persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
+#persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
+persist_directory = settings.VECTOR_DATABASE_LOCATION
 
 @tool
 def memory_search(query:str) -> str:
@@ -45,11 +47,13 @@ def memory_search(query:str) -> str:
      path=persist_directory,
     )
     
-    collection_name = os.getenv('CONVERSATION_COLLECTION_NAME')
+    #collection_name = os.getenv('CONVERSATION_COLLECTION_NAME')
+    collection_name = settings.CONVERSATION_COLLECTION_NAME
     #store using envar
     
     embedding_function = SentenceTransformerEmbeddings(
-        model_name=os.getenv("EMBEDDING_MODEL"),
+        model_name=settings.EMBEDDING_MODEL
+        #model_name=os.getenv("EMBEDDING_MODEL"),
         )
     
     vector_db = Chroma(
@@ -75,7 +79,8 @@ def knowledgeBase_search(query:str) -> str:
     #store using envar
     
     embedding_function = SentenceTransformerEmbeddings(
-        model_name=os.getenv("EMBEDDING_MODEL"),
+        #model_name=os.getenv("EMBEDDING_MODEL"),
+        model_name=settings.EMBEDDING_MODEL
         )
     
     vector_db = Chroma(
@@ -100,7 +105,7 @@ def arxiv_search(query: str) -> str:
     formatted_sources = format_arxiv_documents(data)
     #all_sources += formatted_sources
     parsed_sources = parse_list_to_dicts(formatted_sources)
-    #add_many(parsed_sources)
+    add_many(parsed_sources)
   
     return data.__str__()
 
@@ -149,7 +154,8 @@ def embed_arvix_paper(paper_id:str) -> None:
     #store using envar
     
     embedding_function = SentenceTransformerEmbeddings(
-        model_name=os.getenv("EMBEDDING_MODEL"),
+        #model_name=os.getenv("EMBEDDING_MODEL"),
+        model_name=settings.EMBEDDING_MODEL
         )
     
     full_path = os.path.join(pdf_directory, pdf_file_name)
@@ -170,7 +176,7 @@ def wikipedia_search(query: str) -> str:
     formatted_summaries = format_wiki_summaries(wikipedia_results)
     #all_sources += formatted_summaries
     parsed_summaries = parse_list_to_dicts(formatted_summaries)
-    #add_many(parsed_summaries)
+    add_many(parsed_summaries)
     #all_sources += create_wikipedia_urls_from_text(wikipedia_results)
     return wikipedia_results
 
@@ -183,7 +189,7 @@ def google_search(query: str) -> str:
     search_results:dict = websearch.results(query, 3)
     cleaner_sources =format_search_results(search_results)
     parsed_csources = parse_list_to_dicts(cleaner_sources)
-    #add_many(parsed_csources)
+    add_many(parsed_csources)
     #all_sources += cleaner_sources    
     
     return cleaner_sources.__str__()

{innovation_pathfinder_ai/backend/app → app}/templates/chat.py

@@ -6,10 +6,10 @@ chat_html = """
   </head>
   <body>
     <webchat-widget
-      widget-websocket="ws://localhost:8001/chat/agent"
+      widget-websocket="ws://localhost:8000/chat/agent"
       widget-color="#47A7F6"
-      widget-chat-avatar="https://icon-library.com/images/ai-icon/ai-icon-7.jpg"
-      widget-user-avatar="https://img2.freepng.es/20210721/osx/transparent-jedi-avatar-60f79d68da49c0.1144258416268404248941.jpg"
+      widget-chat-avatar="https://icon-library.com/images/bot-icon/bot-icon-1.jpg"
+      widget-user-avatar="https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQWR4hHJTiikyzCv6nc5OAkHPIHMD-ESsP-LFEaY2vVIjV6wqCt&s"
       widget-header="Bot"
       widget-subheader="Online"
       widget-placeholder="Send a message"

{innovation_pathfinder_ai/backend/app → app}/utils/chains.py

@@ -1,4 +1,5 @@
-from langchain import LLMChain, PromptTemplate
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
 from langchain_community.llms import HuggingFaceEndpoint
 
 import re

{innovation_pathfinder_ai/backend/app → app}/vector_store/chroma_vector_store.py

@@ -23,11 +23,13 @@ from langchain_community.embeddings.sentence_transformer import (
 from app.utils.utils import (
     generate_uuid    
 )
-import dotenv
-import os
+from app.core.config import settings
+# import dotenv
+# import os
 
-dotenv.load_dotenv()
-persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
+# dotenv.load_dotenv()
+# persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
+persist_directory = settings.VECTOR_DATABASE_LOCATION
 
 
 def read_markdown_file(file_path: str) -> str:
@@ -96,7 +98,8 @@ def add_markdown_to_collection(
         )
     
     embedding_function = SentenceTransformerEmbeddings(
-        model_name=os.getenv("EMBEDDING_MODEL"),
+        #model_name=os.getenv("EMBEDDING_MODEL"),
+        model_name=settings.EMBEDDING_MODEL
         )
 
     documents_page_content:list = [i.page_content for i in splits]
@@ -178,7 +181,8 @@ def add_pdf_to_vector_store(
     )
     
     embedding_function = SentenceTransformerEmbeddings(
-        model_name=os.getenv("EMBEDDING_MODEL"),
+        #model_name=os.getenv("EMBEDDING_MODEL"),
+        model_name=settings.EMBEDDING_MODEL
         )
     
     documents_page_content:list = [i.page_content for i in split_docs]
@@ -236,7 +240,8 @@ if __name__ == "__main__":
     
     # create the open-source embedding function
     embedding_function = SentenceTransformerEmbeddings(
-        model_name=os.getenv("EMBEDDING_MODEL"),
+        #model_name=os.getenv("EMBEDDING_MODEL"),
+        model_name=settings.EMBEDDING_MODEL
         )
     
     #method of integrating Chroma and Langchain

{innovation_pathfinder_ai/backend/app → app}/vector_store/initialize_chroma_db.py

@@ -1,14 +1,17 @@
 from langchain_community.vectorstores import Chroma
+from app.core.config import settings
 import chromadb
-import dotenv
-import os
+#import dotenv
+#import os
 
-dotenv.load_dotenv()
-persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
+#dotenv.load_dotenv()
+#persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
+persist_directory = settings.VECTOR_DATABASE_LOCATION
 
 def initialize_chroma_db() -> Chroma:
-    collection_name = os.getenv('CONVERSATION_COLLECTION_NAME')
-    
+    #collection_name = os.getenv('CONVERSATION_COLLECTION_NAME')
+    collection_name = settings.CONVERSATION_COLLECTION_NAME
+
     client = chromadb.PersistentClient(
         path=persist_directory
         )

innovation_pathfinder_ai/frontend/app.py

@@ -1,143 +0,0 @@
-from fastapi import FastAPI
-import gradio as gr
-from gradio.themes.base import Base
-#from innovation_pathfinder_ai.backend.app.api.v1.agents.hf_mixtral_agent import agent_executor
-#from innovation_pathfinder_ai.source_container.container import (
-#    all_sources
-#)
-#from innovation_pathfinder_ai.backend.app.utils.utils import extract_urls
-#from innovation_pathfinder_ai.backend.app.utils import logger
-#from innovation_pathfinder_ai.backend.app.vector_store.chroma_vector_store import initialize_chroma_db
-#from innovation_pathfinder_ai.backend.app.utils.utils import (
-#    generate_uuid    
-#)
-from langchain_community.vectorstores import Chroma
-
-import asyncio
-import websockets
-import json
-import dotenv
-import os
-
-dotenv.load_dotenv()
-persist_directory = os.getenv('VECTOR_DATABASE_LOCATION')
-
-#logger = logger.get_console_logger("app")
-
-app = FastAPI()
-
-if __name__ == "__main__":
-    
-    #db = initialize_chroma_db()
-    
-    def add_text(history, text):
-        history = history + [(text, None)]
-        return history, ""
-
-    def bot(history):
-        response = infer(history[-1][0], history)
-        # Existing logic remains the same up to the point where you need to call backend operations
-        # Example for calling generate_uuid from the backend
-        # response = requests.post("http://localhost:8000/add-document")
-        #current_id = response.text
-        # sources = extract_urls(all_sources)
-        # src_list = '\n'.join(sources)
-        # current_id = generate_uuid()
-        # db.add(
-        #     ids=[current_id],
-        #     documents=[response['output']],
-        #     metadatas=[
-        #         {
-        #             "human_message":history[-1][0],
-        #             "sources": 'Internal Knowledge Base From: \n\n' + src_list
-        #         }
-        #     ]
-        # )
-        # if not sources:
-        #     response_w_sources = response['output']+"\n\n\n Sources:  \n\n\n Internal knowledge base"
-        # else:
-        #     response_w_sources = response['output']+"\n\n\n Sources: \n\n\n"+src_list
-        print(response)
-        history[-1][1] = response['output']
-       # all_sources.clear()
-        return history
-    
-    async def ask_question_async(question, history):
-        uri = "ws://localhost:8000/chat/agent"  # Update this URI to your actual WebSocket endpoint
-        async with websockets.connect(uri) as websocket:
-            # Prepare the message to send (adjust the structure as needed for your backend)
-            message_data = {
-                "message": question,
-                "history": history
-            }
-            json_data = json.dumps(message_data)
-            await websocket.send(json_data)
-
-            # Wait for the response
-            response_data = await websocket.recv()
-            return json.loads(response_data)
-
-    def infer(question, history):
-        # result = agent_executor.invoke(
-        #     {
-        #         "input": question,
-        #         "chat_history": history
-        #     }
-        # )        
-        # return result
-        try:
-            # Ensure there's an event loop to run async code
-            loop = asyncio.get_event_loop()
-        except RuntimeError as ex:
-            if "There is no current event loop" in str(ex):
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-
-        result = loop.run_until_complete(ask_question_async(question, history))
-        return result
-
-        # Run the asynchronous function in the synchronous context
-        result = asyncio.get_event_loop().run_until_complete(ask_question_async(question, history))
-        return result
-
-    def vote(data: gr.LikeData):
-        if data.liked:
-            print("You upvoted this response: " + data.value)
-        else:
-            print("You downvoted this response: " + data.value)
-
-    css="""
-    #col-container {max-width: 700px; margin-left: auto; margin-right: auto;}
-    """
-
-    title = """
-    <div style="text-align:left;">
-        <p>Hello Human, I am your AI knowledge research assistant. I can explore topics across ArXiv, Wikipedia and use Google search.<br />
-    </div>
-    """
-
-    with gr.Blocks(theme=gr.themes.Soft(), title="AlfredAI - AI Knowledge Research Assistant") as demo:
-       # with gr.Tab("Google|Wikipedia|Arxiv"):
-            with gr.Column(elem_id="col-container"):
-                gr.HTML(title)
-                with gr.Row():
-                    question = gr.Textbox(label="Question", 
-                                          placeholder="Type your question and hit Enter",)
-                chatbot = gr.Chatbot([], 
-                                     elem_id="AI Assistant",
-                                     bubble_full_width=False,
-                                     avatar_images=(None, "./assets/avatar.png"),
-                                     height=480,)
-                chatbot.like(vote, None, None)
-                clear = gr.Button("Clear")
-            question.submit(add_text, [chatbot, question], [chatbot, question], queue=False).then(
-                bot, chatbot, chatbot
-            )
-            clear.click(lambda: None, None, chatbot, queue=False)
-            with gr.Accordion("Open for More!", open=False):
-                gr.Markdown("Nothing yet...")
-
-    demo.queue().launch(debug=True, favicon_path="assets/favicon.ico", share=True)
-
-    x = 0 # for debugging purposes
-    app = gr.mount_gradio_app(app, demo, path="/")

innovation_pathfinder_ai/source_container/container.py

@@ -1 +0,0 @@
-all_sources = []