add hfspace files

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,164 @@
+# default python gitignore
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Mac OS
+.DS_Store

README.md

@@ -0,0 +1,13 @@
+---
+title: {{title}}
+emoji: {{emoji}}
+colorFrom: {{colorFrom}}
+colorTo: {{colorTo}}
+sdk: {{sdk}}
+sdk_version: {{sdkVersion}}
+app_file: src/app.py
+pinned: false
+---
+
+# hello-sajal-sap
+Repo for SAP Gen AI Developer assessment. 

data/source.md

@@ -0,0 +1,145 @@
+# Sajal Sharma
+
+## Contact Info
+
++65 9077-9093 | [email protected] | [LinkedIn](linkedin.com/in/sajals) | [GitHub](github.com/sajal2692)
+
+## Professional Summary
+With over 7 years in the AI & ML space, my career is a testament
+to the pursuit of creating AI systems that not only enhance but
+harmonize with human life. Specializing in Natural Language
+Processing, I've led groundbreaking projects across Asia, focusing
+on transforming data into intuitive, meaningful experiences. My role
+is not just about engineering solutions; it's about envisioning a future
+where AI and humans coexist in a symbiotic relationship, fostering
+creativity and innovation.
+
+My expertise in Deep Learning technologies drives me to push
+boundaries in AI applications. Having led teams and projects from
+concept to implementation, I've helped businesses integrate AI
+into their core strategies, redefining efficiency and effectiveness.
+
+This experience underscores my commitment to leveraging AI for
+enhancing human capabilities and enriching everyday experiences.
+
+I am always eager to engage in discussions about AI's potential,
+whether it be through collaboration, consulting, or a simple exchange
+of ideas. The power of AI lies in collective effort and shared vision,
+and I'm passionate about being at the forefront of this exciting and
+evolving field.
+
+## Experience
+
+### Lead AI Engineer  
+**Aug 2023 – Present**  
+**OneByZero (contracted via Unscrambl), Singapore**
+- Spearheading the AI Engineering team, pioneering bleeding-edge AI solutions by integrating proprietary and open-source LLMs, RAG, and vector databases, alongside techniques like prompt engineering, chaining, function
+calling, and agent-based systems. Currently delivering transformative AI strategies across multiple high-value projects for clients throughout Asia.
+Page 1 of 5
+- Collaborated with key stakeholders to conceptualize and realize generative AI use cases, aligning innovative solutions with core business objectives to maximize operational and strategic impact.
+- Assisted the sales team in securing deals by preparing and presenting technical collateral, driving client engagement through expert communication of complex AI concepts.
+- Conducted technical workshops at client locations, promoting generative AI awareness and knowledge sharing, and reinforcing the company's position as an industry thought leader.
+- Developed a POC for an LLM-powered chatbot for a major bank in the Philippines, showcased at the Singapore Fintech Festival, utilizing AWS infrastructure, including Bedrock, Sagemaker & Opensearch, focusing on LLM
+safety and quality.
+- Revamped data processing for a major appliance retailer by leveraging LLMs to automate data extraction, cutting product data entry time from 2 hours to just 15 minutes, significantly boosting e-commerce efficiency and accuracy.
+- Improved the accuracy of a demand forecasting model for a major Thai Home Improvement retailer from 30% to 70%, employing deep learning time series forecasting, feature engineering and addressing data quality issues.
+
+### Senior AI Engineer  
+**Jan 2023 – Aug 2023**  
+**Splore, a Temasek-backed AI startup (contracted via Unscrambl), Singapore**
+- Led overall efforts to enhance the user search experience, resulting in a 50% reduction in incorrectly answered queries and a notable increase in user
+engagement.
+- Collaborated with Product Managers, Data Engineers, Data Scientists, and MLOps Engineers to align AI development with business objectives, enhancing
+strategic integration of AI capabilities.
+- Assisted in the expansion of the AI team from 2 to 6, focusing on roles in search engineering, NLP, MLOps with a diverse set of expertise areas including ranking algorithms and large language model applications.
+- Engineered an advanced NLP pipeline to analyze user queries, incorporating Symspell for spell checking, SpaCy for NER, semantic similarity for small talk detection, and ToxicBERT for profanity filtering, thereby enhancing query understanding and categorization.
+- Developed a question-answering system for queries about current affairs using Langchain, GPT model and Bing Search, which tripled user engagement and daily queries.
+- Developed an automated query-result dataset generation and labeling pipeline using GPT, LabelStudio, and Huggingface, facilitating pre-production performance evaluation of the search system.
+- Implemented rigorous data quality checkpoints using Great Expectations, in collaboration with the Data Engineering team, improving system efficiency and search result relevance.
+- Enhanced Vespa search engine performance, improving the Mean Average Precision (MAP) metric from 0.3 to 0.8 by refining ranking algorithms and integrating semantic search with vector embeddings, resulting in markedly
+improved search accuracy and user engagement.
+- Fine-tuned sentence transformer models for better embeddings, specifically targeting gaming-related vocabularies, which enhanced the relevance and precision of gaming query responses and contributed to improved user interaction with AI systems.
+
+### Senior Machine Learning Engineer  
+**Apr 2020 – Dec 2022**  
+**Unscrambl, India**
+- Key member of Unscrambl’s NLP Engineering team, helping enhance the natural language understanding of their business analytics platform. Focused on advancing NER, intent recognition, and ANNOY model functionalities.
+- Developed the NL to SQL system data preparation pipeline using NLTK and spaCy, cutting over 5 hours of manual effort daily and boosting system efficiency.
+
+### Machine Learning Engineer  
+**Aug 2017 – Apr 2020**  
+**Unscrambl, India**
+- Collaborated in a dynamic, cross-functional team of 6 to research, design, and develop NLP-driven chatbot products, aligning technological capabilities with market needs and user experiences.
+- Strategically coordinated with the customer solutions team to lead the deployment of chatbot solutions for clients across Asia, significantly impacting over 100,000 monthly users. Utilized Microsoft Bot Framework and Azure Cognitive Services for intent recognition and dialogue flows to ensure optimal performance and user engagement in diverse markets.
+
+## Education
+
+**The University of Melbourne**  
+Master of Information Technology, Major in Computing  
+Melbourne, Australia  
+Aug 2014 – Aug 2016
+
+**Bharatiya Vidyapeeth University**  
+Bachelor of Computer Applications  
+New Delhi, India  
+Jul 2010 – Jul 2013
+
+## Technical Skills
+
+- Languages: Python (Fluent), SQL (Proficient), Javascript (Proficient), Ruby (Familiar)
+- AI & ML Technologies: Huggingface, Sentence Transformers, Pytorch, GPT, Claude, llama, Langchain, BERT, SpaCy, NLTK
+- Tools & Frameworks: Git, Docker, AWS, Google Cloud Platform, Opensearch, Vespa, Pinecone, VsCode, Unix
+
+## Activities
+
+- Mentor & Project Reviewer, Udacity: Coached 100+ international students enrolled in Data Science courses. Recognised as an elite mentor in 2021 with A+ mentor performance grade based on student feedback scores.
+- Mentor, STEM Industry Mentoring Programme, The University of Melbourne: Jul 2020 - Present
+- Creator, Data Science Portfolio: Github repo with 900+ stars showcasing various classical Data Science projects.
+
+## Languages
+
+- Hindi (Native or Bilingual)
+- English (Native or Bilingual)
+- German (Elementary)
+
+
+## Certifications
+
+- **Practical Data Science on the AWS Cloud**  
+  DeepLearning.AI, Jan 2023
+
+- **Machine Learning Specialization**  
+  DeepLearning.AI, Jul 2022  
+  Skills: TensorFlow, Keras, Data Science
+
+- **Deep Learning Specialization**  
+  DeepLearning.AI, Apr 2022  
+  Skills: TensorFlow, Keras, Deep Learning, Data Science
+
+- **Natural Language Processing Nanodegree**  
+  Udacity, Jun 2020  
+  Skills: Deep Learning
+
+- **Mathematics for Machine Learning Specialization**  
+  Coursera, Nov 2019
+
+- **React Nanodegree**  
+  Udacity, Jan 2018
+
+- **Machine Learning Nanodegree**  
+  Udacity, Mar 2017
+
+- **Inferential Statistics**  
+  Coursera Course Certificates, Feb 2017
+
+- **Data Science and Machine Learning with R**  
+  Udemy, Dec 2016
+
+- **Introduction to Probability and Data**  
+  Coursera Course Certificates, Dec 2016
+
+## Hobbies
+- I love playing video games, listening to music and reading books in my free time!
+- My favourite games include The Last of Us series from Naughty Dog, and God of War from Sony Santa Monica.
+- My favourite music artists include Kendrick Lamar, Radiohead, & The Beatles. I love listening to indie rock and hip hop.
+- My favourite genre of books is non-fiction and magical realism. My favourite book is To Kill a Mockingbird.

requirements.txt

@@ -0,0 +1,160 @@
+aiofiles==23.2.1
+aiohttp==3.9.3
+aiosignal==1.3.1
+altair==5.2.0
+annotated-types==0.6.0
+anyio==4.3.0
+asgiref==3.7.2
+attrs==23.2.0
+backoff==2.2.1
+bcrypt==4.1.2
+beautifulsoup4==4.12.3
+build==1.0.3
+cachetools==5.3.2
+certifi==2024.2.2
+chardet==5.2.0
+charset-normalizer==3.3.2
+chroma-hnswlib==0.7.3
+chromadb==0.4.23
+click==8.1.7
+colorama==0.4.6
+coloredlogs==15.0.1
+contourpy==1.2.0
+cycler==0.12.1
+dataclasses-json==0.6.4
+dataclasses-json-speakeasy==0.5.11
+Deprecated==1.2.14
+distro==1.9.0
+emoji==2.10.1
+fastapi==0.109.2
+ffmpy==0.3.2
+filelock==3.13.1
+filetype==1.2.0
+flatbuffers==23.5.26
+fonttools==4.49.0
+frozenlist==1.4.1
+fsspec==2024.2.0
+google-auth==2.28.1
+googleapis-common-protos==1.62.0
+gradio==4.19.2
+gradio_client==0.10.1
+grpcio==1.62.0
+h11==0.14.0
+httpcore==1.0.4
+httptools==0.6.1
+httpx==0.27.0
+huggingface-hub==0.20.3
+humanfriendly==10.0
+idna==3.6
+importlib-metadata==6.11.0
+importlib-resources==6.1.1
+Jinja2==3.1.3
+joblib==1.3.2
+jsonpatch==1.33
+jsonpath-python==1.0.6
+jsonpointer==2.4
+jsonschema==4.21.1
+jsonschema-specifications==2023.12.1
+kiwisolver==1.4.5
+kubernetes==29.0.0
+langchain==0.1.9
+langchain-community==0.0.24
+langchain-core==0.1.26
+langchain-openai==0.0.7
+langchainhub==0.1.14
+langdetect==1.0.9
+langgraph==0.0.26
+langsmith==0.1.7
+lxml==5.1.0
+Markdown==3.5.2
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.20.2
+matplotlib==3.8.3
+mdurl==0.1.2
+mmh3==4.1.0
+monotonic==1.6
+mpmath==1.3.0
+multidict==6.0.5
+mypy-extensions==1.0.0
+nltk==3.8.1
+numpy==1.26.4
+oauthlib==3.2.2
+onnxruntime==1.17.0
+openai==1.12.0
+opentelemetry-api==1.23.0
+opentelemetry-exporter-otlp-proto-common==1.23.0
+opentelemetry-exporter-otlp-proto-grpc==1.23.0
+opentelemetry-instrumentation==0.44b0
+opentelemetry-instrumentation-asgi==0.44b0
+opentelemetry-instrumentation-fastapi==0.44b0
+opentelemetry-proto==1.23.0
+opentelemetry-sdk==1.23.0
+opentelemetry-semantic-conventions==0.44b0
+opentelemetry-util-http==0.44b0
+orjson==3.9.15
+overrides==7.7.0
+packaging==23.2
+pandas==2.2.1
+pillow==10.2.0
+posthog==3.4.2
+protobuf==4.25.3
+pulsar-client==3.4.0
+pyasn1==0.5.1
+pyasn1-modules==0.3.0
+pydantic==2.6.2
+pydantic_core==2.16.3
+pydub==0.25.1
+Pygments==2.17.2
+pyparsing==3.1.1
+PyPika==0.48.9
+pyproject_hooks==1.0.0
+python-dateutil==2.8.2
+python-dotenv==1.0.1
+python-iso639==2024.2.7
+python-magic==0.4.27
+python-multipart==0.0.9
+pytz==2024.1
+PyYAML==6.0.1
+rapidfuzz==3.6.1
+referencing==0.33.0
+regex==2023.12.25
+requests==2.31.0
+requests-oauthlib==1.3.1
+rich==13.7.0
+rpds-py==0.18.0
+rsa==4.9
+ruff==0.2.2
+semantic-version==2.10.0
+setuptools==68.2.2
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.0
+soupsieve==2.5
+SQLAlchemy==2.0.27
+starlette==0.36.3
+sympy==1.12
+tabulate==0.9.0
+tenacity==8.2.3
+tiktoken==0.6.0
+tokenizers==0.15.2
+tomlkit==0.12.0
+toolz==0.12.1
+tqdm==4.66.2
+typer==0.9.0
+types-requests==2.31.0.20240218
+typing-inspect==0.9.0
+typing_extensions==4.9.0
+tzdata==2024.1
+unstructured==0.11.8
+unstructured-client==0.18.0
+urllib3==2.2.1
+uvicorn==0.27.1
+uvloop==0.19.0
+watchfiles==0.21.0
+websocket-client==1.7.0
+websockets==11.0.3
+wheel==0.41.2
+wrapt==1.16.0
+yarl==1.9.4
+zipp==3.17.0

src/app.py

@@ -0,0 +1,43 @@
+import os 
+
+import gradio as gr
+
+from langchain_core.messages import AIMessage, HumanMessage
+from langchain_openai import ChatOpenAI
+from dotenv import load_dotenv
+
+from graph import AssistantGraph
+
+
+# load the environment variables
+load_dotenv()
+
+VECTOR_DB_PATH = "data/chroma_db"
+SOURCE_DATA_PATH = "data/source.md"
+
+# define llm
+llm = ChatOpenAI(model=os.getenv("OPENAI_MODEL"), temperature=0)
+
+# create instance of assistant graph
+app = AssistantGraph(llm=llm, vector_db_path=VECTOR_DB_PATH, source_data_path=SOURCE_DATA_PATH)
+
+def process_history(history):
+    """Return the history as a list of HumanMessage and AIMessage tuples"""
+    chat_history = []
+    for pair in history:
+        human_message, ai_message = pair
+        chat_history.append(HumanMessage(content=human_message))
+        chat_history.append(AIMessage(content=ai_message))
+    return chat_history
+
+def run(message, history):
+    chat_history = process_history(history[1:]) # ignore the auto message
+    inputs = {"keys": {"message": message, "history": chat_history}}
+    result = app.run(inputs)
+    response = result["keys"]["response"]
+    return response
+
+initial_message = "Hi there! I'm Saj, an AI assistant built by Sajal Sharma. I'm here to answer any questions you may have about Sajal. Ask me anything!"
+
+if __name__ == "__main__":
+    gr.ChatInterface(run, chatbot=gr.Chatbot(value=[[None, initial_message]])).launch(auth=("sap-review", "polo1010"))

src/chains/document_grader.py

@@ -0,0 +1,50 @@
+"""Implements the document grader chain"""
+
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.utils.function_calling import convert_to_openai_tool
+from langchain.output_parsers.openai_tools import PydanticToolsParser
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from textwrap import dedent
+
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Data model
+class grade(BaseModel):
+    """Binary score for relevance check."""
+    binary_score: str = Field(description="Relevance score 'yes' or 'no'")
+
+class DocumentGrader:
+    
+    """Implements the document grader chain"""
+    
+    _GRADER_PROMPT_TEMPLATE = """
+    You are a grader assessing relevance of a retrieved document to a user question. \n 
+    Retrieved document: \n\n {context} \n\n
+    User Question: {question} \n
+    When assessing the relevance of a retrieved document to a user question, consider whether the document can provide a complete answer to the question posed. A document is considered relevant only if it contains all the necessary information to fully answer the user's inquiry without requiring additional context or assumptions.
+    Give a binary score 'yes' or 'no' score to indicate whether the document is relevant to the question.
+    Do not return anything other than a 'yes' or 'no'.
+    """
+    
+    _GRADER_PROMPT = PromptTemplate(template=dedent(_GRADER_PROMPT_TEMPLATE), input_variables=["context", "question"])
+    
+    def __init__(self):
+        # seperate the model wrapper instance for the binded tool
+        llm = ChatOpenAI(temperature=0, model=os.environ["OPENAI_MODEL"])
+        grade_tool_oai = convert_to_openai_tool(grade)
+        # LLM with tool and enforce invocation
+        llm_with_tool = llm.bind(
+            tools=[grade_tool_oai],
+            tool_choice={"type": "function", "function": {"name": "grade"}},
+        )
+        # Parser
+        parser_tool = PydanticToolsParser(tools=[grade])
+        self._grader_chain = self._GRADER_PROMPT | llm_with_tool | parser_tool
+        
+    def run(self, question, context):
+        """Returns the response from the document grader"""
+        return self._grader_chain.invoke({"context": context, "question": question})

src/chains/intent_detection.py

@@ -0,0 +1,44 @@
+"""Implements the intents detection chain"""
+
+from langchain.chains import create_tagging_chain
+from langchain_core.prompts import ChatPromptTemplate
+from textwrap import dedent
+
+class IntentDetection:
+    
+    """Implements the intents detection chain"""
+
+    _SCHEMA = {
+        "properties": {
+            "intent": {
+                "type": "string",
+                "enum": ["smalltalk", "sajal_question"],
+                "description": "The intent of the user's message. The intent is sajal_question, if the user is asking questions about Sajal Sharma"
+                    "for example related to his contact info, work experience, educational background, certifications, hobbies, etc, or any other questions about him." 
+                    "Any questions about contact info, work experience, educational background, certifications, hobbies, should also be sajal_question."
+                    "General greetings or smalltalk messages are smalltalk. Questions about anyone other than sajal are also smalltalk."
+            }
+        }
+    }
+
+    _TAGGING_PROMPT = """Extract the desired information from the following passage.
+
+    Only extract the properties mentioned in the 'information_extraction' function.
+    Use the chat history to guide your extraction.
+
+    Chat History:
+    {history}
+
+    Passage:
+    {input}
+    """
+    _TAGGING_PROMPT_TEMPLATE = ChatPromptTemplate.from_template(dedent(_TAGGING_PROMPT))
+    
+    def __init__(self, llm):
+        self.tagging_chain = create_tagging_chain(self._SCHEMA, llm, prompt=self._TAGGING_PROMPT_TEMPLATE)
+    
+    def run(self, message, history):
+        """Returns the detected intent"""
+        result = self.tagging_chain.invoke({"input": message, "history": history})
+        return result["text"]["intent"]
+        

src/chains/qa_all_data.py

@@ -0,0 +1,27 @@
+"""Implements a QA chain to run using the full data."""
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+
+class QAAllData:
+    """Implements a QA chain to run using the full data"""
+
+    _PROMPT_TEMPLATE = """
+    You are an AI  assistant, Saj, built by Sajal Sharma, an AI Engineer.
+    Your main task is to answer questions people may have about Sajal. 
+    Use the following information about Sajal context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
+    Question: {question} 
+    Context: {context} 
+    Answer:
+    """
+
+    _PROMPT = ChatPromptTemplate.from_template(_PROMPT_TEMPLATE)
+
+    def __init__(self, llm, source_data_path):
+        with open(source_data_path, "r") as file:
+            self.full_markdown_document = file.read()
+        self.qa_all_data_chain = self._PROMPT | llm | StrOutputParser()
+
+    def run(self, question):
+        """Returns the response from the LLM to the user's message using all data."""
+        return self.qa_all_data_chain.invoke({"question": question, "context": self.full_markdown_document})

src/chains/rag.py

@@ -0,0 +1,35 @@
+"""Implements the RAG chain"""
+
+from langchain_core.prompts import format_document, PromptTemplate, ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from textwrap import dedent
+
+class RAG:
+    
+    """Implements the RAG chain"""
+    
+    _RAG_PROMPT = """
+    You are an AI  assistant, Saj, built by Sajal Sharma, an AI Engineer.
+    Your main task is to answer questions people may have about Sajal. 
+    Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
+    Question: {question} 
+    Context: {context} 
+    Answer:
+    """
+    
+    _DOCUMENT_SEPARATOR = "\n\n"
+    _DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template="{page_content}")
+    
+    _RAG_PROMPT_TEMPLATE = ChatPromptTemplate.from_template(dedent(_RAG_PROMPT))
+    
+    def __init__(self, llm):
+        self.rag_chain = self._RAG_PROMPT_TEMPLATE | llm | StrOutputParser()
+    
+    def _combine_documents(self, docs):
+        doc_strings = [format_document(doc, self._DEFAULT_DOCUMENT_PROMPT) for doc in docs]
+        return self._DOCUMENT_SEPARATOR.join(doc_strings)
+    
+    def run(self, question, documents):
+        """Returns the response from the LLM to the user's message using RAG with chunked documents."""
+        document_str = self._combine_documents(documents)
+        return self.rag_chain.invoke({"question": question, "context": document_str})

src/chains/rephrase_question.py

@@ -0,0 +1,24 @@
+"""Implements the rephrase question chain"""
+
+from langchain_core.prompts import PromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+
+class RephraseQuestion:
+    
+    """Implements the rephrase question chain"""
+    
+    _CONDESE_QUESTION_PROMPT_TEMPLATE = """
+    Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.
+    Chat History:
+    {chat_history}
+    Follow Up Input: {question}
+    Standalone question:
+    """
+    _CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_CONDESE_QUESTION_PROMPT_TEMPLATE)
+    
+    def __init__(self, llm):
+        self.rephrase_question_chain = self._CONDENSE_QUESTION_PROMPT | llm | StrOutputParser()
+    
+    def run(self, message, history):
+        """Returns the rephrased question from the LLM to the user's message."""
+        return self.rephrase_question_chain.invoke({"chat_history": history, "question": message})

src/chains/smalltalk.py

@@ -0,0 +1,28 @@
+"""Responds to any smalltalk or off-topic messages."""
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from textwrap import dedent
+
+class Smalltalk:
+    
+    """Responds to any smalltalk or off-topic messages."""
+    
+    _SMALLTALK_PROMPT = """
+    You are an AI assistant, Saj, built by Sajal Sharma, an AI Engineer. Given the following message and chat history, please respond to the user.
+    You are allow to repond to smalltalk messages such as greetings or how are yous. For any message that is off topic, or is not a greeting, or not about Sajal, refuse to answer and ask the user to ask a question about Sajal.
+
+    Chat History: {chat_history}
+
+    User Message: {input}
+    """
+    
+    _SMALLTALK_PROMPT_TEMPLATE = ChatPromptTemplate.from_template(dedent(_SMALLTALK_PROMPT))
+    
+    def __init__(self, llm):
+        self.smalltalk_chain = self._SMALLTALK_PROMPT_TEMPLATE | llm | StrOutputParser()   
+    
+    def run(self, message, history):
+        """Returns the response from the LLM to the user's message."""
+        return self.smalltalk_chain.invoke({"input": message, "chat_history": history})
+        

src/graph.py

@@ -0,0 +1,247 @@
+"""Implements the graph to handle workflows for the Sajal assistant"""
+
+from typing import Dict, TypedDict
+
+from chains.intent_detection import IntentDetection
+from chains.smalltalk import Smalltalk
+from chains.document_grader import DocumentGrader
+from chains.rephrase_question import RephraseQuestion
+from chains.qa_all_data import QAAllData
+from chains.rag import RAG
+
+from retriever import Retriever
+
+from langgraph.graph import END, StateGraph
+
+class GraphState(TypedDict):
+    """
+    Represents the state of our graph.
+
+    Attributes:
+        keys: A dictionary where each key is a string.
+    """
+    keys: Dict[str, any]
+
+class AssistantGraph:
+    
+    """Implements the graph to handle workflows for the Sajal assistant"""
+    
+    def __init__(self, llm, vector_db_path, source_data_path):
+        self.intent_detector = IntentDetection(llm)
+        self.smalltalk = Smalltalk(llm)
+        self.document_grader = DocumentGrader()
+        self.rephrase_question_chain = RephraseQuestion(llm)
+        self.retriever = Retriever(vector_db_path=vector_db_path)
+        self.qa_all_data = QAAllData(llm=llm, source_data_path=source_data_path)
+        self.rag = RAG(llm)
+        self.app = self.compile_graph()
+        
+    def run(self, inputs):
+        return self.app.invoke(inputs)
+    
+    # define graph nodes and edges and compile graph
+    def compile_graph(self):
+        workflow = StateGraph(GraphState)
+        ### define the nodes
+        workflow.add_node("detect_intent", self.detect_intent)
+        workflow.add_node("chat", self.chat)
+        workflow.add_node("rephrase_question", self.rephrase_question)
+        workflow.add_node("retrieve", self.retrieve)
+        workflow.add_node("grade_documents", self.grade_documents)
+        workflow.add_node("generate_answer_with_retrieved_documents", self.generate_answer_with_retrieved_documents)
+        workflow.add_node("generate_answer_using_all_data", self.generate_answer_using_all_data)
+        ### build the graph
+        workflow.set_entry_point("detect_intent")
+        workflow.add_conditional_edges(
+            "detect_intent",
+            self.decide_to_rag,
+            {
+                "rag": "rephrase_question",
+                "chat": "chat",
+            }
+        )
+        workflow.add_edge("rephrase_question", "retrieve")
+        workflow.add_edge("retrieve", "grade_documents")
+        workflow.add_conditional_edges(
+            "grade_documents",
+            self.decide_to_use_all_data,
+            {
+                "rag": "generate_answer_with_retrieved_documents",
+                "generate_answer_using_all_data": "generate_answer_using_all_data",
+            }
+        )
+        workflow.add_edge("generate_answer_with_retrieved_documents", END)
+        workflow.add_edge("generate_answer_using_all_data", END)
+        workflow.add_edge("chat", END)
+        ### compile the graph
+        app = workflow.compile()
+        return app
+    
+    # define the nodes
+    def detect_intent(self, state):
+        """
+        Detects the intent of a user's message
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            state (dict): New key added to state, intent, that contains the detected intent
+        """
+        state = state["keys"]
+        message = state["message"]
+        history = state["history"]
+        intent = self.intent_detector.run(message=message, history=history)
+        return {"keys": {"message": message, "intent": intent, "history": history}}
+    
+    def chat(self, state):
+        """
+        Chat with the user
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            str: Updated graph state after adding response
+        """
+        state = state["keys"]
+        input = state["message"]
+        history = state["history"]
+        response = self.smalltalk.run(message=input, history=history)
+        return {"keys": {"message": input, "history": history, "response": response}}
+    
+    def grade_documents(self, state):
+        """
+        Determines whether the retrieved documents are relevant to the question.
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            state (dict): Updates documents key with relevant documents
+        """
+
+        print("---CHECK RELEVANCE---")
+        state = state["keys"]
+        question = state["standalone_question"]
+        documents = state["documents"]
+
+        # Score
+        filtered_docs = []
+        all_data = False  # Default do not opt to use all data for generation
+        for d in documents:
+            score = self.document_grader.run(question=question, context=d.page_content)
+            grade = score[0].binary_score
+            if grade == "yes":
+                print("---GRADE: FOUND RELEVANT DOCUMENT---")
+                filtered_docs.append(d)
+
+        if not filtered_docs:
+            all_data = True  # Opt to use all data for generation
+
+        return {
+            "keys": {
+                "documents": filtered_docs,
+                "standalone_question": question,
+                "run_with_all_data": all_data,
+            }
+        }
+        
+    def rephrase_question(self, state):
+        """
+        Rephrase the question to be a standalone question
+        
+        Args:
+            state (dict): The current graph state
+        
+        Returns:
+            str: Updated graph state after adding standalone question
+        """
+        state = state["keys"]
+        question = state["message"]
+        chat_history = state["history"]
+        result = self.rephrase_question_chain.run(message=question, history=chat_history)
+        return {"keys": {"message": question, "history": chat_history, "standalone_question": result}}
+    
+    def retrieve(self, state):
+        """
+        Retrieve documents
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            state (dict): New key added to state, documents, that contains retrieved documents
+        """
+        state = state["keys"]
+        question = state["standalone_question"]
+        chat_history = state["history"]
+        documents = self.retriever.run(query=question)
+        return {"keys": {"message": state["message"], "history": chat_history, "standalone_question": question, "documents": documents}}
+
+    def generate_answer_using_all_data(self, state):
+        """
+        Generate an answer using all documents
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            str: Updated graph state after adding response
+        """
+        state = state["keys"]
+        question = state["standalone_question"]
+        response = self.qa_all_data.run(question=question)
+        return {"keys": {"message": question, "response": response}}
+    
+    def generate_answer_with_retrieved_documents(self, state):
+        """
+        Generate an answer using the retrieved documents
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            str: Updated graph state after adding response
+        """
+        state = state["keys"]
+        question = state["standalone_question"]
+        documents = state["documents"]
+        response = self.rag.run(question=question, documents=documents)
+        return {"keys": {"message": question, "response": response}}
+    
+    # define the edges
+    def decide_to_rag(self, state):
+        """
+        Decides whether to use RAG or not
+
+        Args:
+            state (dict): The current graph state
+
+        Returns:
+            str: Next node to call
+        """
+        state = state["keys"]
+        intent = state["intent"]
+        if intent == "sajal_question":
+            return "rag"
+        return "chat"
+
+    def decide_to_use_all_data(self, state):
+        """
+        Determines whether to use all data for generation or not.
+
+        Args:
+            state (dict): The current state of the agent, including all keys.
+
+        Returns:
+            str: Next node to call
+        """
+
+        state = state["keys"]
+        run_with_all_data = state["run_with_all_data"]
+
+        if run_with_all_data:
+            return "generate_answer_using_all_data"
+        else:
+            return "rag"

src/ingest_data.py

@@ -0,0 +1,30 @@
+"""Script to ingest data to a ChromaDB vector store, and persist it to disk"""
+
+import os
+from dotenv import load_dotenv
+
+from langchain.text_splitter import MarkdownHeaderTextSplitter
+from langchain_community.vectorstores import Chroma
+from langchain_openai import OpenAIEmbeddings
+
+# load the environment variables
+load_dotenv()
+
+# load the data
+markdown_path = "data/source.md"
+# read the markdown file and return the full document as a string
+with open(markdown_path, "r") as file:
+    full_markdown_document = file.read()
+
+# split the data into chunks based on the markdown heading
+headers_to_split_on = [
+    ("#", "Header 1"),
+    ("##", "Header 2"),
+    ("###", "Header 3"),
+]
+markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on, strip_headers=False)
+chunked_documents = markdown_splitter.split_text(full_markdown_document)
+
+# create a vector store
+embeddings_model = OpenAIEmbeddings()
+db = Chroma.from_documents(chunked_documents, embeddings_model, persist_directory="data/chroma_db")

src/retriever.py

@@ -0,0 +1,16 @@
+"""Impleemnts the Retriever class for retrieving data from the database"""
+
+from langchain_community.vectorstores import Chroma
+from langchain_openai import OpenAIEmbeddings
+
+class Retriever:
+    """Retrieves data from the database"""
+    
+    def __init__(self, vector_db_path):
+        _embedding_model = OpenAIEmbeddings()
+        _db = Chroma(persist_directory=vector_db_path, embedding_function=_embedding_model)
+        self.retriever = _db.as_retriever()
+
+    def run(self, query):
+        """Retrieves data from the database"""
+        return self.retriever.get_relevant_documents(query)