Merge pull request #46 from joshuasundance-swca/cleanup

.idea/langchain-streamlit-demo.iml

@@ -1,7 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <module type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager">
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/langchain-streamlit-demo" isTestSource="false" />
+    </content>
     <orderEntry type="jdk" jdkName="Remote Python 3.11.4 Docker (&lt;none&gt;:&lt;none&gt;) (5)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>

kubernetes/resources.yaml

@@ -39,6 +39,11 @@ spec:
               secretKeyRef:
                 name: langchain-streamlit-demo-secret
                 key: AZURE_OPENAI_DEPLOYMENT_NAME
+          - name: AZURE_OPENAI_EMB_DEPLOYMENT_NAME
+            valueFrom:
+              secretKeyRef:
+                name: langchain-streamlit-demo-secret
+                key: AZURE_OPENAI_EMB_DEPLOYMENT_NAME
           - name: AZURE_OPENAI_API_KEY
             valueFrom:
               secretKeyRef:
@@ -71,6 +76,10 @@ spec:
                 key: LANGCHAIN_API_KEY
           - name: LANGCHAIN_PROJECT
             value: "langchain-streamlit-demo"
+          - name: SHOW_LANGCHAIN_OPTIONS
+            value: "False"
+          - name: SHOW_AZURE_OPTIONS
+            value: "False"
         securityContext:
           runAsNonRoot: true
 ---

langchain-streamlit-demo/app.py

@@ -1,37 +1,22 @@
-import os
 from datetime import datetime
-from tempfile import NamedTemporaryFile
-from typing import Tuple, List, Dict, Any, Union
+from typing import Tuple, List, Dict, Any, Union, Optional
 
 import anthropic
 import langsmith.utils
 import openai
 import streamlit as st
-from langchain.callbacks.base import BaseCallbackHandler
 from langchain.callbacks.tracers.langchain import LangChainTracer, wait_for_all_tracers
 from langchain.callbacks.tracers.run_collector import RunCollectorCallbackHandler
-from langchain.chains import RetrievalQA
-from langchain.chains.llm import LLMChain
-from langchain.chat_models import (
-    AzureChatOpenAI,
-    ChatAnthropic,
-    ChatAnyscale,
-    ChatOpenAI,
-)
-from langchain.document_loaders import PyPDFLoader
-from langchain.embeddings import OpenAIEmbeddings
 from langchain.memory import ConversationBufferMemory, StreamlitChatMessageHistory
 from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain.retrievers import BM25Retriever, EnsembleRetriever
 from langchain.schema.document import Document
 from langchain.schema.retriever import BaseRetriever
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.vectorstores import FAISS
 from langsmith.client import Client
 from streamlit_feedback import streamlit_feedback
 
-from qagen import get_rag_qa_gen_chain
-from summarize import get_rag_summarization_chain
+from defaults import default_values
+
+from llm_resources import get_runnable, get_llm, get_texts_and_retriever, StreamHandler
 
 __version__ = "0.0.13"
 
@@ -62,119 +47,72 @@ st_init_null(
     "trace_link",
 )
 
-# --- Memory ---
+# --- LLM globals ---
 STMEMORY = StreamlitChatMessageHistory(key="langchain_messages")
 MEMORY = ConversationBufferMemory(
     chat_memory=STMEMORY,
     return_messages=True,
     memory_key="chat_history",
 )
-
-
-# --- Callbacks ---
-class StreamHandler(BaseCallbackHandler):
-    def __init__(self, container, initial_text=""):
-        self.container = container
-        self.text = initial_text
-
-    def on_llm_new_token(self, token: str, **kwargs) -> None:
-        self.text += token
-        self.container.markdown(self.text)
-
-
 RUN_COLLECTOR = RunCollectorCallbackHandler()
 
-
-# --- Model Selection Helpers ---
-MODEL_DICT = {
-    "gpt-3.5-turbo": "OpenAI",
-    "gpt-4": "OpenAI",
-    "claude-instant-v1": "Anthropic",
-    "claude-2": "Anthropic",
-    "meta-llama/Llama-2-7b-chat-hf": "Anyscale Endpoints",
-    "meta-llama/Llama-2-13b-chat-hf": "Anyscale Endpoints",
-    "meta-llama/Llama-2-70b-chat-hf": "Anyscale Endpoints",
-    "codellama/CodeLlama-34b-Instruct-hf": "Anyscale Endpoints",
-    "Azure OpenAI": "Azure OpenAI",
-}
-SUPPORTED_MODELS = list(MODEL_DICT.keys())
-
-
-# --- Constants from Environment Variables ---
-DEFAULT_MODEL = os.environ.get("DEFAULT_MODEL", "gpt-3.5-turbo")
-DEFAULT_SYSTEM_PROMPT = os.environ.get(
-    "DEFAULT_SYSTEM_PROMPT",
-    "You are a helpful chatbot.",
+LANGSMITH_API_KEY = default_values.PROVIDER_KEY_DICT.get("LANGSMITH")
+LANGSMITH_PROJECT = (
+    default_values.DEFAULT_LANGSMITH_PROJECT or "langchain-streamlit-demo"
 )
-MIN_TEMP = float(os.environ.get("MIN_TEMPERATURE", 0.0))
-MAX_TEMP = float(os.environ.get("MAX_TEMPERATURE", 1.0))
-DEFAULT_TEMP = float(os.environ.get("DEFAULT_TEMPERATURE", 0.7))
-MIN_MAX_TOKENS = int(os.environ.get("MIN_MAX_TOKENS", 1))
-MAX_MAX_TOKENS = int(os.environ.get("MAX_MAX_TOKENS", 100000))
-DEFAULT_MAX_TOKENS = int(os.environ.get("DEFAULT_MAX_TOKENS", 1000))
-DEFAULT_LANGSMITH_PROJECT = os.environ.get("LANGCHAIN_PROJECT")
-
-AZURE_VARS = [
-    "AZURE_OPENAI_BASE_URL",
-    "AZURE_OPENAI_API_VERSION",
-    "AZURE_OPENAI_DEPLOYMENT_NAME",
-    "AZURE_OPENAI_API_KEY",
-    "AZURE_OPENAI_MODEL_VERSION",
+AZURE_OPENAI_BASE_URL = default_values.AZURE_DICT["AZURE_OPENAI_BASE_URL"]
+AZURE_OPENAI_API_VERSION = default_values.AZURE_DICT["AZURE_OPENAI_API_VERSION"]
+AZURE_OPENAI_DEPLOYMENT_NAME = default_values.AZURE_DICT["AZURE_OPENAI_DEPLOYMENT_NAME"]
+AZURE_OPENAI_EMB_DEPLOYMENT_NAME = default_values.AZURE_DICT[
+    "AZURE_OPENAI_EMB_DEPLOYMENT_NAME"
 ]
+AZURE_OPENAI_API_KEY = default_values.AZURE_DICT["AZURE_OPENAI_API_KEY"]
+AZURE_OPENAI_MODEL_VERSION = default_values.AZURE_DICT["AZURE_OPENAI_MODEL_VERSION"]
+
+AZURE_AVAILABLE = all(
+    [
+        AZURE_OPENAI_BASE_URL,
+        AZURE_OPENAI_API_VERSION,
+        AZURE_OPENAI_DEPLOYMENT_NAME,
+        AZURE_OPENAI_API_KEY,
+        AZURE_OPENAI_MODEL_VERSION,
+    ],
+)
 
-AZURE_DICT = {v: os.environ.get(v, "") for v in AZURE_VARS}
-
-PROVIDER_KEY_DICT = {
-    "OpenAI": os.environ.get("OPENAI_API_KEY", ""),
-    "Anthropic": os.environ.get("ANTHROPIC_API_KEY", ""),
-    "Anyscale Endpoints": os.environ.get("ANYSCALE_API_KEY", ""),
-    "LANGSMITH": os.environ.get("LANGCHAIN_API_KEY", ""),
-}
-OPENAI_API_KEY = PROVIDER_KEY_DICT["OpenAI"]
-
-MIN_CHUNK_SIZE = 1
-MAX_CHUNK_SIZE = 10000
-DEFAULT_CHUNK_SIZE = 1000
-
-MIN_CHUNK_OVERLAP = 0
-MAX_CHUNK_OVERLAP = 10000
-DEFAULT_CHUNK_OVERLAP = 0
-
-DEFAULT_RETRIEVER_K = 4
+AZURE_EMB_AVAILABLE = AZURE_AVAILABLE and AZURE_OPENAI_EMB_DEPLOYMENT_NAME
+
+AZURE_KWARGS = (
+    None
+    if not AZURE_EMB_AVAILABLE
+    else {
+        "openai_api_base": AZURE_OPENAI_BASE_URL,
+        "openai_api_version": AZURE_OPENAI_API_VERSION,
+        "deployment": AZURE_OPENAI_EMB_DEPLOYMENT_NAME,
+        "openai_api_key": AZURE_OPENAI_API_KEY,
+        "openai_api_type": "azure",
+    }
+)
 
 
 @st.cache_data
-def get_texts_and_retriever(
+def get_texts_and_retriever_cacheable_wrapper(
     uploaded_file_bytes: bytes,
-    chunk_size: int = DEFAULT_CHUNK_SIZE,
-    chunk_overlap: int = DEFAULT_CHUNK_OVERLAP,
-    k: int = DEFAULT_RETRIEVER_K,
+    openai_api_key: str,
+    chunk_size: int = default_values.DEFAULT_CHUNK_SIZE,
+    chunk_overlap: int = default_values.DEFAULT_CHUNK_OVERLAP,
+    k: int = default_values.DEFAULT_RETRIEVER_K,
+    azure_kwargs: Optional[Dict[str, str]] = None,
+    use_azure: bool = False,
 ) -> Tuple[List[Document], BaseRetriever]:
-    with NamedTemporaryFile() as temp_file:
-        temp_file.write(uploaded_file_bytes)
-        temp_file.seek(0)
-
-        loader = PyPDFLoader(temp_file.name)
-        documents = loader.load()
-        text_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=chunk_size,
-            chunk_overlap=chunk_overlap,
-        )
-        texts = text_splitter.split_documents(documents)
-        embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
-
-        bm25_retriever = BM25Retriever.from_documents(texts)
-        bm25_retriever.k = k
-
-        faiss_vectorstore = FAISS.from_documents(texts, embeddings)
-        faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={"k": k})
-
-        ensemble_retriever = EnsembleRetriever(
-            retrievers=[bm25_retriever, faiss_retriever],
-            weights=[0.5, 0.5],
-        )
-
-        return texts, ensemble_retriever
+    return get_texts_and_retriever(
+        uploaded_file_bytes=uploaded_file_bytes,
+        openai_api_key=openai_api_key,
+        chunk_size=chunk_size,
+        chunk_overlap=chunk_overlap,
+        k=k,
+        azure_kwargs=azure_kwargs,
+        use_azure=use_azure,
+    )
 
 
 # --- Sidebar ---
@@ -184,14 +122,14 @@ with sidebar:
 
     model = st.selectbox(
         label="Chat Model",
-        options=SUPPORTED_MODELS,
-        index=SUPPORTED_MODELS.index(DEFAULT_MODEL),
+        options=default_values.SUPPORTED_MODELS,
+        index=default_values.SUPPORTED_MODELS.index(default_values.DEFAULT_MODEL),
     )
 
-    st.session_state.provider = MODEL_DICT[model]
+    st.session_state.provider = default_values.MODEL_DICT[model]
 
     provider_api_key = (
-        PROVIDER_KEY_DICT.get(
+        default_values.PROVIDER_KEY_DICT.get(
             st.session_state.provider,
         )
         or st.text_input(
@@ -214,7 +152,7 @@ with sidebar:
         openai_api_key = (
             provider_api_key
             if st.session_state.provider == "OpenAI"
-            else OPENAI_API_KEY
+            else default_values.OPENAI_API_KEY
             or st.sidebar.text_input("OpenAI API Key: ", type="password")
         )
 
@@ -227,7 +165,7 @@ with sidebar:
         k = st.slider(
             label="Number of Chunks",
             help="How many document chunks will be used for context?",
-            value=DEFAULT_RETRIEVER_K,
+            value=default_values.DEFAULT_RETRIEVER_K,
             min_value=1,
             max_value=10,
         )
@@ -235,21 +173,23 @@ with sidebar:
         chunk_size = st.slider(
             label="Number of Tokens per Chunk",
             help="Size of each chunk of text",
-            min_value=MIN_CHUNK_SIZE,
-            max_value=MAX_CHUNK_SIZE,
-            value=DEFAULT_CHUNK_SIZE,
+            min_value=default_values.MIN_CHUNK_SIZE,
+            max_value=default_values.MAX_CHUNK_SIZE,
+            value=default_values.DEFAULT_CHUNK_SIZE,
         )
+
         chunk_overlap = st.slider(
             label="Chunk Overlap",
             help="Number of characters to overlap between chunks",
-            min_value=MIN_CHUNK_OVERLAP,
-            max_value=MAX_CHUNK_OVERLAP,
-            value=DEFAULT_CHUNK_OVERLAP,
+            min_value=default_values.MIN_CHUNK_OVERLAP,
+            max_value=default_values.MAX_CHUNK_OVERLAP,
+            value=default_values.DEFAULT_CHUNK_OVERLAP,
         )
 
         chain_type_help_root = (
             "https://python.langchain.com/docs/modules/chains/document/"
         )
+
         chain_type_help = "\n".join(
             f"- [{chain_type_name}]({chain_type_help_root}/{chain_type_name})"
             for chain_type_name in (
@@ -259,6 +199,7 @@ with sidebar:
                 "map_rerank",
             )
         )
+
         document_chat_chain_type = st.selectbox(
             label="Document Chat Chain Type",
             options=[
@@ -273,17 +214,28 @@ with sidebar:
             help=chain_type_help,
             disabled=not document_chat,
         )
+        use_azure = False
+
+        if AZURE_EMB_AVAILABLE:
+            use_azure = st.toggle(
+                label="Use Azure OpenAI",
+                value=AZURE_EMB_AVAILABLE,
+                help="Use Azure for embeddings instead of using OpenAI directly.",
+            )
 
         if uploaded_file:
-            if openai_api_key:
+            if AZURE_EMB_AVAILABLE or openai_api_key:
                 (
                     st.session_state.texts,
                     st.session_state.retriever,
-                ) = get_texts_and_retriever(
+                ) = get_texts_and_retriever_cacheable_wrapper(
                     uploaded_file_bytes=uploaded_file.getvalue(),
+                    openai_api_key=openai_api_key,
                     chunk_size=chunk_size,
                     chunk_overlap=chunk_overlap,
                     k=k,
+                    azure_kwargs=AZURE_KWARGS,
+                    use_azure=use_azure,
                 )
             else:
                 st.error("Please enter a valid OpenAI API key.", icon="❌")
@@ -297,123 +249,100 @@ with sidebar:
         system_prompt = (
             st.text_area(
                 "Custom Instructions",
-                DEFAULT_SYSTEM_PROMPT,
+                default_values.DEFAULT_SYSTEM_PROMPT,
                 help="Custom instructions to provide the language model to determine style, personality, etc.",
             )
             .strip()
             .replace("{", "{{")
             .replace("}", "}}")
         )
+
         temperature = st.slider(
             "Temperature",
-            min_value=MIN_TEMP,
-            max_value=MAX_TEMP,
-            value=DEFAULT_TEMP,
+            min_value=default_values.MIN_TEMP,
+            max_value=default_values.MAX_TEMP,
+            value=default_values.DEFAULT_TEMP,
             help="Higher values give more random results.",
         )
 
         max_tokens = st.slider(
             "Max Tokens",
-            min_value=MIN_MAX_TOKENS,
-            max_value=MAX_MAX_TOKENS,
-            value=DEFAULT_MAX_TOKENS,
+            min_value=default_values.MIN_MAX_TOKENS,
+            max_value=default_values.MAX_MAX_TOKENS,
+            value=default_values.DEFAULT_MAX_TOKENS,
             help="Higher values give longer results.",
         )
 
     # --- LangSmith Options ---
-    with st.expander("LangSmith Options", expanded=False):
-        LANGSMITH_API_KEY = st.text_input(
-            "LangSmith API Key (optional)",
-            type="password",
-            value=PROVIDER_KEY_DICT.get("LANGSMITH"),
-        )
-        LANGSMITH_PROJECT = st.text_input(
-            "LangSmith Project Name",
-            value=DEFAULT_LANGSMITH_PROJECT or "langchain-streamlit-demo",
-        )
-        if st.session_state.client is None and LANGSMITH_API_KEY:
-            st.session_state.client = Client(
-                api_url="https://api.smith.langchain.com",
-                api_key=LANGSMITH_API_KEY,
+    if default_values.SHOW_LANGSMITH_OPTIONS:
+        with st.expander("LangSmith Options", expanded=False):
+            LANGSMITH_API_KEY = st.text_input(
+                "LangSmith API Key (optional)",
+                value=LANGSMITH_API_KEY,
+                type="password",
             )
-            st.session_state.ls_tracer = LangChainTracer(
-                project_name=LANGSMITH_PROJECT,
-                client=st.session_state.client,
+
+            LANGSMITH_PROJECT = st.text_input(
+                "LangSmith Project Name",
+                value=LANGSMITH_PROJECT,
             )
 
-    # --- Azure Options ---
-    with st.expander("Azure Options", expanded=False):
-        AZURE_OPENAI_BASE_URL = st.text_input(
-            "AZURE_OPENAI_BASE_URL",
-            value=AZURE_DICT["AZURE_OPENAI_BASE_URL"],
-        )
-        AZURE_OPENAI_API_VERSION = st.text_input(
-            "AZURE_OPENAI_API_VERSION",
-            value=AZURE_DICT["AZURE_OPENAI_API_VERSION"],
-        )
-        AZURE_OPENAI_DEPLOYMENT_NAME = st.text_input(
-            "AZURE_OPENAI_DEPLOYMENT_NAME",
-            value=AZURE_DICT["AZURE_OPENAI_DEPLOYMENT_NAME"],
-        )
-        AZURE_OPENAI_API_KEY = st.text_input(
-            "AZURE_OPENAI_API_KEY",
-            value=AZURE_DICT["AZURE_OPENAI_API_KEY"],
-            type="password",
+    if st.session_state.client is None and LANGSMITH_API_KEY:
+        st.session_state.client = Client(
+            api_url="https://api.smith.langchain.com",
+            api_key=LANGSMITH_API_KEY,
         )
-        AZURE_OPENAI_MODEL_VERSION = st.text_input(
-            "AZURE_OPENAI_MODEL_VERSION",
-            value=AZURE_DICT["AZURE_OPENAI_MODEL_VERSION"],
+        st.session_state.ls_tracer = LangChainTracer(
+            project_name=LANGSMITH_PROJECT,
+            client=st.session_state.client,
         )
 
-        AZURE_AVAILABLE = all(
-            [
-                AZURE_OPENAI_BASE_URL,
-                AZURE_OPENAI_API_VERSION,
-                AZURE_OPENAI_DEPLOYMENT_NAME,
-                AZURE_OPENAI_API_KEY,
-                AZURE_OPENAI_MODEL_VERSION,
-            ],
-        )
+    # --- Azure Options ---
+    if default_values.SHOW_AZURE_OPTIONS:
+        with st.expander("Azure Options", expanded=False):
+            AZURE_OPENAI_BASE_URL = st.text_input(
+                "AZURE_OPENAI_BASE_URL",
+                value=AZURE_OPENAI_BASE_URL,
+            )
+
+            AZURE_OPENAI_API_VERSION = st.text_input(
+                "AZURE_OPENAI_API_VERSION",
+                value=AZURE_OPENAI_API_VERSION,
+            )
+
+            AZURE_OPENAI_DEPLOYMENT_NAME = st.text_input(
+                "AZURE_OPENAI_DEPLOYMENT_NAME",
+                value=AZURE_OPENAI_DEPLOYMENT_NAME,
+            )
+
+            AZURE_OPENAI_API_KEY = st.text_input(
+                "AZURE_OPENAI_API_KEY",
+                value=AZURE_OPENAI_API_KEY,
+                type="password",
+            )
+
+            AZURE_OPENAI_MODEL_VERSION = st.text_input(
+                "AZURE_OPENAI_MODEL_VERSION",
+                value=AZURE_OPENAI_MODEL_VERSION,
+            )
 
 
 # --- LLM Instantiation ---
-if provider_api_key:
-    if st.session_state.provider == "OpenAI":
-        st.session_state.llm = ChatOpenAI(
-            model_name=model,
-            openai_api_key=provider_api_key,
-            temperature=temperature,
-            streaming=True,
-            max_tokens=max_tokens,
-        )
-    elif st.session_state.provider == "Anthropic":
-        st.session_state.llm = ChatAnthropic(
-            model=model,
-            anthropic_api_key=provider_api_key,
-            temperature=temperature,
-            streaming=True,
-            max_tokens_to_sample=max_tokens,
-        )
-    elif st.session_state.provider == "Anyscale Endpoints":
-        st.session_state.llm = ChatAnyscale(
-            model_name=model,
-            anyscale_api_key=provider_api_key,
-            temperature=temperature,
-            streaming=True,
-            max_tokens=max_tokens,
-        )
-elif AZURE_AVAILABLE and st.session_state.provider == "Azure OpenAI":
-    st.session_state.llm = AzureChatOpenAI(
-        openai_api_base=AZURE_OPENAI_BASE_URL,
-        openai_api_version=AZURE_OPENAI_API_VERSION,
-        deployment_name=AZURE_OPENAI_DEPLOYMENT_NAME,
-        openai_api_key=AZURE_OPENAI_API_KEY,
-        openai_api_type="azure",
-        model_version=AZURE_OPENAI_MODEL_VERSION,
-        temperature=temperature,
-        streaming=True,
-        max_tokens=max_tokens,
-    )
+st.session_state.llm = get_llm(
+    provider=st.session_state.provider,
+    model=model,
+    provider_api_key=provider_api_key,
+    temperature=temperature,
+    max_tokens=max_tokens,
+    azure_available=AZURE_AVAILABLE,
+    azure_dict={
+        "AZURE_OPENAI_BASE_URL": AZURE_OPENAI_BASE_URL,
+        "AZURE_OPENAI_API_VERSION": AZURE_OPENAI_API_VERSION,
+        "AZURE_OPENAI_DEPLOYMENT_NAME": AZURE_OPENAI_DEPLOYMENT_NAME,
+        "AZURE_OPENAI_API_KEY": AZURE_OPENAI_API_KEY,
+        "AZURE_OPENAI_MODEL_VERSION": AZURE_OPENAI_MODEL_VERSION,
+    },
+)
 
 # --- Chat History ---
 if len(STMEMORY.messages) == 0:
@@ -474,38 +403,17 @@ if st.session_state.llm:
             stream_handler = StreamHandler(message_placeholder)
             callbacks.append(stream_handler)
 
-            def get_rag_runnable():
-                if document_chat_chain_type == "Q&A Generation":
-                    return get_rag_qa_gen_chain(
-                        st.session_state.retriever,
-                        st.session_state.llm,
-                    )
-                elif document_chat_chain_type == "Summarization":
-                    return get_rag_summarization_chain(
-                        prompt,
-                        st.session_state.retriever,
-                        st.session_state.llm,
-                    )
-                else:
-                    return RetrievalQA.from_chain_type(
-                        llm=st.session_state.llm,
-                        chain_type=document_chat_chain_type,
-                        retriever=st.session_state.retriever,
-                        memory=MEMORY,
-                        output_key="output_text",
-                    ) | (lambda output: output["output_text"])
-
-            st.session_state.chain = (
-                get_rag_runnable()
-                if use_document_chat
-                else LLMChain(
-                    prompt=chat_prompt,
-                    llm=st.session_state.llm,
-                    memory=MEMORY,
-                )
-                | (lambda output: output["text"])
+            st.session_state.chain = get_runnable(
+                use_document_chat,
+                document_chat_chain_type,
+                st.session_state.llm,
+                st.session_state.retriever,
+                MEMORY,
+                chat_prompt,
+                prompt,
             )
 
+            # --- LLM call ---
             try:
                 full_response = st.session_state.chain.invoke(prompt, config)
 
@@ -515,6 +423,7 @@ if st.session_state.llm:
                     icon="❌",
                 )
 
+            # --- Display output ---
             if full_response is not None:
                 message_placeholder.markdown(full_response)
 
@@ -530,6 +439,8 @@ if st.session_state.llm:
                         ).url
                     except langsmith.utils.LangSmithError:
                         st.session_state.trace_link = None
+
+    # --- LangSmith Trace Link ---
     if st.session_state.trace_link:
         with sidebar:
             st.markdown(
@@ -573,10 +484,6 @@ if st.session_state.llm:
                     score=score,
                     comment=feedback.get("text"),
                 )
-                # feedback = {
-                #     "feedback_id": str(feedback_record.id),
-                #     "score": score,
-                # }
                 st.toast("Feedback recorded!", icon="📝")
             else:
                 st.warning("Invalid feedback score.")

langchain-streamlit-demo/defaults.py

@@ -0,0 +1,129 @@
+import os
+from collections import namedtuple
+
+
+MODEL_DICT = {
+    "gpt-3.5-turbo": "OpenAI",
+    "gpt-4": "OpenAI",
+    "claude-instant-v1": "Anthropic",
+    "claude-2": "Anthropic",
+    "meta-llama/Llama-2-7b-chat-hf": "Anyscale Endpoints",
+    "meta-llama/Llama-2-13b-chat-hf": "Anyscale Endpoints",
+    "meta-llama/Llama-2-70b-chat-hf": "Anyscale Endpoints",
+    "codellama/CodeLlama-34b-Instruct-hf": "Anyscale Endpoints",
+    "Azure OpenAI": "Azure OpenAI",
+}
+
+SUPPORTED_MODELS = list(MODEL_DICT.keys())
+
+DEFAULT_MODEL = os.environ.get("DEFAULT_MODEL", "gpt-3.5-turbo")
+
+DEFAULT_SYSTEM_PROMPT = os.environ.get(
+    "DEFAULT_SYSTEM_PROMPT",
+    "You are a helpful chatbot.",
+)
+
+MIN_TEMP = float(os.environ.get("MIN_TEMPERATURE", 0.0))
+MAX_TEMP = float(os.environ.get("MAX_TEMPERATURE", 1.0))
+DEFAULT_TEMP = float(os.environ.get("DEFAULT_TEMPERATURE", 0.7))
+
+MIN_MAX_TOKENS = int(os.environ.get("MIN_MAX_TOKENS", 1))
+MAX_MAX_TOKENS = int(os.environ.get("MAX_MAX_TOKENS", 100000))
+DEFAULT_MAX_TOKENS = int(os.environ.get("DEFAULT_MAX_TOKENS", 1000))
+
+DEFAULT_LANGSMITH_PROJECT = os.environ.get("LANGCHAIN_PROJECT")
+
+AZURE_VARS = [
+    "AZURE_OPENAI_BASE_URL",
+    "AZURE_OPENAI_API_VERSION",
+    "AZURE_OPENAI_DEPLOYMENT_NAME",
+    "AZURE_OPENAI_EMB_DEPLOYMENT_NAME",
+    "AZURE_OPENAI_API_KEY",
+    "AZURE_OPENAI_MODEL_VERSION",
+]
+
+AZURE_DICT = {v: os.environ.get(v, "") for v in AZURE_VARS}
+
+
+SHOW_LANGSMITH_OPTIONS = (
+    os.environ.get("SHOW_LANGSMITH_OPTIONS", "true").lower() == "true"
+)
+SHOW_AZURE_OPTIONS = os.environ.get("SHOW_AZURE_OPTIONS", "true").lower() == "true"
+
+PROVIDER_KEY_DICT = {
+    "OpenAI": os.environ.get("OPENAI_API_KEY", ""),
+    "Anthropic": os.environ.get("ANTHROPIC_API_KEY", ""),
+    "Anyscale Endpoints": os.environ.get("ANYSCALE_API_KEY", ""),
+    "LANGSMITH": os.environ.get("LANGCHAIN_API_KEY", ""),
+}
+
+OPENAI_API_KEY = PROVIDER_KEY_DICT["OpenAI"]
+
+
+MIN_CHUNK_SIZE = 1
+MAX_CHUNK_SIZE = 10000
+DEFAULT_CHUNK_SIZE = 1000
+
+MIN_CHUNK_OVERLAP = 0
+MAX_CHUNK_OVERLAP = 10000
+DEFAULT_CHUNK_OVERLAP = 0
+
+DEFAULT_RETRIEVER_K = 4
+
+DEFAULT_VALUES = namedtuple(
+    "DEFAULT_VALUES",
+    [
+        "MODEL_DICT",
+        "SUPPORTED_MODELS",
+        "DEFAULT_MODEL",
+        "DEFAULT_SYSTEM_PROMPT",
+        "MIN_TEMP",
+        "MAX_TEMP",
+        "DEFAULT_TEMP",
+        "MIN_MAX_TOKENS",
+        "MAX_MAX_TOKENS",
+        "DEFAULT_MAX_TOKENS",
+        "DEFAULT_LANGSMITH_PROJECT",
+        "AZURE_VARS",
+        "AZURE_DICT",
+        "PROVIDER_KEY_DICT",
+        "OPENAI_API_KEY",
+        "MIN_CHUNK_SIZE",
+        "MAX_CHUNK_SIZE",
+        "DEFAULT_CHUNK_SIZE",
+        "MIN_CHUNK_OVERLAP",
+        "MAX_CHUNK_OVERLAP",
+        "DEFAULT_CHUNK_OVERLAP",
+        "DEFAULT_RETRIEVER_K",
+        "SHOW_LANGSMITH_OPTIONS",
+        "SHOW_AZURE_OPTIONS",
+    ],
+)
+
+
+default_values = DEFAULT_VALUES(
+    MODEL_DICT,
+    SUPPORTED_MODELS,
+    DEFAULT_MODEL,
+    DEFAULT_SYSTEM_PROMPT,
+    MIN_TEMP,
+    MAX_TEMP,
+    DEFAULT_TEMP,
+    MIN_MAX_TOKENS,
+    MAX_MAX_TOKENS,
+    DEFAULT_MAX_TOKENS,
+    DEFAULT_LANGSMITH_PROJECT,
+    AZURE_VARS,
+    AZURE_DICT,
+    PROVIDER_KEY_DICT,
+    OPENAI_API_KEY,
+    MIN_CHUNK_SIZE,
+    MAX_CHUNK_SIZE,
+    DEFAULT_CHUNK_SIZE,
+    MIN_CHUNK_OVERLAP,
+    MAX_CHUNK_OVERLAP,
+    DEFAULT_CHUNK_OVERLAP,
+    DEFAULT_RETRIEVER_K,
+    SHOW_LANGSMITH_OPTIONS,
+    SHOW_AZURE_OPTIONS,
+)

langchain-streamlit-demo/llm_resources.py

@@ -0,0 +1,160 @@
+from tempfile import NamedTemporaryFile
+from typing import Tuple, List, Optional, Dict
+
+from langchain.callbacks.base import BaseCallbackHandler
+from langchain.chains import RetrievalQA, LLMChain
+from langchain.chat_models import (
+    AzureChatOpenAI,
+    ChatOpenAI,
+    ChatAnthropic,
+    ChatAnyscale,
+)
+from langchain.document_loaders import PyPDFLoader
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.retrievers import BM25Retriever, EnsembleRetriever
+from langchain.schema import Document, BaseRetriever
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.vectorstores import FAISS
+
+from defaults import DEFAULT_CHUNK_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_RETRIEVER_K
+from qagen import get_rag_qa_gen_chain
+from summarize import get_rag_summarization_chain
+
+
+def get_runnable(
+    use_document_chat: bool,
+    document_chat_chain_type: str,
+    llm,
+    retriever,
+    memory,
+    chat_prompt,
+    summarization_prompt,
+):
+    if not use_document_chat:
+        return LLMChain(
+            prompt=chat_prompt,
+            llm=llm,
+            memory=memory,
+        ) | (lambda output: output["text"])
+
+    if document_chat_chain_type == "Q&A Generation":
+        return get_rag_qa_gen_chain(
+            retriever,
+            llm,
+        )
+    elif document_chat_chain_type == "Summarization":
+        return get_rag_summarization_chain(
+            summarization_prompt,
+            retriever,
+            llm,
+        )
+    else:
+        return RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type=document_chat_chain_type,
+            retriever=retriever,
+            memory=memory,
+            output_key="output_text",
+        ) | (lambda output: output["output_text"])
+
+
+def get_llm(
+    provider: str,
+    model: str,
+    provider_api_key: str,
+    temperature: float,
+    max_tokens: int,
+    azure_available: bool,
+    azure_dict: dict[str, str],
+):
+    if azure_available and provider == "Azure OpenAI":
+        return AzureChatOpenAI(
+            openai_api_base=azure_dict["AZURE_OPENAI_BASE_URL"],
+            openai_api_version=azure_dict["AZURE_OPENAI_API_VERSION"],
+            deployment_name=azure_dict["AZURE_OPENAI_DEPLOYMENT_NAME"],
+            openai_api_key=azure_dict["AZURE_OPENAI_API_KEY"],
+            openai_api_type="azure",
+            model_version=azure_dict["AZURE_OPENAI_MODEL_VERSION"],
+            temperature=temperature,
+            streaming=True,
+            max_tokens=max_tokens,
+        )
+
+    elif provider_api_key:
+        if provider == "OpenAI":
+            return ChatOpenAI(
+                model_name=model,
+                openai_api_key=provider_api_key,
+                temperature=temperature,
+                streaming=True,
+                max_tokens=max_tokens,
+            )
+
+        elif provider == "Anthropic":
+            return ChatAnthropic(
+                model=model,
+                anthropic_api_key=provider_api_key,
+                temperature=temperature,
+                streaming=True,
+                max_tokens_to_sample=max_tokens,
+            )
+
+        elif provider == "Anyscale Endpoints":
+            return ChatAnyscale(
+                model_name=model,
+                anyscale_api_key=provider_api_key,
+                temperature=temperature,
+                streaming=True,
+                max_tokens=max_tokens,
+            )
+
+    return None
+
+
+def get_texts_and_retriever(
+    uploaded_file_bytes: bytes,
+    openai_api_key: str,
+    chunk_size: int = DEFAULT_CHUNK_SIZE,
+    chunk_overlap: int = DEFAULT_CHUNK_OVERLAP,
+    k: int = DEFAULT_RETRIEVER_K,
+    azure_kwargs: Optional[Dict[str, str]] = None,
+    use_azure: bool = False,
+) -> Tuple[List[Document], BaseRetriever]:
+    with NamedTemporaryFile() as temp_file:
+        temp_file.write(uploaded_file_bytes)
+        temp_file.seek(0)
+
+        loader = PyPDFLoader(temp_file.name)
+        documents = loader.load()
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+        )
+        texts = text_splitter.split_documents(documents)
+        embeddings_kwargs = {"openai_api_key": openai_api_key}
+        if use_azure and azure_kwargs:
+            embeddings_kwargs.update(azure_kwargs)
+        embeddings = OpenAIEmbeddings(**embeddings_kwargs)
+
+        bm25_retriever = BM25Retriever.from_documents(texts)
+        bm25_retriever.k = k
+
+        faiss_vectorstore = FAISS.from_documents(texts, embeddings)
+        faiss_retriever = faiss_vectorstore.as_retriever(search_kwargs={"k": k})
+
+        ensemble_retriever = EnsembleRetriever(
+            retrievers=[bm25_retriever, faiss_retriever],
+            weights=[0.5, 0.5],
+        )
+
+        return texts, ensemble_retriever
+
+
+class StreamHandler(BaseCallbackHandler):
+    def __init__(self, container, initial_text=""):
+        self.container = container
+        self.text = initial_text
+
+    def on_llm_new_token(self, token: str, **kwargs) -> None:
+        self.text += token
+        self.container.markdown(self.text)