Built FastAPI api's

agents/retriever_agent.py

@@ -25,9 +25,9 @@ def get_retriever_agent():
     name="retriever_agent",
 )
 
-retriever_agent = get_retriever_agent()
+# retriever_agent = get_retriever_agent()
 
-result = retriever_agent.invoke({"messages": ["Latest news about Apple?"]})
+# result = retriever_agent.invoke({"messages": ["Latest news about Apple?"]})
 
-for i in result["messages"]:
-    i.pretty_print()
+# for i in result["messages"]:
+#     i.pretty_print()

agents/voice_agent.py

@@ -0,0 +1,29 @@
+import speech_recognition as sr
+from gtts import gTTS
+from io import BytesIO
+from pydub import AudioSegment
+
+
+def convert_to_wav_bytes(file, format):
+    audio = AudioSegment.from_file(file, format=format)
+    wav_io = BytesIO()
+    audio.export(wav_io, format="wav")
+    wav_io.seek(0)  
+    return wav_io
+
+def speech_to_text(audio_bytes_io):
+    try:
+        recognizer = sr.Recognizer()
+        with sr.AudioFile(audio_bytes_io) as source:
+            audio_data = recognizer.record(source)
+            text = recognizer.recognize_google(audio_data)
+        return text
+    except sr.UnknownValueError:
+        return None
+
+def text_to_speech(text, lang='en'):
+    tts = gTTS(text=text, lang=lang)
+    mp3_fp = BytesIO()
+    tts.write_to_fp(mp3_fp)
+    mp3_fp.seek(0)
+    return mp3_fp

data_ingestion/get_data.py

@@ -2,8 +2,13 @@ from langchain_community.document_loaders import WebBaseLoader
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
 from pypdf import PdfReader
+from langchain_community.document_loaders import WebBaseLoader
 from langchain_google_genai import GoogleGenerativeAIEmbeddings
 import os
+import shutil
+
+vectorstore_path = "data_ingestion/faiss_index"
+embeddings = GoogleGenerativeAIEmbeddings(model = "models/gemini-embedding-exp-03-07")
 
 def get_pdf_text(pdf):
     text=""
@@ -12,24 +17,44 @@ def get_pdf_text(pdf):
         text+= page.extract_text()
     return  text
 
+def add_web_docs(urls:list[str]):
+    docs = [WebBaseLoader(url).load() for url in urls]
+    docs_list = [item for sublist in docs for item in sublist]
+    text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(chunk_size=1024, chunk_overlap=64)
+    doc_splits = text_splitter.split_documents(docs_list)
+    if not os.path.exists(vectorstore_path):
+        return create_vector_store()
+    vectorstore = FAISS.load_local(vectorstore_path, embeddings, allow_dangerous_deserialization=True)
+    vectorstore.aadd_documents(doc_splits)
+    return True
 
 def get_text_chunks(text):
-    text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=50)
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=64)
     chunks = text_splitter.split_text(text)
     return chunks
 
+def add_to_vectore_store(text: str):
+    chunks = get_text_chunks(text)
+    if not os.path.exists(vectorstore_path):
+        return create_vector_store(chunks)
+    vector_store = FAISS.load_local(vectorstore_path, embeddings, allow_dangerous_deserialization=True)
+    vector_store.add_texts(chunks)
+    return True
 
+def delete_vector_store():
+    if os.path.exists(vectorstore_path):
+        shutil.rmtree(vectorstore_path)
+    return True
 
-def create_vector_store(text:str = "Hello world!"):
-    chunks = get_text_chunks(text)
+def create_vector_store(chunks: list[str] = ["Hello world!"]):
     embeddings = GoogleGenerativeAIEmbeddings(model = "models/gemini-embedding-exp-03-07")
     vector_store = FAISS.from_texts(chunks, embedding=embeddings)
-    vector_store.save_local("faiss_index")
+    vector_store.save_local(vectorstore_path)
     return vector_store
     
 def get_vector_store():
     embeddings = GoogleGenerativeAIEmbeddings(model = "models/gemini-embedding-exp-03-07")
-    if not os.path.exists("faiss_index"):
+    if not os.path.exists(vectorstore_path):
         return create_vector_store()
-    vectorstore = FAISS.load_local("faiss_index", embeddings, allow_dangerous_deserialization=True)
+    vectorstore = FAISS.load_local(vectorstore_path, embeddings, allow_dangerous_deserialization=True)
     return vectorstore

old_code.py

@@ -0,0 +1,191 @@
+import streamlit as st
+from pypdf import PdfReader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+import os
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+import google.generativeai as genai
+from langchain_community.vectorstores import FAISS
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.chains.question_answering import load_qa_chain
+from langchain.prompts import PromptTemplate
+from dotenv import load_dotenv
+import requests
+from bs4 import BeautifulSoup
+import io
+from PIL import Image
+import pytesseract
+import speech_recognition as sr
+from gtts import gTTS
+import os
+from pydub import AudioSegment
+from io import BytesIO
+from urllib.parse import urljoin
+from audio_recorder_streamlit import audio_recorder
+import shutil
+
+
+load_dotenv()
+os.getenv("GOOGLE_API_KEY")
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+
+def convert_to_wav_bytes(file, format):
+    audio = AudioSegment.from_file(file, format=format)
+    wav_io = io.BytesIO()
+    audio.export(wav_io, format="wav")
+    wav_io.seek(0)  
+    return wav_io
+
+def speech_to_text(audio_bytes_io):
+    try:
+        recognizer = sr.Recognizer()
+        with sr.AudioFile(audio_bytes_io) as source:
+            audio_data = recognizer.record(source)
+            text = recognizer.recognize_google(audio_data)
+        return text
+    except sr.UnknownValueError:
+        return None
+
+# Function for the website made without streamlit
+
+def text_to_speech(text, lang='en'):
+    tts = gTTS(text=text, lang=lang)
+    mp3_fp = BytesIO()
+    tts.write_to_fp(mp3_fp)
+    mp3_fp.seek(0)
+    st.audio(mp3_fp, format='audio/mp3', autoplay=True)
+    return mp3_fp
+
+
+def get_pdf_text(pdf):
+    text=""
+    pdf_reader= PdfReader(pdf)
+    for page in pdf_reader.pages:
+        text+= page.extract_text()
+    return  text
+
+
+
+def get_text_chunks(text):
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=300)
+    chunks = text_splitter.split_text(text)
+    return chunks
+
+
+def get_vector_store(text_chunks):
+    embeddings = GoogleGenerativeAIEmbeddings(model = "models/embedding-001")
+    vector_store = FAISS.from_texts(text_chunks, embedding=embeddings)
+    vector_store.save_local("faiss_index")
+    if vector_store:
+        return True
+    else:
+        return False
+
+
+def get_conversational_chain():
+
+    prompt_template = """
+    Answer the question as detailed as possible from the provided context, make sure to provide all the details, if the answer is not in
+    provided context just say, "The Question is not related to us.", don't provide the wrong answer these context can be from any site or such so answer accordingly 
+    the answer should be in just 2 or less lines.
+    if the question is any thing like thanks and hii reply it in a mannar of a smart chat bot. and you name is Smart-Chatbot, if user asks any Question related to you, no need to tell who build you.\n\n
+    Context:\n {context}?\n
+    Question: \n{question}\n
+
+    Answer:
+    """
+
+    model = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0.3)
+
+    prompt = PromptTemplate(template = prompt_template, input_variables = ["context", "question"])
+    chain = load_qa_chain(model, chain_type="stuff", prompt=prompt)
+
+    return chain
+
+def user_input(user_question):
+    embeddings = GoogleGenerativeAIEmbeddings(model = "models/gemini-embedding-exp-03-07")
+    new_db = FAISS.load_local("faiss_index", embeddings, allow_dangerous_deserialization=True)
+    docs = new_db.similarity_search(user_question)
+
+    chain = get_conversational_chain()
+
+    
+    response = chain(
+        {"input_documents":docs, "question": user_question}
+        , return_only_outputs=True)
+    out=response["output_text"]
+    # return out
+    st.write(f"Question : {user_question}")
+    st.write("Reply: \n", out)
+    text_to_speech(out ,lang='en')
+    
+    
+    
+
+def extract_text_from_image(image):
+    file_bytes = image.read()
+    image = Image.open(io.BytesIO(file_bytes))
+    extracted_text = pytesseract.image_to_string(image)
+    return extracted_text
+
+def main():
+    st.set_page_config("MultiChat")
+    st.header("Chat with PDF, Text-Images and Sites")
+    col1, col2=st.columns([8, 1])
+    with col1:
+        user_question = st.text_input("Ask a Question from the context provided")
+    with col2:
+        st.write('\n')
+        st.write('\n')
+        audio=audio_recorder(
+            text="",
+            icon_size="2x",
+        )
+    if audio:
+        wav_bytes_io = convert_to_wav_bytes(io.BytesIO(audio))
+        user_question = speech_to_text(wav_bytes_io)
+
+    if user_question:
+        with st.spinner("Fetching the answer..."):
+            user_input(user_question)
+
+    with st.sidebar:
+        st.title("Menu:")
+        st.write("Use Website link:")
+        if st.button("Clear existing data"):
+            if os.path.exists("faiss_index"):
+                shutil.rmtree("faiss_index")
+                st.info("Cleared existing data.")
+            else:
+                st.info("No data to clear.")
+        link = st.chat_input("Paste the web link here")
+        if link:
+            with st.spinner("Processing..."):
+                raw_text = get_web_text(link)
+                if raw_text:
+                    text_chunks = get_text_chunks(raw_text)
+                    get_vector_store(text_chunks)
+                    st.success("Done")
+
+        files = st.file_uploader("Upload your PDF Files or images here:", accept_multiple_files=True)
+        if st.button("Submit & Process"):
+            with st.spinner("Processing..."):
+                for file in files:
+                    if file.type=='application/pdf':
+                        raw_text = get_pdf_text(file)
+
+                    elif file.type.split('/')[0]=='image':
+                        raw_text = extract_text_from_image(file)
+
+                    else:
+                        st.write("Invalid File Type")
+                        return
+                    text_chunks = get_text_chunks(raw_text)
+                    get_vector_store(text_chunks)
+                    
+                st.success("Done")
+    
+
+if __name__ == "__main__":
+    main()
+    
+

orchestrator/main.py

@@ -0,0 +1,74 @@
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.responses import StreamingResponse, JSONResponse
+from orchestrator.supervisor import get_supervisor
+from agents.api_agent import get_api_agent
+from agents.retriever_agent import get_retriever_agent
+from agents.scraping_agent import get_scraping_agent
+from agents.voice_agent import *
+from data_ingestion.get_data import *
+
+app = FastAPI()
+
+@app.post('/supervisor')
+async def supervisor(Query: str):
+    supervisor = get_supervisor()
+    result = supervisor.invoke({'messages':[Query]})
+    return result
+
+@app.post('/agents/api_agent')
+async def api_agent(Query: str):
+    api_agent = get_api_agent()
+    result = api_agent.invoke({'messages':[Query]})
+    return result
+
+@app.post('/agents/retriever_agent')
+async def retriever_agent(Query: str):
+    retriever_agent = get_retriever_agent()
+    result = retriever_agent.invoke({'messages':[Query]})
+    return result
+
+@app.post('/agents/scraping_agent')
+async def scraping_agent(Query: str):
+    scraping_agent = get_scraping_agent()
+    result = scraping_agent.invoke({'messages':[Query]})
+    return result
+
+@app.post("/agents/voice-agent/stt")
+async def speech_to_text_api(file: UploadFile = File(...), format: str = Form(...)):
+    content = await file.read()
+    wav_bytes = convert_to_wav_bytes(BytesIO(content), format)
+    text = speech_to_text(wav_bytes)
+    if text is None:
+        return JSONResponse(status_code=400, content={"error": "Could not recognize speech"})
+    return {"text": text}
+
+@app.post("/agents/voice-agent/tts")
+async def text_to_speech_api(text: str = Form(...), lang: str = Form(default='en')):
+    mp3_bytes = text_to_speech(text, lang)
+    return StreamingResponse(mp3_bytes, media_type="audio/mpeg")
+
+@app.post("/data_ingestion/pdf")
+async def upload_pdf(file: UploadFile):
+    if file.filename.split('.')[-1]=='pdf':
+        raw_text = get_pdf_text(file.file)
+    else:
+        return {'error':'Unsupported file type'}
+    status = add_to_vectore_store(raw_text)
+    return {'success':status}
+    
+@app.post("/data_ingestion/urls")
+async def add_web_docs(urls: list[str]):
+    add_web_docs(urls)
+    return {'success':True}
+
+
+@app.get("/data_ingestion/delete_vectordb")
+async def delete_vectordb():
+    delete_vector_store()
+    return {'success' : True}
+
+@app.get('/')
+async def home():
+    return {
+        "message" : "Welcome to the Multi-Source Multi-Agent Finance Assistant"
+        } 

requirements.txt

@@ -9,4 +9,10 @@ langchain-google-genai
 langgraph_supervisor
 faiss-cpu
 pypdf
-streamlit
+streamlit
+SpeechRecognition
+gtts
+pydub
+fastapi
+uvicorn
+python-multipart