code
stringlengths 141
97.3k
| apis
sequencelengths 1
24
| extract_api
stringlengths 113
214k
|
|---|---|---|
import streamlit as st
from dotenv import load_dotenv
load_dotenv()
import os
import tempfile
from llama_index import SimpleDirectoryReader, StorageContext, LLMPredictor
from llama_index import VectorStoreIndex
from llama_index import ServiceContext
from llama_index.embeddings.langchain import LangchainEmbedding
from langchain.chat_models import ChatOpenAI
import tiktoken
from langchain.embeddings import CohereEmbeddings
import openai
os.environ["OPENAI_API_KEY"] = st.secrets["OPENAI_API_KEY"]
openai.api_key = st.secrets["OPENAI_API_KEY"]
os.environ["COHERE_API_KEY"] = st.secrets["COHERE_API_KEY"]
llm_predictor = LLMPredictor(llm = ChatOpenAI(temperature = 0, model_name = 'gpt-3.5-turbo', max_tokens = -1, openai_api_key = openai.api_key))
embed_model = LangchainEmbedding(CohereEmbeddings(model = "embed-english-light-v2.0"))
storage_context = StorageContext.from_defaults()
service_context = ServiceContext.from_defaults(llm_predictor = llm_predictor, embed_model = embed_model)
def num_tokens_from_string(string: str, encoding_name: str) -> int:
encoding = tiktoken.encoding_for_model(encoding_name)
num_tokens = len(encoding.encode(string))
return num_tokens
@st.cache_resource
def preprocessing(uploaded_file):
if uploaded_file:
temp_dir = tempfile.TemporaryDirectory()
file_path = os.path.join(temp_dir.name, uploaded_file.name)
with open(file_path, "wb") as f:
f.write(uploaded_file.read())
document = SimpleDirectoryReader(input_files = [file_path]).load_data()
tokens = num_tokens_from_string(document[0].text, 'gpt-3.5-turbo')
global context
context = document[0].text
if tokens <= 4000:
print('Case - A')
return context
else:
print('Case - B')
index = VectorStoreIndex.from_documents(document, service_context = service_context, storage_context = storage_context)
global engine
engine = index.as_query_engine(similarity_top_k = 3)
return engine
@st.cache_resource
def run(_query_engine, query):
if type(_query_engine) == str:
print('Executing Case - A')
response = openai.ChatCompletion.create(
model = "gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a helpful assistant who answers questions given context."},
{"role": "user", "content": f"The question is - {query}\nThe provided context is - {_query_engine}\nAnswer the question to the best of your abilities."},
]
)
st.write(response['choices'][0]['message']['content'])
else:
print('Executing Case - B')
st.write(query_engine.query(query).response)
return True
st.set_page_config(layout = "wide")
st.title("Document Querying")
uploaded_file = st.file_uploader('Upload your file')
query_engine = preprocessing(uploaded_file)
if query_engine:
query = st.text_input('Enter your Query.', key = 'query_input')
if query:
run(query_engine, query) | [
"langchain.chat_models.ChatOpenAI",
"langchain.embeddings.CohereEmbeddings"
] | [((55, 68), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (66, 68), False, 'from dotenv import load_dotenv\n'), ((860, 890), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {}), '()\n', (888, 890), False, 'from llama_index import SimpleDirectoryReader, StorageContext, LLMPredictor\n'), ((909, 996), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'embed_model': 'embed_model'}), '(llm_predictor=llm_predictor, embed_model=\n embed_model)\n', (937, 996), False, 'from llama_index import ServiceContext\n'), ((2820, 2853), 'streamlit.set_page_config', 'st.set_page_config', ([], {'layout': '"""wide"""'}), "(layout='wide')\n", (2838, 2853), True, 'import streamlit as st\n'), ((2857, 2886), 'streamlit.title', 'st.title', (['"""Document Querying"""'], {}), "('Document Querying')\n", (2865, 2886), True, 'import streamlit as st\n'), ((2904, 2940), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload your file"""'], {}), "('Upload your file')\n", (2920, 2940), True, 'import streamlit as st\n'), ((787, 837), 'langchain.embeddings.CohereEmbeddings', 'CohereEmbeddings', ([], {'model': '"""embed-english-light-v2.0"""'}), "(model='embed-english-light-v2.0')\n", (803, 837), False, 'from langchain.embeddings import CohereEmbeddings\n'), ((1080, 1122), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['encoding_name'], {}), '(encoding_name)\n', (1107, 1122), False, 'import tiktoken\n'), ((3016, 3069), 'streamlit.text_input', 'st.text_input', (['"""Enter your Query."""'], {'key': '"""query_input"""'}), "('Enter your Query.', key='query_input')\n", (3029, 3069), True, 'import streamlit as st\n'), ((644, 747), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo"""', 'max_tokens': '(-1)', 'openai_api_key': 'openai.api_key'}), "(temperature=0, model_name='gpt-3.5-turbo', max_tokens=-1,\n openai_api_key=openai.api_key)\n", (654, 747), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1286, 1315), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (1313, 1315), False, 'import tempfile\n'), ((1336, 1383), 'os.path.join', 'os.path.join', (['temp_dir.name', 'uploaded_file.name'], {}), '(temp_dir.name, uploaded_file.name)\n', (1348, 1383), False, 'import os\n'), ((2198, 2537), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-3.5-turbo"""', 'messages': '[{\'role\': \'system\', \'content\':\n \'You are a helpful assistant who answers questions given context.\'}, {\n \'role\': \'user\', \'content\':\n f"""The question is - {query}\nThe provided context is - {_query_engine}\nAnswer the question to the best of your abilities."""\n }]'}), '(model=\'gpt-3.5-turbo\', messages=[{\'role\':\n \'system\', \'content\':\n \'You are a helpful assistant who answers questions given context.\'}, {\n \'role\': \'user\', \'content\':\n f"""The question is - {query}\nThe provided context is - {_query_engine}\nAnswer the question to the best of your abilities."""\n }])\n', (2226, 2537), False, 'import openai\n'), ((2645, 2699), 'streamlit.write', 'st.write', (["response['choices'][0]['message']['content']"], {}), "(response['choices'][0]['message']['content'])\n", (2653, 2699), True, 'import streamlit as st\n'), ((1828, 1939), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['document'], {'service_context': 'service_context', 'storage_context': 'storage_context'}), '(document, service_context=service_context,\n storage_context=storage_context)\n', (1859, 1939), False, 'from llama_index import VectorStoreIndex\n'), ((1486, 1532), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_files': '[file_path]'}), '(input_files=[file_path])\n', (1507, 1532), False, 'from llama_index import SimpleDirectoryReader, StorageContext, LLMPredictor\n')] |
import os
import langchain
from langchain.utilities import SerpAPIWrapper
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
os.environ['OPENAI_API_KEY'] = ""
os.environ['SERPAPI_API_KEY'] = ""
llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
search = SerpAPIWrapper()
# Define a list of tools offered by the agent
tools = [
Tool(
name="Search",
func=search.run,
description="Useful when you need to answer questions about current events. You should ask targeted questions.",
),
]
mrkl = initialize_agent(
tools, llm, agent=AgentType.OPENAI_MULTI_FUNCTIONS, verbose=True
)
langchain.debug = True
result = mrkl.run("What is the weather in LA and SF?")
print(result)
# Configuring max iteration behavior
mrkl = initialize_agent(
tools,
llm,
agent=AgentType.OPENAI_FUNCTIONS,
verbose=True,
max_iterations=2,
early_stopping_method="generate",
)
result = mrkl.run("What is the weather in NYC today, yesterday, and the day before?")
print(result)
| [
"langchain.utilities.SerpAPIWrapper",
"langchain.agents.initialize_agent",
"langchain.chat_models.ChatOpenAI",
"langchain.agents.Tool"
] | [((288, 341), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model': '"""gpt-3.5-turbo-0613"""'}), "(temperature=0, model='gpt-3.5-turbo-0613')\n", (298, 341), False, 'from langchain.chat_models import ChatOpenAI\n'), ((352, 368), 'langchain.utilities.SerpAPIWrapper', 'SerpAPIWrapper', ([], {}), '()\n', (366, 368), False, 'from langchain.utilities import SerpAPIWrapper\n'), ((622, 708), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': 'AgentType.OPENAI_MULTI_FUNCTIONS', 'verbose': '(True)'}), '(tools, llm, agent=AgentType.OPENAI_MULTI_FUNCTIONS,\n verbose=True)\n', (638, 708), False, 'from langchain.agents import initialize_agent, Tool\n'), ((850, 982), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': 'AgentType.OPENAI_FUNCTIONS', 'verbose': '(True)', 'max_iterations': '(2)', 'early_stopping_method': '"""generate"""'}), "(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True,\n max_iterations=2, early_stopping_method='generate')\n", (866, 982), False, 'from langchain.agents import initialize_agent, Tool\n'), ((430, 589), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""Search"""', 'func': 'search.run', 'description': '"""Useful when you need to answer questions about current events. You should ask targeted questions."""'}), "(name='Search', func=search.run, description=\n 'Useful when you need to answer questions about current events. You should ask targeted questions.'\n )\n", (434, 589), False, 'from langchain.agents import initialize_agent, Tool\n')] |
import streamlit as st
from dotenv import load_dotenv
import os
from htmlTemplates import css, bot_template, user_template
import langchain
from langchain.document_loaders import GitLoader
from langchain.text_splitter import (
RecursiveCharacterTextSplitter,
Language,
)
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import DeepLake
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
import tempfile
from langchain.prompts.chat import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)
def load_github_repo(github_url, local_path, repo_branch):
loader = GitLoader(
clone_url=github_url,
repo_path=local_path,
branch=repo_branch,
)
docs = loader.load()
return docs
def split_documents(documents_list):
split_documents_list = []
for doc in documents_list:
try:
ext = os.path.splitext(doc.metadata["source"])[1]
lang = get_language_from_extension(ext)
splitter = RecursiveCharacterTextSplitter.from_language(
language=lang, chunk_size=1000, chunk_overlap=0
)
split_docs = splitter.create_documents([doc.page_content])
for split_doc in split_docs:
split_doc.metadata.update(
doc.metadata
) # Copy metadata from original doc
split_documents_list.append(
split_doc
) # Store split documents in a list
except Exception as e:
st.write(
f"Error splitting document: {doc.metadata['source']}, Exception: {str(e)}"
)
return split_documents_list
def get_language_from_extension(ext):
# Simplified mapping from file extension to LangChain Language enum
ext_to_lang = {
".cpp": Language.CPP,
".go": Language.GO,
".java": Language.JAVA,
".js": Language.JS,
".jsx": Language.JS,
".ts": Language.JS,
".tsx": Language.JS,
".php": Language.PHP,
".proto": Language.PROTO,
".py": Language.PYTHON,
".rst": Language.RST,
".rb": Language.RUBY,
".rs": Language.RUST,
".scala": Language.SCALA,
".swift": Language.SWIFT,
".md": Language.MARKDOWN,
".tex": Language.LATEX,
".html": Language.HTML,
".htm": Language.HTML,
".sol": Language.SOL,
".css": Language.HTML,
".txt": Language.MARKDOWN,
".json": Language.MARKDOWN,
}
return ext_to_lang.get(ext, Language.MARKDOWN)
def create_vectorstore(chunks, dataset_path):
embeddings = OpenAIEmbeddings(disallowed_special=())
db = DeepLake(dataset_path=dataset_path, embedding_function=embeddings)
db.add_documents(chunks)
return db
def load_vectorstore(dataset_path):
embeddings = OpenAIEmbeddings(disallowed_special=())
db = DeepLake(
dataset_path=dataset_path,
read_only=True,
embedding_function=embeddings,
)
return db
def get_conversation_chain(vectorstore, gpt_model):
langchain.verbose = False
llm = ChatOpenAI(model=gpt_model, temperature=0.5)
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Define your system message template
general_system_template = """You are a superintelligent AI that answers questions about codebases.
You are:
- helpful & friendly
- good at answering complex questions in simple language
- an expert in all programming languages
- able to infer the intent of the user's question
The user will ask a question about their codebase, and you will answer it.
When the user asks their question, you will answer it by searching the codebase for the answer.
Answer the question using the code file(s) below:
----------------
{context}"""
# Define your user message template
general_user_template = "Question:```{question}```"
# Create message prompt templates from your message templates
system_message_prompt = SystemMessagePromptTemplate.from_template(
general_system_template
)
user_message_prompt = HumanMessagePromptTemplate.from_template(
general_user_template
)
# Create a chat prompt template from your message prompt templates
qa_prompt = ChatPromptTemplate.from_messages(
[system_message_prompt, user_message_prompt]
)
conversation_chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=vectorstore.as_retriever(),
memory=memory,
combine_docs_chain_kwargs={"prompt": qa_prompt},
)
return conversation_chain
def handle_user_input(user_input):
response = st.session_state.conversation({"question": user_input})
st.session_state.chat_history = response["chat_history"]
for i, message in enumerate(st.session_state.chat_history):
if i % 2 == 0:
st.write(
user_template.replace("{{MSG}}", message.content),
unsafe_allow_html=True,
)
else:
st.write(
bot_template.replace("{{MSG}}", message.content), unsafe_allow_html=True
)
def main():
load_dotenv()
st.set_page_config(page_title="Chat with repo")
st.write(css, unsafe_allow_html=True)
with st.sidebar:
"""
Remember to add your `OPENAI_API_KEY` and `ACTIVELOOP_TOKEN` to your .env file.
"""
gpt_model = st.selectbox("Select OpenAI GPT model", ("gpt-3.5-turbo", "gpt-4"))
st.subheader("If you don't have an existing Activeloop dataset enter below")
github_url = st.text_input(
"Enter GitHub repo URL (for example: `https://github.com/username/my_repo`)"
)
repo_branch = st.text_input(
"Enter GitHub repo branch (for example: `master`)", "master"
)
activeloop_url = st.text_input(
"Enter the Activeloop dataset URL where you wish to save your dataset (for example: `hub://username/my_dataset`)"
)
if st.button("Create dataset and start chatting"):
with st.spinner("Processing..."):
with tempfile.TemporaryDirectory() as local_path:
# get code files
docs = load_github_repo(
github_url, local_path, repo_branch="master"
)
# get code chunks
chunks = split_documents(docs)
# create vector store
vectorstore = create_vectorstore(chunks, activeloop_url)
# create conversation chain
st.session_state.conversation = get_conversation_chain(
vectorstore, gpt_model
)
st.subheader("If you already have an existing Activeloop dataset enter below")
activeloop_url = st.text_input(
"Enter your existing Activeloop dataset URL here (for example: `hub://username/my_dataset`)"
)
if st.button("Load dataset and start chatting"):
with st.spinner("Processing..."):
# load vector store
vectorstore = load_vectorstore(activeloop_url)
# create conversation chain
st.session_state.conversation = get_conversation_chain(
vectorstore, gpt_model
)
if "conversation" not in st.session_state:
st.session_state.conversation = None
if "chat_history" not in st.session_state:
st.session_state.chat_history = None
# Error handling?
st.header("Chat with repo")
user_input = st.text_area("Ask question to repo")
if user_input:
handle_user_input(user_input)
if __name__ == "__main__":
main()
| [
"langchain.vectorstores.DeepLake",
"langchain.prompts.chat.HumanMessagePromptTemplate.from_template",
"langchain.chat_models.ChatOpenAI",
"langchain.text_splitter.RecursiveCharacterTextSplitter.from_language",
"langchain.document_loaders.GitLoader",
"langchain.memory.ConversationBufferMemory",
"langchain.embeddings.openai.OpenAIEmbeddings",
"langchain.prompts.chat.SystemMessagePromptTemplate.from_template",
"langchain.prompts.chat.ChatPromptTemplate.from_messages"
] | [((822, 895), 'langchain.document_loaders.GitLoader', 'GitLoader', ([], {'clone_url': 'github_url', 'repo_path': 'local_path', 'branch': 'repo_branch'}), '(clone_url=github_url, repo_path=local_path, branch=repo_branch)\n', (831, 895), False, 'from langchain.document_loaders import GitLoader\n'), ((2876, 2915), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'disallowed_special': '()'}), '(disallowed_special=())\n', (2892, 2915), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((2925, 2991), 'langchain.vectorstores.DeepLake', 'DeepLake', ([], {'dataset_path': 'dataset_path', 'embedding_function': 'embeddings'}), '(dataset_path=dataset_path, embedding_function=embeddings)\n', (2933, 2991), False, 'from langchain.vectorstores import DeepLake\n'), ((3090, 3129), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'disallowed_special': '()'}), '(disallowed_special=())\n', (3106, 3129), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((3139, 3226), 'langchain.vectorstores.DeepLake', 'DeepLake', ([], {'dataset_path': 'dataset_path', 'read_only': '(True)', 'embedding_function': 'embeddings'}), '(dataset_path=dataset_path, read_only=True, embedding_function=\n embeddings)\n', (3147, 3226), False, 'from langchain.vectorstores import DeepLake\n'), ((3361, 3405), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model': 'gpt_model', 'temperature': '(0.5)'}), '(model=gpt_model, temperature=0.5)\n', (3371, 3405), False, 'from langchain.chat_models import ChatOpenAI\n'), ((3419, 3492), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(memory_key='chat_history', return_messages=True)\n", (3443, 3492), False, 'from langchain.memory import ConversationBufferMemory\n'), ((4304, 4370), 'langchain.prompts.chat.SystemMessagePromptTemplate.from_template', 'SystemMessagePromptTemplate.from_template', (['general_system_template'], {}), '(general_system_template)\n', (4345, 4370), False, 'from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((4411, 4474), 'langchain.prompts.chat.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['general_user_template'], {}), '(general_user_template)\n', (4451, 4474), False, 'from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((4577, 4655), 'langchain.prompts.chat.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (['[system_message_prompt, user_message_prompt]'], {}), '([system_message_prompt, user_message_prompt])\n', (4609, 4655), False, 'from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((4965, 5020), 'streamlit.session_state.conversation', 'st.session_state.conversation', (["{'question': user_input}"], {}), "({'question': user_input})\n", (4994, 5020), True, 'import streamlit as st\n'), ((5470, 5483), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (5481, 5483), False, 'from dotenv import load_dotenv\n'), ((5488, 5535), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""Chat with repo"""'}), "(page_title='Chat with repo')\n", (5506, 5535), True, 'import streamlit as st\n'), ((5540, 5577), 'streamlit.write', 'st.write', (['css'], {'unsafe_allow_html': '(True)'}), '(css, unsafe_allow_html=True)\n', (5548, 5577), True, 'import streamlit as st\n'), ((7900, 7927), 'streamlit.header', 'st.header', (['"""Chat with repo"""'], {}), "('Chat with repo')\n", (7909, 7927), True, 'import streamlit as st\n'), ((7945, 7981), 'streamlit.text_area', 'st.text_area', (['"""Ask question to repo"""'], {}), "('Ask question to repo')\n", (7957, 7981), True, 'import streamlit as st\n'), ((5732, 5799), 'streamlit.selectbox', 'st.selectbox', (['"""Select OpenAI GPT model"""', "('gpt-3.5-turbo', 'gpt-4')"], {}), "('Select OpenAI GPT model', ('gpt-3.5-turbo', 'gpt-4'))\n", (5744, 5799), True, 'import streamlit as st\n'), ((5809, 5885), 'streamlit.subheader', 'st.subheader', (['"""If you don\'t have an existing Activeloop dataset enter below"""'], {}), '("If you don\'t have an existing Activeloop dataset enter below")\n', (5821, 5885), True, 'import streamlit as st\n'), ((5907, 6008), 'streamlit.text_input', 'st.text_input', (['"""Enter GitHub repo URL (for example: `https://github.com/username/my_repo`)"""'], {}), "(\n 'Enter GitHub repo URL (for example: `https://github.com/username/my_repo`)'\n )\n", (5920, 6008), True, 'import streamlit as st\n'), ((6043, 6118), 'streamlit.text_input', 'st.text_input', (['"""Enter GitHub repo branch (for example: `master`)"""', '"""master"""'], {}), "('Enter GitHub repo branch (for example: `master`)', 'master')\n", (6056, 6118), True, 'import streamlit as st\n'), ((6166, 6304), 'streamlit.text_input', 'st.text_input', (['"""Enter the Activeloop dataset URL where you wish to save your dataset (for example: `hub://username/my_dataset`)"""'], {}), "(\n 'Enter the Activeloop dataset URL where you wish to save your dataset (for example: `hub://username/my_dataset`)'\n )\n", (6179, 6304), True, 'import streamlit as st\n'), ((6329, 6375), 'streamlit.button', 'st.button', (['"""Create dataset and start chatting"""'], {}), "('Create dataset and start chatting')\n", (6338, 6375), True, 'import streamlit as st\n'), ((7072, 7150), 'streamlit.subheader', 'st.subheader', (['"""If you already have an existing Activeloop dataset enter below"""'], {}), "('If you already have an existing Activeloop dataset enter below')\n", (7084, 7150), True, 'import streamlit as st\n'), ((7177, 7295), 'streamlit.text_input', 'st.text_input', (['"""Enter your existing Activeloop dataset URL here (for example: `hub://username/my_dataset`)"""'], {}), "(\n 'Enter your existing Activeloop dataset URL here (for example: `hub://username/my_dataset`)'\n )\n", (7190, 7295), True, 'import streamlit as st\n'), ((7320, 7364), 'streamlit.button', 'st.button', (['"""Load dataset and start chatting"""'], {}), "('Load dataset and start chatting')\n", (7329, 7364), True, 'import streamlit as st\n'), ((1219, 1316), 'langchain.text_splitter.RecursiveCharacterTextSplitter.from_language', 'RecursiveCharacterTextSplitter.from_language', ([], {'language': 'lang', 'chunk_size': '(1000)', 'chunk_overlap': '(0)'}), '(language=lang, chunk_size=1000,\n chunk_overlap=0)\n', (1263, 1316), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1100, 1140), 'os.path.splitext', 'os.path.splitext', (["doc.metadata['source']"], {}), "(doc.metadata['source'])\n", (1116, 1140), False, 'import os\n'), ((5208, 5257), 'htmlTemplates.user_template.replace', 'user_template.replace', (['"""{{MSG}}"""', 'message.content'], {}), "('{{MSG}}', message.content)\n", (5229, 5257), False, 'from htmlTemplates import css, bot_template, user_template\n'), ((5365, 5413), 'htmlTemplates.bot_template.replace', 'bot_template.replace', (['"""{{MSG}}"""', 'message.content'], {}), "('{{MSG}}', message.content)\n", (5385, 5413), False, 'from htmlTemplates import css, bot_template, user_template\n'), ((6394, 6421), 'streamlit.spinner', 'st.spinner', (['"""Processing..."""'], {}), "('Processing...')\n", (6404, 6421), True, 'import streamlit as st\n'), ((7383, 7410), 'streamlit.spinner', 'st.spinner', (['"""Processing..."""'], {}), "('Processing...')\n", (7393, 7410), True, 'import streamlit as st\n'), ((6444, 6473), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (6471, 6473), False, 'import tempfile\n')] |
import json
from llama_index.core.service_context_elements.llm_predictor import LLMPredictor
from llama_index.core.utilities.sql_wrapper import SQLDatabase
from llama_index.core.response_synthesizers import get_response_synthesizer
from llama_index.embeddings.langchain import LangchainEmbedding
from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.postprocessor import SimilarityPostprocessor
from llama_index.core.prompts import PromptTemplate
from llama_index.core.chat_engine import CondensePlusContextChatEngine, ContextChatEngine
from llama_index.core.indices.struct_store.sql_query import NLSQLTableQueryEngine
from llama_index.core.schema import ImageDocument
from llama_index.core.base.llms.types import ChatMessage
from llama_index.core.postprocessor.llm_rerank import LLMRerank
from llama_index.postprocessor.colbert_rerank import ColbertRerank
from llama_index.core.tools import ToolMetadata
from llama_index.core.selectors import LLMSingleSelector
from langchain.agents import initialize_agent
import ollama
from sqlalchemy import create_engine
from app.llms.tools.dalle import DalleImage
from app.llms.tools.describeimage import DescribeImage
from app.llms.tools.instantid import InstantID
from app.llms.tools.stablediffusion import StableDiffusionImage
from app.model import Model
from app.models import LLMModel, ProjectModel, QuestionModel, ChatModel
from app.project import Project
from app.tools import getLLMClass
from app.vectordb import vector_init
from modules.embeddings import EMBEDDINGS
from app.database import dbc
from sqlalchemy.orm import Session
from langchain_community.chat_models import ChatOpenAI
from transformers import pipeline
class Brain:
def __init__(self):
self.llmCache = {}
self.embeddingCache = {}
self.defaultCensorship = "This question is outside of my scope. Didn't find any related data."
self.defaultNegative = "I'm sorry, I don't know the answer to that."
self.defaultSystem = ""
self.loopFailsafe = 0
def memoryModelsInfo(self):
models = []
for llmr, mr in self.llmCache.items():
if mr.privacy == "private":
models.append(llmr)
return models
def getLLM(self, llmName, db: Session, **kwargs):
llm = None
if llmName in self.llmCache:
llm = self.llmCache[llmName]
else:
llm = self.loadLLM(llmName, db)
if llm.props.class_name == "Ollama":
model_name = json.loads(llm.props.options).get("model")
try:
ollama.show(model_name)
except Exception as e:
if e.status_code == 404:
print("Model not found, pulling " + model_name + " from Ollama")
ollama.pull(model_name)
else:
raise e
return llm
def loadLLM(self, llmName, db: Session):
llm_db = dbc.get_llm_by_name(db, llmName)
if llm_db is not None:
llmm = LLMModel.model_validate(llm_db)
llm = getLLMClass(llmm.class_name)(**json.loads(llmm.options))
if llmName in self.llmCache:
del self.llmCache[llmName]
self.llmCache[llmName] = Model(llmName, llmm, llm)
return self.llmCache[llmName]
else:
return None
def getEmbedding(self, embeddingModel):
if embeddingModel in self.embeddingCache:
return self.embeddingCache[embeddingModel]
else:
if embeddingModel in EMBEDDINGS:
embedding_class, embedding_args, privacy, description = EMBEDDINGS[embeddingModel]
model = LangchainEmbedding(embedding_class(**embedding_args))
self.embeddingCache[embeddingModel] = model
return model
else:
raise Exception("Invalid Embedding type.")
def findProject(self, name, db):
p = dbc.get_project_by_name(db, name)
if p is None:
return None
proj = ProjectModel.model_validate(p)
if proj is not None:
project = Project()
project.model = proj
if project.model.type == "rag":
project.db = vector_init(self, project)
return project
def entryChat(self, projectName: str, chatModel: ChatModel, db: Session):
project = self.findProject(projectName, db)
model = self.getLLM(project.model.llm, db)
chat = project.loadChat(chatModel)
threshold = chatModel.score or project.model.score or 0.2
k = chatModel.k or project.model.k or 1
sysTemplate = project.model.system or self.defaultSystem
if project.model.colbert_rerank or project.model.llm_rerank:
final_k = k * 2
else:
final_k = k
retriever = VectorIndexRetriever(
index=project.db,
similarity_top_k=final_k,
)
postprocessors = []
if project.model.colbert_rerank:
postprocessors.append(ColbertRerank(
top_n=k,
model="colbert-ir/colbertv2.0",
tokenizer="colbert-ir/colbertv2.0",
keep_retrieval_score=True,
))
if project.model.llm_rerank:
postprocessors.append(LLMRerank(
choice_batch_size=k,
top_n=k,
llm=model.llm,
))
postprocessors.append(SimilarityPostprocessor(similarity_cutoff=threshold))
chat_engine = ContextChatEngine.from_defaults(
retriever=retriever,
system_prompt=sysTemplate,
memory=chat.history,
node_postprocessors=postprocessors,
)
chat_engine._llm = model.llm
try:
if chatModel.stream:
response = chat_engine.stream_chat(chatModel.question)
else:
response = chat_engine.chat(chatModel.question)
output_nodes = []
for node in response.source_nodes:
output_nodes.append(
{"source": node.metadata["source"], "keywords": node.metadata["keywords"], "score": node.score, "id": node.node_id, "text": node.text})
output = {
"id": chat.id,
"question": chatModel.question,
"sources": output_nodes,
"type": "chat"
}
if chatModel.stream:
if hasattr(response, "response_gen"):
for text in response.response_gen:
yield "data: " + text + "\n\n"
yield "data: " + json.dumps(output) + "\n"
yield "event: close\n\n"
else:
yield "data: " + self.defaultCensorship + "\n\n"
yield "data: " + json.dumps(output) + "\n"
yield "event: close\n\n"
else:
if len(response.source_nodes) == 0:
output["answer"] = project.model.censorship or self.defaultCensorship
else:
output["answer"] = response.response
yield output
except Exception as e:
if chatModel.stream:
yield "data: Inference failed\n"
yield "event: error\n\n"
raise e
def entryQuestion(self, projectName: str, questionModel: QuestionModel, db: Session):
project = self.findProject(projectName, db)
model = self.getLLM(project.model.llm, db)
sysTemplate = questionModel.system or project.model.system or self.defaultSystem
k = questionModel.k or project.model.k or 2
threshold = questionModel.score or project.model.score or 0.2
if questionModel.colbert_rerank or questionModel.llm_rerank or project.model.colbert_rerank or project.model.llm_rerank:
final_k = k * 2
else:
final_k = k
retriever = VectorIndexRetriever(
index=project.db,
similarity_top_k=final_k,
)
qa_prompt_tmpl = (
"Context information is below.\n"
"---------------------\n"
"{context_str}\n"
"---------------------\n"
"Given the context information and not prior knowledge, "
"answer the query.\n"
"Query: {query_str}\n"
"Answer: "
)
qa_prompt = PromptTemplate(qa_prompt_tmpl)
llm_predictor = LLMPredictor(llm=model.llm, system_prompt=sysTemplate)
response_synthesizer = get_response_synthesizer(llm=llm_predictor, text_qa_template=qa_prompt, streaming=questionModel.stream)
postprocessors = []
if questionModel.colbert_rerank or project.model.colbert_rerank:
postprocessors.append(ColbertRerank(
top_n=k,
model="colbert-ir/colbertv2.0",
tokenizer="colbert-ir/colbertv2.0",
keep_retrieval_score=True,
))
if questionModel.llm_rerank or project.model.llm_rerank:
postprocessors.append(LLMRerank(
choice_batch_size=k,
top_n=k,
llm=model.llm,
))
postprocessors.append(SimilarityPostprocessor(similarity_cutoff=threshold))
query_engine = RetrieverQueryEngine(
retriever=retriever,
response_synthesizer=response_synthesizer,
node_postprocessors=postprocessors
)
try:
response = query_engine.query(questionModel.question)
output_nodes = []
if hasattr(response, "source_nodes"):
for node in response.source_nodes:
output_nodes.append(
{"source": node.metadata["source"], "keywords": node.metadata["keywords"], "score": node.score, "id": node.node_id, "text": node.text})
output = {
"question": questionModel.question,
"sources": output_nodes,
"type": "question"
}
if questionModel.stream:
if hasattr(response, "response_gen"):
for text in response.response_gen:
yield "data: " + text + "\n\n"
yield "data: " + json.dumps(output) + "\n"
yield "event: close\n\n"
else :
yield "data: " + self.defaultCensorship + "\n\n"
yield "data: " + json.dumps(output) + "\n"
yield "event: close\n\n"
else:
if len(response.source_nodes) == 0:
output["answer"] = project.model.censorship or self.defaultCensorship
else:
output["answer"] = response.response
yield output
except Exception as e:
if questionModel.stream:
yield "data: Inference failed\n"
yield "event: error\n\n"
raise e
def entryVision(self, projectName, visionInput, isprivate, db: Session):
image = None
output = ""
project = self.findProject(projectName, db)
if project is None:
raise Exception("Project not found")
tools = [
DalleImage(),
StableDiffusionImage(),
DescribeImage(),
InstantID(),
]
if isprivate:
tools.pop(0)
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
agent = initialize_agent(
tools, llm, agent="zero-shot-react-description", verbose=True)
outputAgent = agent.run(visionInput.question, tags=[visionInput])
if isinstance(outputAgent, str):
output = outputAgent
else:
if outputAgent["type"] == "describeimage":
model = self.getLLM(project.model.llm, db)
try:
response = model.llm.complete(prompt=visionInput.question, image_documents=[ImageDocument(image=visionInput.image)])
except Exception as e:
raise e
output = response.text
image = visionInput.image
else:
output = outputAgent["prompt"]
image = outputAgent["image"]
outputf = {
"question": visionInput.question,
"answer": output,
"image": image,
"sources": [],
"type": "vision"
}
return outputf
def inference(self, projectName, inferenceModel, db: Session):
project = self.findProject(projectName, db)
if project is None:
raise Exception("Project not found")
model = self.getLLM(project.model.llm, db)
sysTemplate = inferenceModel.system or project.model.system or self.defaultSystem
model.llm.system_prompt = sysTemplate
#model.llm.system = sysTemplate
#resp = model.llm.complete(inferenceModel.question)
messages = [
ChatMessage(
role="system", content=sysTemplate
),
ChatMessage(role="user", content=inferenceModel.question),
]
try:
if(inferenceModel.stream):
respgen = model.llm.stream_chat(messages)
for text in respgen:
yield "data: " + text.delta + "\n\n"
yield "event: close\n\n"
else:
resp = model.llm.chat(messages)
output = {
"question": inferenceModel.question,
"answer": resp.message.content.strip(),
"type": "inference"
}
yield output
except Exception as e:
if inferenceModel.stream:
yield "data: Inference failed\n"
yield "event: error\n\n"
raise e
def ragSQL(self, projectName, questionModel, db: Session):
project = self.findProject(projectName, db)
if project is None:
raise Exception("Project not found")
model = self.getLLM(project.model.llm, db)
engine = create_engine(project.model.connection)
sql_database = SQLDatabase(engine)
tables = None
if hasattr(questionModel, 'tables') and questionModel.tables is not None:
tables = questionModel.tables
elif project.model.tables:
tables = [table.strip() for table in project.model.tables.split(',')]
query_engine = NLSQLTableQueryEngine(
llm=model.llm,
sql_database=sql_database,
tables=tables,
)
question = (project.model.system or self.defaultSystem) + "\n Question: " + questionModel.question
try:
response = query_engine.query(question)
except Exception as e:
raise e
output = {
"question": questionModel.question,
"answer": response.response,
"sources": [response.metadata['sql_query']],
"type": "questionsql"
}
return output
def router(self, projectName, questionModel, db: Session):
choices = []
project = self.findProject(projectName, db)
if project is None:
raise Exception("Project not found")
for entrance in project.model.entrances:
choices.append(ToolMetadata(description=entrance.description, name=entrance.name))
selector = LLMSingleSelector.from_defaults()
selector_result = selector.select(
choices, query=questionModel.question
)
projectNameDest = project.model.entrances[selector_result.selections[0].index].destination
return projectNameDest
def classify(self, input):
classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
sequence_to_classify = input.sequence
candidate_labels = input.labels
return classifier(sequence_to_classify, candidate_labels, multi_label=True) | [
"langchain.agents.initialize_agent",
"langchain_community.chat_models.ChatOpenAI"
] | [((3043, 3075), 'app.database.dbc.get_llm_by_name', 'dbc.get_llm_by_name', (['db', 'llmName'], {}), '(db, llmName)\n', (3062, 3075), False, 'from app.database import dbc\n'), ((4079, 4112), 'app.database.dbc.get_project_by_name', 'dbc.get_project_by_name', (['db', 'name'], {}), '(db, name)\n', (4102, 4112), False, 'from app.database import dbc\n'), ((4174, 4204), 'app.models.ProjectModel.model_validate', 'ProjectModel.model_validate', (['p'], {}), '(p)\n', (4201, 4204), False, 'from app.models import LLMModel, ProjectModel, QuestionModel, ChatModel\n'), ((4998, 5062), 'llama_index.core.retrievers.VectorIndexRetriever', 'VectorIndexRetriever', ([], {'index': 'project.db', 'similarity_top_k': 'final_k'}), '(index=project.db, similarity_top_k=final_k)\n', (5018, 5062), False, 'from llama_index.core.retrievers import VectorIndexRetriever\n'), ((5712, 5853), 'llama_index.core.chat_engine.ContextChatEngine.from_defaults', 'ContextChatEngine.from_defaults', ([], {'retriever': 'retriever', 'system_prompt': 'sysTemplate', 'memory': 'chat.history', 'node_postprocessors': 'postprocessors'}), '(retriever=retriever, system_prompt=\n sysTemplate, memory=chat.history, node_postprocessors=postprocessors)\n', (5743, 5853), False, 'from llama_index.core.chat_engine import CondensePlusContextChatEngine, ContextChatEngine\n'), ((8196, 8260), 'llama_index.core.retrievers.VectorIndexRetriever', 'VectorIndexRetriever', ([], {'index': 'project.db', 'similarity_top_k': 'final_k'}), '(index=project.db, similarity_top_k=final_k)\n', (8216, 8260), False, 'from llama_index.core.retrievers import VectorIndexRetriever\n'), ((8669, 8699), 'llama_index.core.prompts.PromptTemplate', 'PromptTemplate', (['qa_prompt_tmpl'], {}), '(qa_prompt_tmpl)\n', (8683, 8699), False, 'from llama_index.core.prompts import PromptTemplate\n'), ((8725, 8779), 'llama_index.core.service_context_elements.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'model.llm', 'system_prompt': 'sysTemplate'}), '(llm=model.llm, system_prompt=sysTemplate)\n', (8737, 8779), False, 'from llama_index.core.service_context_elements.llm_predictor import LLMPredictor\n'), ((8812, 8919), 'llama_index.core.response_synthesizers.get_response_synthesizer', 'get_response_synthesizer', ([], {'llm': 'llm_predictor', 'text_qa_template': 'qa_prompt', 'streaming': 'questionModel.stream'}), '(llm=llm_predictor, text_qa_template=qa_prompt,\n streaming=questionModel.stream)\n', (8836, 8919), False, 'from llama_index.core.response_synthesizers import get_response_synthesizer\n'), ((9591, 9716), 'llama_index.core.query_engine.RetrieverQueryEngine', 'RetrieverQueryEngine', ([], {'retriever': 'retriever', 'response_synthesizer': 'response_synthesizer', 'node_postprocessors': 'postprocessors'}), '(retriever=retriever, response_synthesizer=\n response_synthesizer, node_postprocessors=postprocessors)\n', (9611, 9716), False, 'from llama_index.core.query_engine import RetrieverQueryEngine\n'), ((11773, 11821), 'langchain_community.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model': '"""gpt-3.5-turbo"""', 'temperature': '(0)'}), "(model='gpt-3.5-turbo', temperature=0)\n", (11783, 11821), False, 'from langchain_community.chat_models import ChatOpenAI\n'), ((11839, 11918), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': '"""zero-shot-react-description"""', 'verbose': '(True)'}), "(tools, llm, agent='zero-shot-react-description', verbose=True)\n", (11855, 11918), False, 'from langchain.agents import initialize_agent\n'), ((14562, 14601), 'sqlalchemy.create_engine', 'create_engine', (['project.model.connection'], {}), '(project.model.connection)\n', (14575, 14601), False, 'from sqlalchemy import create_engine\n'), ((14626, 14645), 'llama_index.core.utilities.sql_wrapper.SQLDatabase', 'SQLDatabase', (['engine'], {}), '(engine)\n', (14637, 14645), False, 'from llama_index.core.utilities.sql_wrapper import SQLDatabase\n'), ((14934, 15012), 'llama_index.core.indices.struct_store.sql_query.NLSQLTableQueryEngine', 'NLSQLTableQueryEngine', ([], {'llm': 'model.llm', 'sql_database': 'sql_database', 'tables': 'tables'}), '(llm=model.llm, sql_database=sql_database, tables=tables)\n', (14955, 15012), False, 'from llama_index.core.indices.struct_store.sql_query import NLSQLTableQueryEngine\n'), ((15938, 15971), 'llama_index.core.selectors.LLMSingleSelector.from_defaults', 'LLMSingleSelector.from_defaults', ([], {}), '()\n', (15969, 15971), False, 'from llama_index.core.selectors import LLMSingleSelector\n'), ((16273, 16343), 'transformers.pipeline', 'pipeline', (['"""zero-shot-classification"""'], {'model': '"""facebook/bart-large-mnli"""'}), "('zero-shot-classification', model='facebook/bart-large-mnli')\n", (16281, 16343), False, 'from transformers import pipeline\n'), ((3127, 3158), 'app.models.LLMModel.model_validate', 'LLMModel.model_validate', (['llm_db'], {}), '(llm_db)\n', (3150, 3158), False, 'from app.models import LLMModel, ProjectModel, QuestionModel, ChatModel\n'), ((3357, 3382), 'app.model.Model', 'Model', (['llmName', 'llmm', 'llm'], {}), '(llmName, llmm, llm)\n', (3362, 3382), False, 'from app.model import Model\n'), ((4256, 4265), 'app.project.Project', 'Project', ([], {}), '()\n', (4263, 4265), False, 'from app.project import Project\n'), ((5635, 5687), 'llama_index.core.postprocessor.SimilarityPostprocessor', 'SimilarityPostprocessor', ([], {'similarity_cutoff': 'threshold'}), '(similarity_cutoff=threshold)\n', (5658, 5687), False, 'from llama_index.core.postprocessor import SimilarityPostprocessor\n'), ((9513, 9565), 'llama_index.core.postprocessor.SimilarityPostprocessor', 'SimilarityPostprocessor', ([], {'similarity_cutoff': 'threshold'}), '(similarity_cutoff=threshold)\n', (9536, 9565), False, 'from llama_index.core.postprocessor import SimilarityPostprocessor\n'), ((11596, 11608), 'app.llms.tools.dalle.DalleImage', 'DalleImage', ([], {}), '()\n', (11606, 11608), False, 'from app.llms.tools.dalle import DalleImage\n'), ((11622, 11644), 'app.llms.tools.stablediffusion.StableDiffusionImage', 'StableDiffusionImage', ([], {}), '()\n', (11642, 11644), False, 'from app.llms.tools.stablediffusion import StableDiffusionImage\n'), ((11658, 11673), 'app.llms.tools.describeimage.DescribeImage', 'DescribeImage', ([], {}), '()\n', (11671, 11673), False, 'from app.llms.tools.describeimage import DescribeImage\n'), ((11687, 11698), 'app.llms.tools.instantid.InstantID', 'InstantID', ([], {}), '()\n', (11696, 11698), False, 'from app.llms.tools.instantid import InstantID\n'), ((13403, 13450), 'llama_index.core.base.llms.types.ChatMessage', 'ChatMessage', ([], {'role': '"""system"""', 'content': 'sysTemplate'}), "(role='system', content=sysTemplate)\n", (13414, 13450), False, 'from llama_index.core.base.llms.types import ChatMessage\n'), ((13494, 13551), 'llama_index.core.base.llms.types.ChatMessage', 'ChatMessage', ([], {'role': '"""user"""', 'content': 'inferenceModel.question'}), "(role='user', content=inferenceModel.question)\n", (13505, 13551), False, 'from llama_index.core.base.llms.types import ChatMessage\n'), ((2679, 2702), 'ollama.show', 'ollama.show', (['model_name'], {}), '(model_name)\n', (2690, 2702), False, 'import ollama\n'), ((3178, 3206), 'app.tools.getLLMClass', 'getLLMClass', (['llmm.class_name'], {}), '(llmm.class_name)\n', (3189, 3206), False, 'from app.tools import getLLMClass\n'), ((4372, 4398), 'app.vectordb.vector_init', 'vector_init', (['self', 'project'], {}), '(self, project)\n', (4383, 4398), False, 'from app.vectordb import vector_init\n'), ((5203, 5325), 'llama_index.postprocessor.colbert_rerank.ColbertRerank', 'ColbertRerank', ([], {'top_n': 'k', 'model': '"""colbert-ir/colbertv2.0"""', 'tokenizer': '"""colbert-ir/colbertv2.0"""', 'keep_retrieval_score': '(True)'}), "(top_n=k, model='colbert-ir/colbertv2.0', tokenizer=\n 'colbert-ir/colbertv2.0', keep_retrieval_score=True)\n", (5216, 5325), False, 'from llama_index.postprocessor.colbert_rerank import ColbertRerank\n'), ((5473, 5527), 'llama_index.core.postprocessor.llm_rerank.LLMRerank', 'LLMRerank', ([], {'choice_batch_size': 'k', 'top_n': 'k', 'llm': 'model.llm'}), '(choice_batch_size=k, top_n=k, llm=model.llm)\n', (5482, 5527), False, 'from llama_index.core.postprocessor.llm_rerank import LLMRerank\n'), ((9053, 9175), 'llama_index.postprocessor.colbert_rerank.ColbertRerank', 'ColbertRerank', ([], {'top_n': 'k', 'model': '"""colbert-ir/colbertv2.0"""', 'tokenizer': '"""colbert-ir/colbertv2.0"""', 'keep_retrieval_score': '(True)'}), "(top_n=k, model='colbert-ir/colbertv2.0', tokenizer=\n 'colbert-ir/colbertv2.0', keep_retrieval_score=True)\n", (9066, 9175), False, 'from llama_index.postprocessor.colbert_rerank import ColbertRerank\n'), ((9351, 9405), 'llama_index.core.postprocessor.llm_rerank.LLMRerank', 'LLMRerank', ([], {'choice_batch_size': 'k', 'top_n': 'k', 'llm': 'model.llm'}), '(choice_batch_size=k, top_n=k, llm=model.llm)\n', (9360, 9405), False, 'from llama_index.core.postprocessor.llm_rerank import LLMRerank\n'), ((15841, 15907), 'llama_index.core.tools.ToolMetadata', 'ToolMetadata', ([], {'description': 'entrance.description', 'name': 'entrance.name'}), '(description=entrance.description, name=entrance.name)\n', (15853, 15907), False, 'from llama_index.core.tools import ToolMetadata\n'), ((2603, 2632), 'json.loads', 'json.loads', (['llm.props.options'], {}), '(llm.props.options)\n', (2613, 2632), False, 'import json\n'), ((3209, 3233), 'json.loads', 'json.loads', (['llmm.options'], {}), '(llmm.options)\n', (3219, 3233), False, 'import json\n'), ((2878, 2901), 'ollama.pull', 'ollama.pull', (['model_name'], {}), '(model_name)\n', (2889, 2901), False, 'import ollama\n'), ((6841, 6859), 'json.dumps', 'json.dumps', (['output'], {}), '(output)\n', (6851, 6859), False, 'import json\n'), ((7040, 7058), 'json.dumps', 'json.dumps', (['output'], {}), '(output)\n', (7050, 7058), False, 'import json\n'), ((10598, 10616), 'json.dumps', 'json.dumps', (['output'], {}), '(output)\n', (10608, 10616), False, 'import json\n'), ((10798, 10816), 'json.dumps', 'json.dumps', (['output'], {}), '(output)\n', (10808, 10816), False, 'import json\n'), ((12336, 12374), 'llama_index.core.schema.ImageDocument', 'ImageDocument', ([], {'image': 'visionInput.image'}), '(image=visionInput.image)\n', (12349, 12374), False, 'from llama_index.core.schema import ImageDocument\n')] |
# This is an example of integrating a LLM with streamlit
import streamlit as st
import os
import openai
import langchain
from langchain.llms import OpenAI
from langchain import PromptTemplate
#from dotenv import load_dotenv
# Specify the path to the .env file
#dotenv_path = os.path.join(os.path.dirname(__file__), '.env')
# Load the .env file
#load_dotenv(dotenv_path)
# Streamlit Code
st.set_page_config(page_title="Globalize Email", page_icon = ":robot:")
st.header("Globalize Text")
# LLM Code
template = """
Below is an email that is poorly worded.
Your goal is to:
- Properly format the email
- Convert the input text to a specified tone
- Convert the input text to a specified dialect
Here are some examples of different Tones:
- Formal: We went to Barcelona for the weekend. We have a lot of things to tell you.
- Information: Went to Barcelona for the weekend. Lots to tell you.
Here are some examples of words in different dialects:
- American English: French Fries, cotton candy, apartment, garbage cookie
- British English: chips, candyfloss, flag, rubbish, biscuit
Below is the email, tone, and dialect:
TONE: {tone}
DIALECT: {dialect}
EMAIL: {email}
YOUR RESPONSE:
"""
prompt = PromptTemplate(
input_variables=["tone", "dialect", "email"],
template = template,
)
llm = OpenAI(temperature = .5)
col1, col2 = st. columns(2)
with col1:
st.markdown("This application is a demo of the SRL chatbot being developed between UCATT and UAHS International")
with col2:
st.image(image='screenshot.png', width=500, caption="Screenshot of source video")
st.markdown("## Enter Your Email to Convert")
col1, col2 = st.columns(2)
with col1:
option_tone = st.selectbox(
'Which tone would you like your email to have?',
('Formal', 'Informal'))
with col2:
option_dialect = st.selectbox(
'Which English Dialect would you like?',
('American English', 'British English')
)
def get_text():
input_text = st.text_area(label="", placeholder = "Your email...", key="email_input")
return input_text
email_input = get_text()
st.markdown("### Your Converted Email:")
if email_input:
prompt_with_email = prompt.format(tone = option_tone, dialect = option_dialect, email = email_input)
# See full prompt
#st.write(prompt_with_email)
formatted_email = llm(prompt_with_email)
st.write(formatted_email)
| [
"langchain.llms.OpenAI",
"langchain.PromptTemplate"
] | [((390, 459), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""Globalize Email"""', 'page_icon': '""":robot:"""'}), "(page_title='Globalize Email', page_icon=':robot:')\n", (408, 459), True, 'import streamlit as st\n'), ((462, 489), 'streamlit.header', 'st.header', (['"""Globalize Text"""'], {}), "('Globalize Text')\n", (471, 489), True, 'import streamlit as st\n'), ((1280, 1359), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['tone', 'dialect', 'email']", 'template': 'template'}), "(input_variables=['tone', 'dialect', 'email'], template=template)\n", (1294, 1359), False, 'from langchain import PromptTemplate\n'), ((1380, 1403), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0.5)'}), '(temperature=0.5)\n', (1386, 1403), False, 'from langchain.llms import OpenAI\n'), ((1419, 1432), 'streamlit.columns', 'st.columns', (['(2)'], {}), '(2)\n', (1429, 1432), True, 'import streamlit as st\n'), ((1663, 1708), 'streamlit.markdown', 'st.markdown', (['"""## Enter Your Email to Convert"""'], {}), "('## Enter Your Email to Convert')\n", (1674, 1708), True, 'import streamlit as st\n'), ((1723, 1736), 'streamlit.columns', 'st.columns', (['(2)'], {}), '(2)\n', (1733, 1736), True, 'import streamlit as st\n'), ((2179, 2219), 'streamlit.markdown', 'st.markdown', (['"""### Your Converted Email:"""'], {}), "('### Your Converted Email:')\n", (2190, 2219), True, 'import streamlit as st\n'), ((1450, 1573), 'streamlit.markdown', 'st.markdown', (['"""This application is a demo of the SRL chatbot being developed between UCATT and UAHS International"""'], {}), "(\n 'This application is a demo of the SRL chatbot being developed between UCATT and UAHS International'\n )\n", (1461, 1573), True, 'import streamlit as st\n'), ((1580, 1666), 'streamlit.image', 'st.image', ([], {'image': '"""screenshot.png"""', 'width': '(500)', 'caption': '"""Screenshot of source video"""'}), "(image='screenshot.png', width=500, caption=\n 'Screenshot of source video')\n", (1588, 1666), True, 'import streamlit as st\n'), ((1766, 1855), 'streamlit.selectbox', 'st.selectbox', (['"""Which tone would you like your email to have?"""', "('Formal', 'Informal')"], {}), "('Which tone would you like your email to have?', ('Formal',\n 'Informal'))\n", (1778, 1855), True, 'import streamlit as st\n'), ((1906, 2004), 'streamlit.selectbox', 'st.selectbox', (['"""Which English Dialect would you like?"""', "('American English', 'British English')"], {}), "('Which English Dialect would you like?', ('American English',\n 'British English'))\n", (1918, 2004), True, 'import streamlit as st\n'), ((2057, 2127), 'streamlit.text_area', 'st.text_area', ([], {'label': '""""""', 'placeholder': '"""Your email..."""', 'key': '"""email_input"""'}), "(label='', placeholder='Your email...', key='email_input')\n", (2069, 2127), True, 'import streamlit as st\n'), ((2453, 2478), 'streamlit.write', 'st.write', (['formatted_email'], {}), '(formatted_email)\n', (2461, 2478), True, 'import streamlit as st\n')] |
import sys
sys.stdout.reconfigure(encoding="utf-8")
sys.stdin.reconfigure(encoding="utf-8")
import streamlit as st
import streamlit.components.v1 as components
import re
import random
CODE_BUILD_KG = """
# 准备 GraphStore
os.environ['NEBULA_USER'] = "root"
os.environ['NEBULA_PASSWORD'] = "nebula" # default password
os.environ['NEBULA_ADDRESS'] = "127.0.0.1:9669" # assumed we have NebulaGraph installed locally
space_name = "guardians"
edge_types, rel_prop_names = ["relationship"], ["relationship"] # default, could be omit if create from an empty kg
tags = ["entity"] # default, could be omit if create from an empty kg
graph_store = NebulaGraphStore(space_name=space_name, edge_types=edge_types, rel_prop_names=rel_prop_names, tags=tags)
storage_context = StorageContext.from_defaults(graph_store=graph_store)
# 从维基百科下载、预处理数据
from llama_index import download_loader
WikipediaReader = download_loader("WikipediaReader")
loader = WikipediaReader()
documents = loader.load_data(pages=['Guardians of the Galaxy Vol. 3'], auto_suggest=False)
# 利用 LLM 从文档中抽取知识三元组，并存储到 GraphStore（NebulaGraph）
kg_index = KnowledgeGraphIndex.from_documents(
documents,
storage_context=storage_context,
max_triplets_per_chunk=10,
service_context=service_context,
space_name=space_name,
edge_types=edge_types,
rel_prop_names=rel_prop_names,
tags=tags,
include_embeddings=True,
)
"""
CODE_NL2CYPHER_LANGCHAIN = """
## Langchain
# Doc: https://python.langchain.com/docs/modules/chains/additional/graph_nebula_qa
from langchain.chat_models import ChatOpenAI
from langchain.chains import NebulaGraphQAChain
from langchain.graphs import NebulaGraph
graph = NebulaGraph(
space=space_name,
username="root",
password="nebula",
address="127.0.0.1",
port=9669,
session_pool_size=30,
)
chain = NebulaGraphQAChain.from_llm(
llm, graph=graph, verbose=True
)
chain.run(
"Tell me about Peter Quill?",
)
"""
CODE_NL2CYPHER_LLAMAINDEX = """
## Llama Index
# Doc: https://gpt-index.readthedocs.io/en/latest/examples/query_engine/knowledge_graph_query_engine.html
from llama_index.query_engine import KnowledgeGraphQueryEngine
from llama_index.storage.storage_context import StorageContext
from llama_index.graph_stores import NebulaGraphStore
nl2kg_query_engine = KnowledgeGraphQueryEngine(
storage_context=storage_context,
service_context=service_context,
llm=llm,
verbose=True,
)
response = nl2kg_query_engine.query(
"Tell me about Peter Quill?",
)
"""
import os
import json
import openai
from llama_index.llms import AzureOpenAI
from langchain.embeddings import OpenAIEmbeddings
from llama_index import LangchainEmbedding
from llama_index import (
VectorStoreIndex,
SimpleDirectoryReader,
KnowledgeGraphIndex,
LLMPredictor,
ServiceContext,
)
from llama_index.storage.storage_context import StorageContext
from llama_index.graph_stores import NebulaGraphStore
import logging
import sys
logging.basicConfig(
stream=sys.stdout, level=logging.INFO
) # logging.DEBUG for more verbose output
# logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))
openai.api_type = "azure"
openai.api_base = st.secrets["OPENAI_API_BASE"]
# openai.api_version = "2022-12-01" azure gpt-3
openai.api_version = "2023-05-15" # azure gpt-3.5 turbo
openai.api_key = st.secrets["OPENAI_API_KEY"]
llm = AzureOpenAI(
engine=st.secrets["DEPLOYMENT_NAME"],
temperature=0,
model="gpt-35-turbo",
)
llm_predictor = LLMPredictor(llm=llm)
# You need to deploy your own embedding model as well as your own chat completion model
embedding_llm = LangchainEmbedding(
OpenAIEmbeddings(
model="text-embedding-ada-002",
deployment=st.secrets["EMBEDDING_DEPLOYMENT_NAME"],
openai_api_key=openai.api_key,
openai_api_base=openai.api_base,
openai_api_type=openai.api_type,
openai_api_version=openai.api_version,
),
embed_batch_size=1,
)
service_context = ServiceContext.from_defaults(
llm_predictor=llm_predictor,
embed_model=embedding_llm,
)
os.environ["NEBULA_USER"] = st.secrets["graphd_user"]
os.environ["NEBULA_PASSWORD"] = st.secrets["graphd_password"]
os.environ[
"NEBULA_ADDRESS"
] = f"{st.secrets['graphd_host']}:{st.secrets['graphd_port']}"
space_name = "guardians"
edge_types, rel_prop_names = ["relationship"], [
"relationship"
] # default, could be omit if create from an empty kg
tags = ["entity"] # default, could be omit if create from an empty kg
graph_store = NebulaGraphStore(
space_name=space_name,
edge_types=edge_types,
rel_prop_names=rel_prop_names,
tags=tags,
)
storage_context = StorageContext.from_defaults(graph_store=graph_store)
from llama_index.query_engine import KnowledgeGraphQueryEngine
from llama_index.storage.storage_context import StorageContext
from llama_index.graph_stores import NebulaGraphStore
nl2kg_query_engine = KnowledgeGraphQueryEngine(
storage_context=storage_context,
service_context=service_context,
llm=llm,
verbose=True,
)
def cypher_to_all_paths(query):
# Find the MATCH and RETURN parts
match_parts = re.findall(r"(MATCH .+?(?=MATCH|$))", query, re.I | re.S)
return_part = re.search(r"RETURN .+", query).group()
modified_matches = []
path_ids = []
# Go through each MATCH part
for i, part in enumerate(match_parts):
path_id = f"path_{i}"
path_ids.append(path_id)
# Replace the MATCH keyword with "MATCH path_i = "
modified_part = part.replace("MATCH ", f"MATCH {path_id} = ")
modified_matches.append(modified_part)
# Join the modified MATCH parts
matches_string = " ".join(modified_matches)
# Construct the new RETURN part
return_string = f"RETURN {', '.join(path_ids)};"
# Remove the old RETURN part from matches_string
matches_string = matches_string.replace(return_part, "")
# Combine everything
modified_query = f"{matches_string}\n{return_string}"
return modified_query
# write string to file
def result_to_df(result):
from typing import Dict
import pandas as pd
columns = result.keys()
d: Dict[str, list] = {}
for col_num in range(result.col_size()):
col_name = columns[col_num]
col_list = result.column_values(col_name)
d[col_name] = [x.cast() for x in col_list]
return pd.DataFrame(d)
def render_pd_item(g, item):
from nebula3.data.DataObject import Node, PathWrapper, Relationship
if isinstance(item, Node):
node_id = item.get_id().cast()
tags = item.tags() # list of strings
props = dict()
for tag in tags:
props.update(item.properties(tag))
g.add_node(node_id, label=node_id, title=str(props))
elif isinstance(item, Relationship):
src_id = item.start_vertex_id().cast()
dst_id = item.end_vertex_id().cast()
edge_name = item.edge_name()
props = item.properties()
# ensure start and end vertex exist in graph
if not src_id in g.node_ids:
g.add_node(src_id)
if not dst_id in g.node_ids:
g.add_node(dst_id)
g.add_edge(src_id, dst_id, label=edge_name, title=str(props))
elif isinstance(item, PathWrapper):
for node in item.nodes():
render_pd_item(g, node)
for edge in item.relationships():
render_pd_item(g, edge)
elif isinstance(item, list):
for it in item:
render_pd_item(g, it)
def create_pyvis_graph(result_df):
from pyvis.network import Network
g = Network(
notebook=True,
directed=True,
cdn_resources="in_line",
height="500px",
width="100%",
)
for _, row in result_df.iterrows():
for item in row:
render_pd_item(g, item)
g.repulsion(
node_distance=100,
central_gravity=0.2,
spring_length=200,
spring_strength=0.05,
damping=0.09,
)
return g
def query_nebulagraph(
query,
space_name=space_name,
address=st.secrets["graphd_host"],
port=9669,
user=st.secrets["graphd_user"],
password=st.secrets["graphd_password"],
):
from nebula3.Config import SessionPoolConfig
from nebula3.gclient.net.SessionPool import SessionPool
config = SessionPoolConfig()
session_pool = SessionPool(user, password, space_name, [(address, port)])
session_pool.init(config)
return session_pool.execute(query)
st.title("利用 LLM 构建、查询知识图谱")
(
tab_code_kg,
tab_notebook,
tab_graph_view,
tab_cypher,
tab_nl2cypher,
tab_code_nl2cypher,
) = st.tabs(
[
"代码:构建知识图谱",
"完整 Notebook",
"图谱可视化",
"Cypher 查询",
"自然语言查询",
"代码:NL2Cypher",
]
)
with tab_code_kg:
st.write("> 利用 LLM，几行代码构建知识图谱")
st.code(body=CODE_BUILD_KG, language="python")
with tab_notebook:
st.write("> 完整 Demo 过程 Notebook")
st.write(
"""
这个 Notebook 展示了如何利用 LLM 从不同类型的信息源（以维基百科为例）中抽取知识三元组，并存储到图数据库 NebulaGraph 中。
本 Demo 中，我们先抽取了维基百科中关于《银河护卫队3》的信息，然后利用 LLM 生成的知识三元组，构建了一个图谱。
然后利用 Cypher 查询图谱，最后利用 LlamaIndex 和 Langchain 中的 NL2NebulaCypher，实现了自然语言查询图谱的功能。
您可以点击其他标签亲自试玩图谱的可视化、Cypher 查询、自然语言查询（NL2NebulaCypher）等功能。
"""
)
# link to download notebook
st.markdown(
"""
这里可以[下载](https://www.siwei.io/demo-dumps/kg-llm/KG_Building.ipynb) 完整的 Notebook。
"""
)
components.iframe(
src="https://www.siwei.io/demo-dumps/kg-llm/KG_Building.html",
height=2000,
width=800,
scrolling=True,
)
with tab_graph_view:
st.write(
"> 图谱的可视化部分采样，知识来源[银河护卫队3](https://en.wikipedia.org/wiki/Guardians_of_the_Galaxy_Vol._3)"
)
components.iframe(
src="https://www.siwei.io/demo-dumps/kg-llm/nebulagraph_draw_sample.html",
height=500,
scrolling=True,
)
with tab_cypher:
st.write("> Cypher 查询图库")
query_string = st.text_input(
label="输入查询语句", value="MATCH ()-[e]->() RETURN e LIMIT 25"
)
if st.button("> 执行"):
# run query
result = query_nebulagraph(query_string)
# convert to pandas dataframe
result_df = result_to_df(result)
# display pd dataframe
st.dataframe(result_df)
# create pyvis graph
g = create_pyvis_graph(result_df)
# render with random file name
import random
graph_html = g.generate_html(f"graph_{random.randint(0, 1000)}.html")
components.html(graph_html, height=500, scrolling=True)
with tab_nl2cypher:
st.write("> 使用自然语言查询图库")
nl_query_string = st.text_input(
label="输入自然语言问题", value="Tell me about Peter Quill?"
)
if st.button("生成 Cypher 查询语句，并执行"):
response = nl2kg_query_engine.query(nl_query_string)
graph_query = list(response.metadata.values())[0]["graph_store_query"]
graph_query = graph_query.replace("WHERE", "\n WHERE").replace(
"RETURN", "\nRETURN"
)
answer = str(response)
st.write(f"*答案*: {answer}")
st.markdown(
f"""
## 利用 LLM 生成的图查询语句
```cypher
{graph_query}
```
"""
)
st.write("## 结果可视化")
render_query = cypher_to_all_paths(graph_query)
result = query_nebulagraph(render_query)
result_df = result_to_df(result)
# create pyvis graph
g = create_pyvis_graph(result_df)
# render with random file name
graph_html = g.generate_html(f"graph_{random.randint(0, 1000)}.html")
components.html(graph_html, height=500, scrolling=True)
with tab_code_nl2cypher:
st.write("利用 Langchain 或者 Llama Index，我们可以只用几行代码就实现自然语言查询图谱（NL2NebulaCypher）")
tab_langchain, tab_llamaindex = st.tabs(["Langchain", "Llama Index"])
with tab_langchain:
st.code(body=CODE_NL2CYPHER_LANGCHAIN, language="python")
with tab_llamaindex:
st.code(body=CODE_NL2CYPHER_LLAMAINDEX, language="python")
st.markdown(
"""
## 参考文档
- [Langchain: NebulaGraphQAChain](https://python.langchain.com/docs/modules/chains/additional/graph_nebula_qa)
- [Llama Index: KnowledgeGraphQueryEngine](https://gpt-index.readthedocs.io/en/latest/examples/query_engine/knowledge_graph_query_engine.html)
"""
)
| [
"langchain.embeddings.OpenAIEmbeddings"
] | [((12, 52), 'sys.stdout.reconfigure', 'sys.stdout.reconfigure', ([], {'encoding': '"""utf-8"""'}), "(encoding='utf-8')\n", (34, 52), False, 'import sys\n'), ((53, 92), 'sys.stdin.reconfigure', 'sys.stdin.reconfigure', ([], {'encoding': '"""utf-8"""'}), "(encoding='utf-8')\n", (74, 92), False, 'import sys\n'), ((2988, 3046), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (3007, 3046), False, 'import logging\n'), ((3402, 3493), 'llama_index.llms.AzureOpenAI', 'AzureOpenAI', ([], {'engine': "st.secrets['DEPLOYMENT_NAME']", 'temperature': '(0)', 'model': '"""gpt-35-turbo"""'}), "(engine=st.secrets['DEPLOYMENT_NAME'], temperature=0, model=\n 'gpt-35-turbo')\n", (3413, 3493), False, 'from llama_index.llms import AzureOpenAI\n'), ((3520, 3541), 'llama_index.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (3532, 3541), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, KnowledgeGraphIndex, LLMPredictor, ServiceContext\n'), ((4009, 4098), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'embed_model': 'embedding_llm'}), '(llm_predictor=llm_predictor, embed_model=\n embedding_llm)\n', (4037, 4098), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, KnowledgeGraphIndex, LLMPredictor, ServiceContext\n'), ((4552, 4660), 'llama_index.graph_stores.NebulaGraphStore', 'NebulaGraphStore', ([], {'space_name': 'space_name', 'edge_types': 'edge_types', 'rel_prop_names': 'rel_prop_names', 'tags': 'tags'}), '(space_name=space_name, edge_types=edge_types,\n rel_prop_names=rel_prop_names, tags=tags)\n', (4568, 4660), False, 'from llama_index.graph_stores import NebulaGraphStore\n'), ((4694, 4747), 'llama_index.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'graph_store': 'graph_store'}), '(graph_store=graph_store)\n', (4722, 4747), False, 'from llama_index.storage.storage_context import StorageContext\n'), ((4952, 5071), 'llama_index.query_engine.KnowledgeGraphQueryEngine', 'KnowledgeGraphQueryEngine', ([], {'storage_context': 'storage_context', 'service_context': 'service_context', 'llm': 'llm', 'verbose': '(True)'}), '(storage_context=storage_context, service_context=\n service_context, llm=llm, verbose=True)\n', (4977, 5071), False, 'from llama_index.query_engine import KnowledgeGraphQueryEngine\n'), ((8530, 8558), 'streamlit.title', 'st.title', (['"""利用 LLM 构建、查询知识图谱"""'], {}), "('利用 LLM 构建、查询知识图谱')\n", (8538, 8558), True, 'import streamlit as st\n'), ((8680, 8769), 'streamlit.tabs', 'st.tabs', (["['代码:构建知识图谱', '完整 Notebook', '图谱可视化', 'Cypher 查询', '自然语言查询', '代码:NL2Cypher']"], {}), "(['代码:构建知识图谱', '完整 Notebook', '图谱可视化', 'Cypher 查询', '自然语言查询',\n '代码:NL2Cypher'])\n", (8687, 8769), True, 'import streamlit as st\n'), ((3671, 3920), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'model': '"""text-embedding-ada-002"""', 'deployment': "st.secrets['EMBEDDING_DEPLOYMENT_NAME']", 'openai_api_key': 'openai.api_key', 'openai_api_base': 'openai.api_base', 'openai_api_type': 'openai.api_type', 'openai_api_version': 'openai.api_version'}), "(model='text-embedding-ada-002', deployment=st.secrets[\n 'EMBEDDING_DEPLOYMENT_NAME'], openai_api_key=openai.api_key,\n openai_api_base=openai.api_base, openai_api_type=openai.api_type,\n openai_api_version=openai.api_version)\n", (3687, 3920), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((5176, 5232), 're.findall', 're.findall', (['"""(MATCH .+?(?=MATCH|$))"""', 'query', '(re.I | re.S)'], {}), "('(MATCH .+?(?=MATCH|$))', query, re.I | re.S)\n", (5186, 5232), False, 'import re\n'), ((6408, 6423), 'pandas.DataFrame', 'pd.DataFrame', (['d'], {}), '(d)\n', (6420, 6423), True, 'import pandas as pd\n'), ((7626, 7723), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'directed': '(True)', 'cdn_resources': '"""in_line"""', 'height': '"""500px"""', 'width': '"""100%"""'}), "(notebook=True, directed=True, cdn_resources='in_line', height=\n '500px', width='100%')\n", (7633, 7723), False, 'from pyvis.network import Network\n'), ((8361, 8380), 'nebula3.Config.SessionPoolConfig', 'SessionPoolConfig', ([], {}), '()\n', (8378, 8380), False, 'from nebula3.Config import SessionPoolConfig\n'), ((8400, 8458), 'nebula3.gclient.net.SessionPool.SessionPool', 'SessionPool', (['user', 'password', 'space_name', '[(address, port)]'], {}), '(user, password, space_name, [(address, port)])\n', (8411, 8458), False, 'from nebula3.gclient.net.SessionPool import SessionPool\n'), ((8850, 8881), 'streamlit.write', 'st.write', (['"""> 利用 LLM，几行代码构建知识图谱"""'], {}), "('> 利用 LLM，几行代码构建知识图谱')\n", (8858, 8881), True, 'import streamlit as st\n'), ((8886, 8932), 'streamlit.code', 'st.code', ([], {'body': 'CODE_BUILD_KG', 'language': '"""python"""'}), "(body=CODE_BUILD_KG, language='python')\n", (8893, 8932), True, 'import streamlit as st\n'), ((8957, 8990), 'streamlit.write', 'st.write', (['"""> 完整 Demo 过程 Notebook"""'], {}), "('> 完整 Demo 过程 Notebook')\n", (8965, 8990), True, 'import streamlit as st\n'), ((8995, 9313), 'streamlit.write', 'st.write', (['"""\n\n这个 Notebook 展示了如何利用 LLM 从不同类型的信息源（以维基百科为例）中抽取知识三元组，并存储到图数据库 NebulaGraph 中。\n\n本 Demo 中，我们先抽取了维基百科中关于《银河护卫队3》的信息，然后利用 LLM 生成的知识三元组，构建了一个图谱。\n然后利用 Cypher 查询图谱，最后利用 LlamaIndex 和 Langchain 中的 NL2NebulaCypher，实现了自然语言查询图谱的功能。\n\n您可以点击其他标签亲自试玩图谱的可视化、Cypher 查询、自然语言查询（NL2NebulaCypher）等功能。\n\n """'], {}), '(\n """\n\n这个 Notebook 展示了如何利用 LLM 从不同类型的信息源（以维基百科为例）中抽取知识三元组，并存储到图数据库 NebulaGraph 中。\n\n本 Demo 中，我们先抽取了维基百科中关于《银河护卫队3》的信息，然后利用 LLM 生成的知识三元组，构建了一个图谱。\n然后利用 Cypher 查询图谱，最后利用 LlamaIndex 和 Langchain 中的 NL2NebulaCypher，实现了自然语言查询图谱的功能。\n\n您可以点击其他标签亲自试玩图谱的可视化、Cypher 查询、自然语言查询（NL2NebulaCypher）等功能。\n\n """\n )\n', (9003, 9313), True, 'import streamlit as st\n'), ((9354, 9465), 'streamlit.markdown', 'st.markdown', (['"""\n这里可以[下载](https://www.siwei.io/demo-dumps/kg-llm/KG_Building.ipynb) 完整的 Notebook。\n"""'], {}), '(\n """\n这里可以[下载](https://www.siwei.io/demo-dumps/kg-llm/KG_Building.ipynb) 完整的 Notebook。\n"""\n )\n', (9365, 9465), True, 'import streamlit as st\n'), ((9475, 9604), 'streamlit.components.v1.iframe', 'components.iframe', ([], {'src': '"""https://www.siwei.io/demo-dumps/kg-llm/KG_Building.html"""', 'height': '(2000)', 'width': '(800)', 'scrolling': '(True)'}), "(src=\n 'https://www.siwei.io/demo-dumps/kg-llm/KG_Building.html', height=2000,\n width=800, scrolling=True)\n", (9492, 9604), True, 'import streamlit.components.v1 as components\n'), ((9661, 9770), 'streamlit.write', 'st.write', (['"""> 图谱的可视化部分采样，知识来源[银河护卫队3](https://en.wikipedia.org/wiki/Guardians_of_the_Galaxy_Vol._3)"""'], {}), "(\n '> 图谱的可视化部分采样，知识来源[银河护卫队3](https://en.wikipedia.org/wiki/Guardians_of_the_Galaxy_Vol._3)'\n )\n", (9669, 9770), True, 'import streamlit as st\n'), ((9780, 9909), 'streamlit.components.v1.iframe', 'components.iframe', ([], {'src': '"""https://www.siwei.io/demo-dumps/kg-llm/nebulagraph_draw_sample.html"""', 'height': '(500)', 'scrolling': '(True)'}), "(src=\n 'https://www.siwei.io/demo-dumps/kg-llm/nebulagraph_draw_sample.html',\n height=500, scrolling=True)\n", (9797, 9909), True, 'import streamlit.components.v1 as components\n'), ((9954, 9979), 'streamlit.write', 'st.write', (['"""> Cypher 查询图库"""'], {}), "('> Cypher 查询图库')\n", (9962, 9979), True, 'import streamlit as st\n'), ((9999, 10072), 'streamlit.text_input', 'st.text_input', ([], {'label': '"""输入查询语句"""', 'value': '"""MATCH ()-[e]->() RETURN e LIMIT 25"""'}), "(label='输入查询语句', value='MATCH ()-[e]->() RETURN e LIMIT 25')\n", (10012, 10072), True, 'import streamlit as st\n'), ((10094, 10111), 'streamlit.button', 'st.button', (['"""> 执行"""'], {}), "('> 执行')\n", (10103, 10111), True, 'import streamlit as st\n'), ((10629, 10653), 'streamlit.write', 'st.write', (['"""> 使用自然语言查询图库"""'], {}), "('> 使用自然语言查询图库')\n", (10637, 10653), True, 'import streamlit as st\n'), ((10676, 10743), 'streamlit.text_input', 'st.text_input', ([], {'label': '"""输入自然语言问题"""', 'value': '"""Tell me about Peter Quill?"""'}), "(label='输入自然语言问题', value='Tell me about Peter Quill?')\n", (10689, 10743), True, 'import streamlit as st\n'), ((10765, 10796), 'streamlit.button', 'st.button', (['"""生成 Cypher 查询语句，并执行"""'], {}), "('生成 Cypher 查询语句，并执行')\n", (10774, 10796), True, 'import streamlit as st\n'), ((11681, 11759), 'streamlit.write', 'st.write', (['"""利用 Langchain 或者 Llama Index，我们可以只用几行代码就实现自然语言查询图谱（NL2NebulaCypher）"""'], {}), "('利用 Langchain 或者 Llama Index，我们可以只用几行代码就实现自然语言查询图谱（NL2NebulaCypher）')\n", (11689, 11759), True, 'import streamlit as st\n'), ((11797, 11834), 'streamlit.tabs', 'st.tabs', (["['Langchain', 'Llama Index']"], {}), "(['Langchain', 'Llama Index'])\n", (11804, 11834), True, 'import streamlit as st\n'), ((12022, 12332), 'streamlit.markdown', 'st.markdown', (['"""\n\n## 参考文档\n \n- [Langchain: NebulaGraphQAChain](https://python.langchain.com/docs/modules/chains/additional/graph_nebula_qa)\n- [Llama Index: KnowledgeGraphQueryEngine](https://gpt-index.readthedocs.io/en/latest/examples/query_engine/knowledge_graph_query_engine.html)\n"""'], {}), '(\n """\n\n## 参考文档\n \n- [Langchain: NebulaGraphQAChain](https://python.langchain.com/docs/modules/chains/additional/graph_nebula_qa)\n- [Llama Index: KnowledgeGraphQueryEngine](https://gpt-index.readthedocs.io/en/latest/examples/query_engine/knowledge_graph_query_engine.html)\n"""\n )\n', (12033, 12332), True, 'import streamlit as st\n'), ((10302, 10325), 'streamlit.dataframe', 'st.dataframe', (['result_df'], {}), '(result_df)\n', (10314, 10325), True, 'import streamlit as st\n'), ((10548, 10603), 'streamlit.components.v1.html', 'components.html', (['graph_html'], {'height': '(500)', 'scrolling': '(True)'}), '(graph_html, height=500, scrolling=True)\n', (10563, 10603), True, 'import streamlit.components.v1 as components\n'), ((11093, 11120), 'streamlit.write', 'st.write', (['f"""*答案*: {answer}"""'], {}), "(f'*答案*: {answer}')\n", (11101, 11120), True, 'import streamlit as st\n'), ((11129, 11197), 'streamlit.markdown', 'st.markdown', (['f"""\n## 利用 LLM 生成的图查询语句\n```cypher\n{graph_query}\n```\n"""'], {}), '(f"""\n## 利用 LLM 生成的图查询语句\n```cypher\n{graph_query}\n```\n""")\n', (11140, 11197), True, 'import streamlit as st\n'), ((11228, 11248), 'streamlit.write', 'st.write', (['"""## 结果可视化"""'], {}), "('## 结果可视化')\n", (11236, 11248), True, 'import streamlit as st\n'), ((11594, 11649), 'streamlit.components.v1.html', 'components.html', (['graph_html'], {'height': '(500)', 'scrolling': '(True)'}), '(graph_html, height=500, scrolling=True)\n', (11609, 11649), True, 'import streamlit.components.v1 as components\n'), ((11867, 11924), 'streamlit.code', 'st.code', ([], {'body': 'CODE_NL2CYPHER_LANGCHAIN', 'language': '"""python"""'}), "(body=CODE_NL2CYPHER_LANGCHAIN, language='python')\n", (11874, 11924), True, 'import streamlit as st\n'), ((11958, 12016), 'streamlit.code', 'st.code', ([], {'body': 'CODE_NL2CYPHER_LLAMAINDEX', 'language': '"""python"""'}), "(body=CODE_NL2CYPHER_LLAMAINDEX, language='python')\n", (11965, 12016), True, 'import streamlit as st\n'), ((5252, 5281), 're.search', 're.search', (['"""RETURN .+"""', 'query'], {}), "('RETURN .+', query)\n", (5261, 5281), False, 'import re\n'), ((10507, 10530), 'random.randint', 'random.randint', (['(0)', '(1000)'], {}), '(0, 1000)\n', (10521, 10530), False, 'import random\n'), ((11553, 11576), 'random.randint', 'random.randint', (['(0)', '(1000)'], {}), '(0, 1000)\n', (11567, 11576), False, 'import random\n')] |
from langchain.agents import AgentExecutor, LLMSingleActionAgent, AgentOutputParser
from langchain.tools import Tool, StructuredTool
from langchain.prompts import StringPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.llms import VertexAI
from typing import List, Union, Tuple, Any, Dict
from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult
import re
import langchain
import os
import json
import requests
from utils import *
from tools import take_environment_action_wrapper
from debate import view_debate_wrapper
from langchain.callbacks import FileCallbackHandler
from langchain.callbacks.base import BaseCallbackHandler
import logging
from langchain.agents.agent_iterator import AgentExecutorIterator
from datetime import datetime
from pydantic import BaseModel, Field
# Example usage:
log_levels = {
'none': logging.CRITICAL,
'all': logging.INFO,
}
def get_info_logger():
timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
os.makedirs(f'./results/{timestamp}', exist_ok=True)
info_filename = f'./results/{timestamp}/info_{timestamp}.log'
debug_filename = f'./results/{timestamp}/debug_{timestamp}.log'
logging.basicConfig(level=logging.NOTSET, handlers=[logging.NullHandler()])
info_logger = logging.getLogger('info_logger')
# Create an INFO file handler
file_handler_info = logging.FileHandler(info_filename)
file_handler_info.setLevel(logging.INFO)
# Create formatters and set them for the file handlers
formatter_info = logging.Formatter('%(message)s')
file_handler_info.setFormatter(formatter_info)
# Add the file handlers to the logger
info_logger.addHandler(file_handler_info)
info_logger.info(timestamp)
return info_logger, timestamp, info_filename, debug_filename
class Context(BaseModel):
generation_observation_history: List[str] = []
log_count: int = 0
action_count: int = 0
debate_count: int = 0
do_debate: bool = False
system_hint_mod: int = 2
max_votes: int = 1
vote_count: int = 0
votes: List[Tuple[str, str, str]] = []
info_logger: Any = None
token_count: int = 0
class CustomPromptTemplate(StringPromptTemplate):
# The template to use
template: str
# The list of tools available
tools: List[Tool]
# Context for information
context: Context
def format(self, **kwargs) -> str:
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = [(a, o) for a, o in kwargs.pop("intermediate_steps") if o != EMPTY_RESPONSE]
# if recently finished voting, then vote count is 0
done_voting = self.context.vote_count == 0
history_lines = []
last_action = None
last_observation = None
# create history to prompt agent
for action, observation in intermediate_steps:
history_lines.append(action.log.strip())
history_lines.append(f"{OBSERVATION_PREFIX} {observation.strip()}")
last_action = action
last_observation = observation.strip()
history = '\n'.join(history_lines)
# append observation to list for debaters to use. Only append the environment observation, not debate observation
# only do this if done voting, else we'll append it 'self.context.max_votes' many times
if done_voting and last_action and last_action.tool == TAKE_ENVIRONMENT_ACTION:
self.context.generation_observation_history.append(f'{OBSERVATION_PREFIX} {last_observation}')
system_hint = None
valid_action_hint = None
# append system hint for after taking action
if (self.context.do_debate and
last_action and
last_action.tool == TAKE_ENVIRONMENT_ACTION and
self.context.action_count % self.context.system_hint_mod == 0):
system_hint = HINT_AFTER_ACTION
history += '\n' + system_hint
# append system hint for after viewing debate
if (self.context.do_debate and
last_action and
last_action.tool == VIEW_DEBATE):
system_hint = HINT_AFTER_DEBATE
history += '\n' + system_hint
# append system hint that reminds
valid_action_hint = VALID_ACTIONS
history += '\n' + valid_action_hint
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = history
# Create a tools variable from the list of tools provided
tool_strings = []
for tool in self.tools:
s = f"{tool.name}: {tool.description}"
params = [f'{param} - {info["description"]}' for param, info in tool.args.items()]
s += ' Argument: ' + ' '.join(params)
tool_strings.append(s)
kwargs["tools"] = "\n".join(tool_strings)
# Create a list of tool names for the tools provided
kwargs["tool_names"] = " or ".join([tool.name for tool in self.tools])
agent_prompt = self.template.format(**kwargs)
# log some stuff
if self.context.log_count == 0:
self.context.info_logger.info(f"Step {self.context.log_count} ===")
self.context.info_logger.info(agent_prompt)
self.context.log_count += 1
elif done_voting and self.context.log_count > 0 and last_action:
self.context.info_logger.info(f"\nStep {self.context.log_count} ===")
self.context.info_logger.info(f'Generation ---\n{last_action.log.strip()}')
self.context.info_logger.info(f'Observation ---\n{last_observation}')
if system_hint:
self.context.info_logger.info(f'<only seen once by agent> {system_hint}')
if valid_action_hint:
self.context.info_logger.info(f'<only seen once by agent> {valid_action_hint}')
self.context.log_count += 1
self.context.token_count += tokens(agent_prompt)
return agent_prompt
class CustomOutputParser(AgentOutputParser):
# Context for information
context: Context
def parse(self, llm_output: str) -> Union[AgentFinish, AgentAction, list[AgentAction]]:
self.context.token_count += tokens(llm_output)
default_agent_finish = AgentFinish(
return_values={'output': "Task finished."},
log=llm_output
)
# first, extract the answer and append it to the votes
# this includes final answers, and even treats errors as an answer
try:
pattern = r'Tool: (.*)\nTool Input: (.*)'
match = re.search(pattern, llm_output, re.DOTALL)
# if the agent wants to do a final answer
if "final answer" in llm_output.lower() or "final_answer" in llm_output.lower():
self.context.vote_count += 1
self.context.votes.append(('final answer', 'final answer', llm_output))
# else, look for a tool
elif match:
# extract the tool information
tool_name: str = match.group(1)
tool_input: str = match.group(2)
# increment the votes
self.context.vote_count += 1
self.context.votes.append((tool_name, tool_input, llm_output))
else:
raise ValueError(f"Could not find 'Tool:' or 'Tool Input:' : `{llm_output}`")
except Exception as e:
self.context.vote_count += 1
self.context.votes.append(('error', 'error', llm_output + f'\n ERROR === \n{e}'))
# if not done voting, then don't take an action
# the take_environment_action tool handles this
if self.context.vote_count < self.context.max_votes:
return AgentAction(tool=TAKE_ENVIRONMENT_ACTION, tool_input='empty param', log='empty tool')
# if done voting, return majority vote and reset voting
else:
# log the votes
self.context.info_logger.info("Casting votes... ===")
for i, vote in enumerate(self.context.votes):
self.context.info_logger.info(f"Vote {i} ---\n{vote}")
# get the majority vote
majority_tool_name, majority_tool_input, random_llm_output = get_majority_vote(self.context.votes)
# reset the voting
self.context.vote_count = 0
self.context.votes = []
# if the majority vote was a final answer or an error:
if majority_tool_name == 'final answer' or majority_tool_name == 'error':
return default_agent_finish
# if the majority vote is a debate tool, then call that tool
elif majority_tool_name == VIEW_DEBATE:
self.context.debate_count += 1
return AgentAction(tool=majority_tool_name, tool_input=majority_tool_input,
log=random_llm_output)
# if the majority vote is a environment action tool, then call that tool and log stuff
elif majority_tool_name == TAKE_ENVIRONMENT_ACTION:
# increment action count and log it
self.context.action_count += 1
self.context.info_logger.info(f"\nAction Count {self.context.action_count} +++")
# add action to the history for debaters
self.context.generation_observation_history.append('Action: ' + majority_tool_input)
return AgentAction(tool=majority_tool_name, tool_input=majority_tool_input,
log=random_llm_output)
else:
print('This happened!')
return default_agent_finish
# raise ValueError(f"An error occurred that should never occur: `{majority_tool_name}`")
def run_experiment(exp):
description = exp['description']
langchain.debug = exp['langchain.debug']
langchain_verbose = exp['langchain_verbose']
log_level = log_levels['all']
langchain_logging = False
do_debate = exp['do_debate']
MAX_STEPS = exp['MAX_STEPS']
MAX_VOTES = exp['MAX_VOTES']
temperature = 0 if MAX_VOTES == 1 else 0.7
model = exp['agent_model']
system_hint_mod = 1000000
debate_params = dict()
if 'debate_params' in exp:
debate_params = exp['debate_params']
system_hint_mod = debate_params.pop('system_hint_mod')
info_logger, timestamp, info_filename, debug_filename = get_info_logger()
info_logger.setLevel(log_level)
if langchain_logging:
handler = FileCallbackHandler(debug_filename)
results = []
num_tasks = exp['num_tasks']
start_task = exp['start_task']
reset_tasks()
for _ in range(1, start_task):
get_next_task(MAX_STEPS)
filename = None
for _ in range(num_tasks):
# set up the context to pass around
context = Context()
# file that debaters will use to see agent history
context.generation_observation_history = []
# information to know when to log the full action count
context.log_count = 0
# information to know when to provide the system hint
context.action_count = 0
# count the number of debates
context.debate_count = 0
# only display the system hints if do_debate is true
context.do_debate = do_debate
# show the hints after every x many actions.
context.system_hint_mod = system_hint_mod
# do majority voting
context.max_votes = MAX_VOTES
# count total votes so far
context.vote_count = 0
# store the votes
context.votes = []
# expose the logger
context.info_logger = info_logger
# count the tokens
context.token_count = 0
# set up the available tools
tools = [
take_environment_action_wrapper(context)
]
if do_debate:
tools.append(view_debate_wrapper(context, **debate_params, logger=info_logger))
# load the examples and task from ALFWorld
examples, task, task_index = get_next_task(MAX_STEPS,
do_debate=False) # not inserting debates even if in debate mode
print(f'Task index: {task_index}')
examples_str = '\n\n'.join([f'Example {i + 1}:\n{ex}' for i, ex in enumerate(examples)])
examples_str = examples_str.replace('{', '{{').replace('}', '}}')
info_logger.info(f'\n\n\n\n\n\n\n\n\nTask index: {task_index}')
# load the prompt that tells how to format the actions
formatting = read_text_file("./prompts/action_formatting.txt")
# load the examples of failures
failure_examples_str = read_text_file("./prompts/failure_examples.txt")
# set up strings to insert if do_debate == True
debate_examples_str = ''
debate_msg_1 = ''
debate_msg_2 = ''
if do_debate:
debate_msg_2 = f'\n- IMPORTANT: Remember to use the "{VIEW_DEBATE}" tool to get a better understanding about your problem and proposed action BEFORE using "{TAKE_ENVIRONMENT_ACTION}".'
debate_examples_str = '\n\n' + read_text_file("./prompts/debate_examples.txt")
template = read_text_file("prompts/prompt_template.txt")
# fill out the template
template = template.format(
formatting=formatting,
success_examples=examples_str,
failure_examples=failure_examples_str,
debate_examples=debate_examples_str,
debate_msg_1=debate_msg_1,
debate_msg_2=debate_msg_2,
)
# create the prompt
prompt = CustomPromptTemplate(
template=template,
tools=tools,
# This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables=["input", "intermediate_steps"],
context=context,
)
llm = VertexAI(
model_name=model,
temperature=temperature,
max_output_tokens=256,
)
callbacks = []
if langchain_logging:
callbacks.append(handler)
llm_chain = LLMChain(
llm=llm,
prompt=prompt,
callbacks=callbacks
)
agent = LLMSingleActionAgent(
llm_chain=llm_chain,
output_parser=CustomOutputParser(context=context),
stop=[f"\n{OBSERVATION_PREFIX}"],
allowed_tools=[tool.name for tool in tools],
)
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
verbose=langchain_verbose,
max_iterations=2 * MAX_STEPS * context.max_votes + 1)
agent_iterator = agent_executor.iter(inputs=task)
# append to history for the debaters
context.generation_observation_history.append('Task: ' + task)
result_dict = dict()
result_dict['task'] = task
result_dict['task_index'] = task_index
result_dict['success'] = False
total_steps = 0
for step_num, step in enumerate(agent_iterator):
# intermediate_step is a (action, observation) pair
prev_ob = step.get('intermediate_step')
if prev_ob:
a, o = prev_ob[-1]
if not o:
break
if FAIL_OBSERVATION in o:
total_steps += 1
break
elif SUCCESS_OBSERVATION in o:
total_steps += 1
result_dict['success'] = True
break
elif EMPTY_RESPONSE not in o:
total_steps += 1
else:
# print("HERE")
# print(step)
break
result_dict['total_steps'] = total_steps
# the number of times take_environment_action was called
result_dict['total_actions'] = context.action_count
result_dict['total_debates'] = context.debate_count
result_dict['token_count'] = context.token_count
results.append(result_dict)
# save the results every time, so we don't lose anything
results_dir = f'./results/{timestamp}/'
filename = f"{results_dir}results_{timestamp}.json"
if not os.path.exists(results_dir):
os.makedirs(results_dir)
# put back system hint mod because we popped it
if 'debate_params' in exp:
exp['debate_params']['system_hint_mod'] = system_hint_mod
extended_results = {
'description': description,
'params': exp,
'timestamp': timestamp,
'results': results
}
write_json_file(filename, extended_results)
# pop it again
if 'debate_params' in exp:
exp['debate_params'].pop('system_hint_mod')
return timestamp, filename
| [
"langchain.chains.LLMChain",
"langchain.llms.VertexAI",
"langchain.agents.AgentExecutor.from_agent_and_tools",
"langchain.schema.AgentFinish",
"langchain.schema.AgentAction",
"langchain.callbacks.FileCallbackHandler"
] | [((1046, 1098), 'os.makedirs', 'os.makedirs', (['f"""./results/{timestamp}"""'], {'exist_ok': '(True)'}), "(f'./results/{timestamp}', exist_ok=True)\n", (1057, 1098), False, 'import os\n'), ((1332, 1364), 'logging.getLogger', 'logging.getLogger', (['"""info_logger"""'], {}), "('info_logger')\n", (1349, 1364), False, 'import logging\n'), ((1424, 1458), 'logging.FileHandler', 'logging.FileHandler', (['info_filename'], {}), '(info_filename)\n', (1443, 1458), False, 'import logging\n'), ((1585, 1617), 'logging.Formatter', 'logging.Formatter', (['"""%(message)s"""'], {}), "('%(message)s')\n", (1602, 1617), False, 'import logging\n'), ((6381, 6452), 'langchain.schema.AgentFinish', 'AgentFinish', ([], {'return_values': "{'output': 'Task finished.'}", 'log': 'llm_output'}), "(return_values={'output': 'Task finished.'}, log=llm_output)\n", (6392, 6452), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n'), ((10667, 10702), 'langchain.callbacks.FileCallbackHandler', 'FileCallbackHandler', (['debug_filename'], {}), '(debug_filename)\n', (10686, 10702), False, 'from langchain.callbacks import FileCallbackHandler\n'), ((14195, 14269), 'langchain.llms.VertexAI', 'VertexAI', ([], {'model_name': 'model', 'temperature': 'temperature', 'max_output_tokens': '(256)'}), '(model_name=model, temperature=temperature, max_output_tokens=256)\n', (14203, 14269), False, 'from langchain.llms import VertexAI\n'), ((14429, 14482), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt', 'callbacks': 'callbacks'}), '(llm=llm, prompt=prompt, callbacks=callbacks)\n', (14437, 14482), False, 'from langchain.chains import LLMChain\n'), ((14802, 14948), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'agent', 'tools': 'tools', 'verbose': 'langchain_verbose', 'max_iterations': '(2 * MAX_STEPS * context.max_votes + 1)'}), '(agent=agent, tools=tools, verbose=\n langchain_verbose, max_iterations=2 * MAX_STEPS * context.max_votes + 1)\n', (14836, 14948), False, 'from langchain.agents import AgentExecutor, LLMSingleActionAgent, AgentOutputParser\n'), ((997, 1011), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1009, 1011), False, 'from datetime import datetime\n'), ((6714, 6755), 're.search', 're.search', (['pattern', 'llm_output', 're.DOTALL'], {}), '(pattern, llm_output, re.DOTALL)\n', (6723, 6755), False, 'import re\n'), ((7875, 7965), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'TAKE_ENVIRONMENT_ACTION', 'tool_input': '"""empty param"""', 'log': '"""empty tool"""'}), "(tool=TAKE_ENVIRONMENT_ACTION, tool_input='empty param', log=\n 'empty tool')\n", (7886, 7965), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n'), ((11956, 11996), 'tools.take_environment_action_wrapper', 'take_environment_action_wrapper', (['context'], {}), '(context)\n', (11987, 11996), False, 'from tools import take_environment_action_wrapper\n'), ((16594, 16621), 'os.path.exists', 'os.path.exists', (['results_dir'], {}), '(results_dir)\n', (16608, 16621), False, 'import os\n'), ((16635, 16659), 'os.makedirs', 'os.makedirs', (['results_dir'], {}), '(results_dir)\n', (16646, 16659), False, 'import os\n'), ((1290, 1311), 'logging.NullHandler', 'logging.NullHandler', ([], {}), '()\n', (1309, 1311), False, 'import logging\n'), ((12054, 12119), 'debate.view_debate_wrapper', 'view_debate_wrapper', (['context'], {'logger': 'info_logger'}), '(context, **debate_params, logger=info_logger)\n', (12073, 12119), False, 'from debate import view_debate_wrapper\n'), ((8911, 9007), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'majority_tool_name', 'tool_input': 'majority_tool_input', 'log': 'random_llm_output'}), '(tool=majority_tool_name, tool_input=majority_tool_input, log=\n random_llm_output)\n', (8922, 9007), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n'), ((9578, 9674), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'majority_tool_name', 'tool_input': 'majority_tool_input', 'log': 'random_llm_output'}), '(tool=majority_tool_name, tool_input=majority_tool_input, log=\n random_llm_output)\n', (9589, 9674), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n')] |
import langchain
from dotenv import load_dotenv
from langchain.chains import FlareChain
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.llms import OpenAI
from langchain.vectorstores import FAISS
langchain.verbose = True
load_dotenv()
# FAISSで保存されたベクトルを読み込む
embeddings = OpenAIEmbeddings()
db = FAISS.load_local("./tmp/faiss", embeddings)
retriever = db.as_retriever()
# FLAREの準備
chat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
flare = FlareChain.from_llm(
llm=chat,
retriever=retriever,
min_prob=0.2,
)
# 回答の生成には、logprobsが使えるCompletions APIを使う
flare.response_chain.llm = OpenAI(
model="gpt-3.5-turbo-instruct",
temperature=0,
model_kwargs={"logprobs": 1},
)
query = "LangChainとは"
result = flare.run(query)
print(result)
| [
"langchain.chat_models.ChatOpenAI",
"langchain.llms.OpenAI",
"langchain.chains.FlareChain.from_llm",
"langchain.embeddings.OpenAIEmbeddings",
"langchain.vectorstores.FAISS.load_local"
] | [((285, 298), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (296, 298), False, 'from dotenv import load_dotenv\n'), ((336, 354), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (352, 354), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((360, 403), 'langchain.vectorstores.FAISS.load_local', 'FAISS.load_local', (['"""./tmp/faiss"""', 'embeddings'], {}), "('./tmp/faiss', embeddings)\n", (376, 403), False, 'from langchain.vectorstores import FAISS\n'), ((453, 506), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0)'}), "(model_name='gpt-3.5-turbo', temperature=0)\n", (463, 506), False, 'from langchain.chat_models import ChatOpenAI\n'), ((515, 579), 'langchain.chains.FlareChain.from_llm', 'FlareChain.from_llm', ([], {'llm': 'chat', 'retriever': 'retriever', 'min_prob': '(0.2)'}), '(llm=chat, retriever=retriever, min_prob=0.2)\n', (534, 579), False, 'from langchain.chains import FlareChain\n'), ((663, 751), 'langchain.llms.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo-instruct"""', 'temperature': '(0)', 'model_kwargs': "{'logprobs': 1}"}), "(model='gpt-3.5-turbo-instruct', temperature=0, model_kwargs={\n 'logprobs': 1})\n", (669, 751), False, 'from langchain.llms import OpenAI\n')] |
import os
from dotenv import load_dotenv
import streamlit as st
from langchain.chains import LLMChain
from langchain import PromptTemplate
from genai.credentials import Credentials
from genai.extensions.langchain import LangChainInterface
from genai.schemas import GenerateParams
load_dotenv()
api_key = os.getenv("GENAI_KEY", None)
api_endpoint = os.getenv("GENAI_API", None)
creds = Credentials(api_key,api_endpoint)
params = GenerateParams(
decoding_method="sample",
max_new_tokens=200,
min_new_tokens=1,
stream=False,
temperature=0.7,
top_k=50,
top_p=1
).dict()
with st.sidebar:
st.title("Translation Assistant")
st.title("Translation Assistant")
text_input = st.text_area('Enter text')
# Create a selectbox for the user to select the target language
target_language = st.selectbox('Select language', [ 'English', 'Spanish', 'French', 'German','Chinese','Korean','Japanese','Hindi'])
# Create a button that the user can click to initiate the translation process
translate_button = st.button('Translate')
# Create a placeholder where the translated text will be displayed
translated_text = st.empty()
# Handle the translation process when the user clicks the translate button
if translate_button:
translated_text.text('Translating...')
llm = LangChainInterface(model="bigscience/mt0-xxl",credentials=creds, params=params)
prompt = PromptTemplate(template=f"Translate '{text_input}' to {target_language}",
input_variables=[])
chain = LLMChain(llm=llm,prompt=prompt)
response_text = chain.predict()
translated_text.text(response_text)
| [
"langchain.chains.LLMChain",
"langchain.PromptTemplate"
] | [((283, 296), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (294, 296), False, 'from dotenv import load_dotenv\n'), ((307, 335), 'os.getenv', 'os.getenv', (['"""GENAI_KEY"""', 'None'], {}), "('GENAI_KEY', None)\n", (316, 335), False, 'import os\n'), ((351, 379), 'os.getenv', 'os.getenv', (['"""GENAI_API"""', 'None'], {}), "('GENAI_API', None)\n", (360, 379), False, 'import os\n'), ((389, 423), 'genai.credentials.Credentials', 'Credentials', (['api_key', 'api_endpoint'], {}), '(api_key, api_endpoint)\n', (400, 423), False, 'from genai.credentials import Credentials\n'), ((656, 689), 'streamlit.title', 'st.title', (['"""Translation Assistant"""'], {}), "('Translation Assistant')\n", (664, 689), True, 'import streamlit as st\n'), ((704, 730), 'streamlit.text_area', 'st.text_area', (['"""Enter text"""'], {}), "('Enter text')\n", (716, 730), True, 'import streamlit as st\n'), ((818, 939), 'streamlit.selectbox', 'st.selectbox', (['"""Select language"""', "['English', 'Spanish', 'French', 'German', 'Chinese', 'Korean', 'Japanese',\n 'Hindi']"], {}), "('Select language', ['English', 'Spanish', 'French', 'German',\n 'Chinese', 'Korean', 'Japanese', 'Hindi'])\n", (830, 939), True, 'import streamlit as st\n'), ((1031, 1053), 'streamlit.button', 'st.button', (['"""Translate"""'], {}), "('Translate')\n", (1040, 1053), True, 'import streamlit as st\n'), ((1140, 1150), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (1148, 1150), True, 'import streamlit as st\n'), ((621, 654), 'streamlit.title', 'st.title', (['"""Translation Assistant"""'], {}), "('Translation Assistant')\n", (629, 654), True, 'import streamlit as st\n'), ((1301, 1386), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': '"""bigscience/mt0-xxl"""', 'credentials': 'creds', 'params': 'params'}), "(model='bigscience/mt0-xxl', credentials=creds, params=params\n )\n", (1319, 1386), False, 'from genai.extensions.langchain import LangChainInterface\n'), ((1394, 1491), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'template': 'f"""Translate \'{text_input}\' to {target_language}"""', 'input_variables': '[]'}), '(template=f"Translate \'{text_input}\' to {target_language}",\n input_variables=[])\n', (1408, 1491), False, 'from langchain import PromptTemplate\n'), ((1528, 1560), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (1536, 1560), False, 'from langchain.chains import LLMChain\n'), ((433, 566), 'genai.schemas.GenerateParams', 'GenerateParams', ([], {'decoding_method': '"""sample"""', 'max_new_tokens': '(200)', 'min_new_tokens': '(1)', 'stream': '(False)', 'temperature': '(0.7)', 'top_k': '(50)', 'top_p': '(1)'}), "(decoding_method='sample', max_new_tokens=200, min_new_tokens\n =1, stream=False, temperature=0.7, top_k=50, top_p=1)\n", (447, 566), False, 'from genai.schemas import GenerateParams\n')] |
"""Push and pull to the LangChain Hub."""
from __future__ import annotations
from typing import TYPE_CHECKING, Any, Optional
from langchain.load.dump import dumps
from langchain.load.load import loads
if TYPE_CHECKING:
from langchainhub import Client
def _get_client(api_url: Optional[str] = None, api_key: Optional[str] = None) -> Client:
try:
from langchainhub import Client
except ImportError as e:
raise ImportError(
"Could not import langchainhub, please install with `pip install "
"langchainhub`."
) from e
# Client logic will also attempt to load URL/key from environment variables
return Client(api_url, api_key=api_key)
def push(
repo_full_name: str,
object: Any,
*,
api_url: Optional[str] = None,
api_key: Optional[str] = None,
parent_commit_hash: Optional[str] = "latest",
new_repo_is_public: bool = False,
new_repo_description: str = "",
) -> str:
"""
Pushes an object to the hub and returns the new commit hash.
:param repo_full_name: The full name of the repo to push to in the format of
`owner/repo`.
:param object: The LangChain to serialize and push to the hub.
:param api_url: The URL of the LangChain Hub API. Defaults to the hosted API service
if you have an api key set, or a localhost instance if not.
:param api_key: The API key to use to authenticate with the LangChain Hub API.
:param parent_commit_hash: The commit hash of the parent commit to push to. Defaults
to the latest commit automatically.
:param new_repo_is_public: Whether the repo should be public. Defaults to
False (Private by default).
:param new_repo_description: The description of the repo. Defaults to an empty
string.
"""
client = _get_client(api_url=api_url, api_key=api_key)
manifest_json = dumps(object)
resp = client.push(
repo_full_name,
manifest_json,
parent_commit_hash=parent_commit_hash,
new_repo_is_public=new_repo_is_public,
new_repo_description=new_repo_description,
)
commit_hash: str = resp["commit"]["commit_hash"]
return commit_hash
def pull(
owner_repo_commit: str,
*,
api_url: Optional[str] = None,
api_key: Optional[str] = None,
) -> Any:
"""
Pulls an object from the hub and returns it as a LangChain object.
:param owner_repo_commit: The full name of the repo to pull from in the format of
`owner/repo:commit_hash`.
:param api_url: The URL of the LangChain Hub API. Defaults to the hosted API service
if you have an api key set, or a localhost instance if not.
:param api_key: The API key to use to authenticate with the LangChain Hub API.
"""
client = _get_client(api_url=api_url, api_key=api_key)
resp: str = client.pull(owner_repo_commit)
return loads(resp)
| [
"langchainhub.Client",
"langchain.load.load.loads",
"langchain.load.dump.dumps"
] | [((671, 703), 'langchainhub.Client', 'Client', (['api_url'], {'api_key': 'api_key'}), '(api_url, api_key=api_key)\n', (677, 703), False, 'from langchainhub import Client\n'), ((1886, 1899), 'langchain.load.dump.dumps', 'dumps', (['object'], {}), '(object)\n', (1891, 1899), False, 'from langchain.load.dump import dumps\n'), ((2890, 2901), 'langchain.load.load.loads', 'loads', (['resp'], {}), '(resp)\n', (2895, 2901), False, 'from langchain.load.load import loads\n')] |
"""Base interface that all chains should implement."""
import inspect
import json
import logging
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import Field, root_validator, validator
import langchain
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForChainRun,
CallbackManager,
CallbackManagerForChainRun,
Callbacks,
)
from langchain.load.dump import dumpd
from langchain.load.serializable import Serializable
from langchain.schema import RUN_KEY, BaseMemory, RunInfo
logger = logging.getLogger(__name__)
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(Serializable, ABC):
"""Abstract base class for creating structured sequences of calls to components.
Chains should be used to encode a sequence of calls to components like
models, document retrievers, other chains, etc., and provide a simple interface
to this sequence.
The Chain interface makes it easy to create apps that are:
- Stateful: add Memory to any Chain to give it state,
- Observable: pass Callbacks to a Chain to execute additional functionality,
like logging, outside the main sequence of component calls,
- Composable: the Chain API is flexible enough that it is easy to combine
Chains with other components, including other Chains.
The main methods exposed by chains are:
- `__call__`: Chains are callable. The `__call__` method is the primary way to
execute a Chain. This takes inputs as a dictionary and returns a
dictionary output.
- `run`: A convenience method that takes inputs as args/kwargs and returns the
output as a string. This method can only be used for a subset of chains and
cannot return as rich of an output as `__call__`.
"""
memory: Optional[BaseMemory] = None
"""Optional memory object. Defaults to None.
Memory is a class that gets called at the start
and at the end of every chain. At the start, memory loads variables and passes
them along in the chain. At the end, it saves any returned variables.
There are many different types of memory - please see memory docs
for the full catalog."""
callbacks: Callbacks = Field(default=None, exclude=True)
"""Optional list of callback handlers (or callback manager). Defaults to None.
Callback handlers are called throughout the lifecycle of a call to a chain,
starting with on_chain_start, ending with on_chain_end or on_chain_error.
Each custom chain can optionally call additional callback methods, see Callback docs
for full details."""
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
"""Deprecated, use `callbacks` instead."""
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether or not run in verbose mode. In verbose mode, some intermediate logs
will be printed to the console. Defaults to `langchain.verbose` value."""
tags: Optional[List[str]] = None
"""Optional list of tags associated with the chain. Defaults to None
These tags will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
metadata: Optional[Dict[str, Any]] = None
"""Optional metadata associated with the chain. Defaults to None
This metadata will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@root_validator()
def raise_callback_manager_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""Set the chain verbosity.
Defaults to the global setting if not specified by the user.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Return the keys expected to be in the chain input."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Return the keys expected to be in the chain output."""
def _validate_inputs(self, inputs: Dict[str, Any]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, Any]) -> None:
missing_keys = set(self.output_keys).difference(outputs)
if missing_keys:
raise ValueError(f"Missing some output keys: {missing_keys}")
@abstractmethod
def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.__call__`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
async def _acall(
self,
inputs: Dict[str, Any],
run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.acall`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = CallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
run_manager = callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
self._call(inputs, run_manager=run_manager)
if new_arg_supported
else self._call(inputs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise e
run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
async def acall(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = AsyncCallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
run_manager = await callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
await self._acall(inputs, run_manager=run_manager)
if new_arg_supported
else await self._acall(inputs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise e
await run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prepare chain outputs, and save info about this run to memory.
Args:
inputs: Dictionary of chain inputs, including any inputs added by chain
memory.
outputs: Dictionary of initial chain outputs.
return_only_outputs: Whether to only return the chain outputs. If False,
inputs are also added to the final outputs.
Returns:
A dict of the final chain outputs.
"""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prepare chain inputs, including adding inputs from memory.
Args:
inputs: Dictionary of raw inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
Returns:
A dictionary of all inputs, including those added by the chain's memory.
"""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
@property
def _run_output_key(self) -> str:
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
return self.output_keys[0]
def run(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."
"""
# Run at start to make sure this is possible/defined
_output_key = self._run_output_key
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if kwargs and not args:
return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if not kwargs and not args:
raise ValueError(
"`run` supported with either positional arguments or keyword arguments,"
" but none were provided."
)
else:
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
await chain.arun("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
await chain.arun(question=question, context=context)
# -> "The temperature in Boise is..."
"""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
elif args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (
await self.acall(
args[0], callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
if kwargs and not args:
return (
await self.acall(
kwargs, callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
**kwargs: Keyword arguments passed to default `pydantic.BaseModel.dict`
method.
Returns:
A dictionary representation of the chain.
Example:
..code-block:: python
chain.dict(exclude_unset=True)
# -> {"_type": "foo", "verbose": False, ...}
"""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict(**kwargs)
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
def apply(
self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs, callbacks=callbacks) for inputs in input_list]
| [
"langchain.load.dump.dumpd",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.schema.RunInfo",
"langchain.callbacks.manager.CallbackManager.configure"
] | [((702, 729), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (719, 729), False, 'import logging\n'), ((2435, 2468), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2440, 2468), False, 'from pydantic import Field, root_validator, validator\n'), ((2878, 2911), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2883, 2911), False, 'from pydantic import Field, root_validator, validator\n'), ((2979, 3016), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2984, 3016), False, 'from pydantic import Field, root_validator, validator\n'), ((4107, 4123), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (4121, 4123), False, 'from pydantic import Field, root_validator, validator\n'), ((4576, 4619), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (4585, 4619), False, 'from pydantic import Field, root_validator, validator\n'), ((9402, 9514), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose, tags,\n self.tags, metadata, self.metadata)\n', (9427, 9514), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((12243, 12360), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose,\n tags, self.tags, metadata, self.metadata)\n', (12273, 12360), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((4331, 4433), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (4344, 4433), False, 'import warnings\n'), ((9761, 9772), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (9766, 9772), False, 'from langchain.load.dump import dumpd\n'), ((10332, 10366), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (10339, 10366), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((13211, 13245), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (13218, 13245), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((23986, 24001), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (23990, 24001), False, 'from pathlib import Path\n'), ((12614, 12625), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (12619, 12625), False, 'from langchain.load.dump import dumpd\n'), ((24321, 24355), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (24330, 24355), False, 'import json\n'), ((9634, 9663), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (9651, 9663), False, 'import inspect\n'), ((12480, 12510), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (12497, 12510), False, 'import inspect\n'), ((24458, 24508), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (24467, 24508), False, 'import yaml\n')] |
"""Utilities for running language models or Chains over datasets."""
from __future__ import annotations
import functools
import inspect
import logging
import uuid
from enum import Enum
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Sequence,
Tuple,
Union,
cast,
)
from langsmith.client import Client
from langsmith.evaluation import RunEvaluator
from langsmith.run_helpers import as_runnable, is_traceable_function
from langsmith.schemas import Dataset, DataType, Example
from langsmith.utils import LangSmithError
from requests import HTTPError
from langchain._api import warn_deprecated
from langchain.callbacks.manager import Callbacks
from langchain.callbacks.tracers.evaluation import (
EvaluatorCallbackHandler,
wait_for_all_evaluators,
)
from langchain.callbacks.tracers.langchain import LangChainTracer
from langchain.chains.base import Chain
from langchain.evaluation.loading import load_evaluator
from langchain.evaluation.schema import (
EvaluatorType,
PairwiseStringEvaluator,
StringEvaluator,
)
from langchain.schema import ChatResult, LLMResult
from langchain.schema.language_model import BaseLanguageModel
from langchain.schema.messages import BaseMessage, messages_from_dict
from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda
from langchain.schema.runnable import config as runnable_config
from langchain.schema.runnable import utils as runnable_utils
from langchain.smith import evaluation as smith_eval
from langchain.smith.evaluation import config as smith_eval_config
from langchain.smith.evaluation import name_generation, progress
if TYPE_CHECKING:
import pandas as pd
logger = logging.getLogger(__name__)
MODEL_OR_CHAIN_FACTORY = Union[
Callable[[], Union[Chain, Runnable]],
BaseLanguageModel,
Callable[[dict], Any],
Runnable,
Chain,
]
MCF = Union[Callable[[], Union[Chain, Runnable]], BaseLanguageModel]
class InputFormatError(Exception):
"""Raised when the input format is invalid."""
## Shared Utilities
class TestResult(dict):
"""A dictionary of the results of a single test run."""
def get_aggregate_feedback(
self, quantiles: Optional[Sequence[float]] = None
) -> pd.DataFrame:
"""Return quantiles for the feedback scores.
This method calculates and prints the quantiles for the feedback scores
across all feedback keys.
Returns:
A DataFrame containing the quantiles for each feedback key.
"""
df = self.to_dataframe()
feedback_cols = [
col for col in df.columns if col not in ["input", "output", "reference"]
]
_quantiles = df[feedback_cols].quantile(
quantiles or [0.25, 0.5, 0.75], numeric_only=True
)
_quantiles.loc["mean"] = df[feedback_cols].mean()
_quantiles.loc["mode"] = df[feedback_cols].mode().iloc[0]
return _quantiles.transpose()
def to_dataframe(self) -> pd.DataFrame:
"""Convert the results to a dataframe."""
try:
import pandas as pd
except ImportError as e:
raise ImportError(
"Pandas is required to convert the results to a dataframe."
" to install pandas, run `pip install pandas`."
) from e
indices = []
records = []
for example_id, result in self["results"].items():
feedback = result["feedback"]
r = {
**{f.key: f.score for f in feedback},
"input": result["input"],
"output": result["output"],
}
if "reference" in result:
r["reference"] = result["reference"]
records.append(r)
indices.append(example_id)
return pd.DataFrame(records, index=indices)
def _wrap_in_chain_factory(
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
dataset_name: str = "<my_dataset>",
) -> MCF:
"""Forgive the user if they pass in a chain without memory instead of a chain
factory. It's a common mistake. Raise a more helpful error message as well."""
if isinstance(llm_or_chain_factory, Chain):
chain = llm_or_chain_factory
chain_class = chain.__class__.__name__
if llm_or_chain_factory.memory is not None:
memory_class = chain.memory.__class__.__name__
raise ValueError(
"Cannot directly evaluate a chain with stateful memory."
" To evaluate this chain, pass in a chain constructor"
" that initializes fresh memory each time it is called."
" This will safegaurd against information"
" leakage between dataset examples."
"\nFor example:\n\n"
"def chain_constructor():\n"
f" new_memory = {memory_class}(...)\n"
f" return {chain_class}"
"(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
return lambda: chain
elif isinstance(llm_or_chain_factory, BaseLanguageModel):
return llm_or_chain_factory
elif isinstance(llm_or_chain_factory, Runnable):
# Memory may exist here, but it's not elegant to check all those cases.
lcf = llm_or_chain_factory
return lambda: lcf
elif callable(llm_or_chain_factory):
if is_traceable_function(llm_or_chain_factory):
runnable_ = as_runnable(cast(Callable, llm_or_chain_factory))
return lambda: runnable_
try:
_model = llm_or_chain_factory() # type: ignore[call-arg]
except TypeError:
# It's an arbitrary function, wrap it in a RunnableLambda
user_func = cast(Callable, llm_or_chain_factory)
sig = inspect.signature(user_func)
logger.info(f"Wrapping function {sig} as RunnableLambda.")
wrapped = RunnableLambda(user_func)
return lambda: wrapped
constructor = cast(Callable, llm_or_chain_factory)
if isinstance(_model, BaseLanguageModel):
# It's not uncommon to do an LLM constructor instead of raw LLM,
# so we'll unpack it for the user.
return _model
elif is_traceable_function(cast(Callable, _model)):
runnable_ = as_runnable(cast(Callable, _model))
return lambda: runnable_
elif not isinstance(_model, Runnable):
# This is unlikely to happen - a constructor for a model function
return lambda: RunnableLambda(constructor)
else:
# Typical correct case
return constructor # noqa
return llm_or_chain_factory
def _get_prompt(inputs: Dict[str, Any]) -> str:
"""Get prompt from inputs.
Args:
inputs: The input dictionary.
Returns:
A string prompt.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
prompts = []
if "prompt" in inputs:
if not isinstance(inputs["prompt"], str):
raise InputFormatError(
"Expected string for 'prompt', got"
f" {type(inputs['prompt']).__name__}"
)
prompts = [inputs["prompt"]]
elif "prompts" in inputs:
if not isinstance(inputs["prompts"], list) or not all(
isinstance(i, str) for i in inputs["prompts"]
):
raise InputFormatError(
"Expected list of strings for 'prompts',"
f" got {type(inputs['prompts']).__name__}"
)
prompts = inputs["prompts"]
elif len(inputs) == 1:
prompt_ = next(iter(inputs.values()))
if isinstance(prompt_, str):
prompts = [prompt_]
elif isinstance(prompt_, list) and all(isinstance(i, str) for i in prompt_):
prompts = prompt_
else:
raise InputFormatError(f"LLM Run expects string prompt input. Got {inputs}")
else:
raise InputFormatError(
f"LLM Run expects 'prompt' or 'prompts' in inputs. Got {inputs}"
)
if len(prompts) == 1:
return prompts[0]
else:
raise InputFormatError(
f"LLM Run expects single prompt input. Got {len(prompts)} prompts."
)
def _get_messages(inputs: Dict[str, Any]) -> List[BaseMessage]:
"""Get Chat Messages from inputs.
Args:
inputs: The input dictionary.
Returns:
A list of chat messages.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
if "messages" in inputs:
single_input = inputs["messages"]
elif len(inputs) == 1:
single_input = next(iter(inputs.values()))
else:
raise InputFormatError(
f"Chat Run expects 'messages' in inputs when example has multiple"
f" input keys. Got {inputs}"
)
if isinstance(single_input, list) and all(
isinstance(i, dict) for i in single_input
):
raw_messages = [single_input]
elif isinstance(single_input, list) and all(
isinstance(i, list) for i in single_input
):
raw_messages = single_input
else:
raise InputFormatError(
f"Chat Run expects List[dict] or List[List[dict]] values for"
f" 'messages' key input. Got {inputs}"
)
if len(raw_messages) == 1:
return messages_from_dict(raw_messages[0])
else:
raise InputFormatError(
f"Chat Run expects single List[dict] or List[List[dict]] 'messages'"
f" input. Got {len(raw_messages)} messages from inputs {inputs}"
)
## Shared data validation utilities
def _validate_example_inputs_for_language_model(
first_example: Example,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
if input_mapper:
prompt_input = input_mapper(first_example.inputs)
if not isinstance(prompt_input, str) and not (
isinstance(prompt_input, list)
and all(isinstance(msg, BaseMessage) for msg in prompt_input)
):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for an LLM or chat model, the output must a single string or"
" a list of chat messages."
f"\nGot: {prompt_input} of type {type(prompt_input)}."
)
else:
try:
_get_prompt(first_example.inputs)
except InputFormatError:
try:
_get_messages(first_example.inputs)
except InputFormatError:
raise InputFormatError(
"Example inputs do not match language model input format. "
"Expected a dictionary with messages or a single prompt."
f" Got: {first_example.inputs}"
" Please update your dataset OR provide an input_mapper"
" to convert the example.inputs to a compatible format"
" for the llm or chat model you wish to evaluate."
)
def _validate_example_inputs_for_chain(
first_example: Example,
chain: Chain,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs match the chain input keys."""
if input_mapper:
first_inputs = input_mapper(first_example.inputs)
missing_keys = set(chain.input_keys).difference(first_inputs)
if not isinstance(first_inputs, dict):
raise InputFormatError(
"When using an input_mapper to prepare dataset example"
" inputs for a chain, the mapped value must be a dictionary."
f"\nGot: {first_inputs} of type {type(first_inputs)}."
)
if missing_keys:
raise InputFormatError(
"Missing keys after loading example using input_mapper."
f"\nExpected: {chain.input_keys}. Got: {first_inputs.keys()}"
)
else:
first_inputs = first_example.inputs
missing_keys = set(chain.input_keys).difference(first_inputs)
if len(first_inputs) == 1 and len(chain.input_keys) == 1:
# We can pass this through the run method.
# Refrain from calling to validate.
pass
elif missing_keys:
raise InputFormatError(
"Example inputs missing expected chain input keys."
" Please provide an input_mapper to convert the example.inputs"
" to a compatible format for the chain you wish to evaluate."
f"Expected: {chain.input_keys}. "
f"Got: {first_inputs.keys()}"
)
def _validate_example_inputs(
example: Example,
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs are valid for the model."""
if isinstance(llm_or_chain_factory, BaseLanguageModel):
_validate_example_inputs_for_language_model(example, input_mapper)
else:
chain = llm_or_chain_factory()
if isinstance(chain, Chain):
# Otherwise it's a runnable
_validate_example_inputs_for_chain(example, chain, input_mapper)
elif isinstance(chain, Runnable):
logger.debug(f"Skipping input validation for {chain}")
## Shared Evaluator Setup Utilities
def _setup_evaluation(
llm_or_chain_factory: MCF,
examples: List[Example],
evaluation: Optional[smith_eval.RunEvalConfig],
data_type: DataType,
) -> Optional[List[RunEvaluator]]:
"""Configure the evaluators to run on the results of the chain."""
if evaluation:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
run_inputs, run_outputs = None, None
run_type = "llm"
else:
run_type = "chain"
if data_type in (DataType.chat, DataType.llm):
val = data_type.value if isinstance(data_type, Enum) else data_type
raise ValueError(
"Cannot evaluate a chain on dataset with "
f"data_type={val}. "
"Please specify a dataset with the default 'kv' data type."
)
chain = llm_or_chain_factory()
run_inputs = chain.input_keys if isinstance(chain, Chain) else None
run_outputs = chain.output_keys if isinstance(chain, Chain) else None
run_evaluators = _load_run_evaluators(
evaluation,
run_type,
data_type,
list(examples[0].outputs) if examples[0].outputs else None,
run_inputs,
run_outputs,
)
else:
# TODO: Create a default helpfulness evaluator
run_evaluators = None
return run_evaluators
def _determine_input_key(
config: smith_eval.RunEvalConfig,
run_inputs: Optional[List[str]],
) -> Optional[str]:
input_key = None
if config.input_key:
input_key = config.input_key
if run_inputs and input_key not in run_inputs:
raise ValueError(f"Input key {input_key} not in run inputs {run_inputs}")
elif run_inputs and len(run_inputs) == 1:
input_key = run_inputs[0]
elif run_inputs is not None and len(run_inputs) > 1:
raise ValueError(
f"Must specify input key for model with multiple inputs: {run_inputs}"
)
return input_key
def _determine_prediction_key(
config: smith_eval.RunEvalConfig,
run_outputs: Optional[List[str]],
) -> Optional[str]:
prediction_key = None
if config.prediction_key:
prediction_key = config.prediction_key
if run_outputs and prediction_key not in run_outputs:
raise ValueError(
f"Prediction key {prediction_key} not in run outputs {run_outputs}"
)
elif run_outputs and len(run_outputs) == 1:
prediction_key = run_outputs[0]
elif run_outputs is not None and len(run_outputs) > 1:
raise ValueError(
f"Must specify prediction key for model"
f" with multiple outputs: {run_outputs}"
)
return prediction_key
def _determine_reference_key(
config: smith_eval.RunEvalConfig,
example_outputs: Optional[List[str]],
) -> Optional[str]:
if config.reference_key:
reference_key = config.reference_key
if example_outputs and reference_key not in example_outputs:
raise ValueError(
f"Reference key {reference_key} not in Dataset"
f" example outputs: {example_outputs}"
)
elif example_outputs and len(example_outputs) == 1:
reference_key = list(example_outputs)[0]
else:
reference_key = None
return reference_key
def _construct_run_evaluator(
eval_config: Union[EvaluatorType, str, smith_eval_config.EvalConfig],
eval_llm: Optional[BaseLanguageModel],
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
reference_key: Optional[str],
input_key: Optional[str],
prediction_key: Optional[str],
) -> RunEvaluator:
if isinstance(eval_config, (EvaluatorType, str)):
if not isinstance(eval_config, EvaluatorType):
eval_config = EvaluatorType(eval_config)
evaluator_ = load_evaluator(eval_config, llm=eval_llm)
eval_type_tag = eval_config.value
else:
kwargs = {"llm": eval_llm, **eval_config.get_kwargs()}
evaluator_ = load_evaluator(eval_config.evaluator_type, **kwargs)
eval_type_tag = eval_config.evaluator_type.value
if isinstance(evaluator_, StringEvaluator):
if evaluator_.requires_reference and reference_key is None:
raise ValueError(
f"Must specify reference_key in smith_eval.RunEvalConfig to use"
f" evaluator of type {eval_type_tag} with"
f" dataset with multiple output keys: {example_outputs}."
)
run_evaluator = smith_eval.StringRunEvaluatorChain.from_run_and_data_type(
evaluator_,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
tags=[eval_type_tag],
)
elif isinstance(evaluator_, PairwiseStringEvaluator):
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented."
" PairwiseStringEvaluators compare the outputs of two different models"
" rather than the output of a single model."
" Did you mean to use a StringEvaluator instead?"
"\nSee: https://python.langchain.com/docs/guides/evaluation/string/"
)
else:
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented"
)
return run_evaluator
def _get_keys(
config: smith_eval.RunEvalConfig,
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
example_outputs: Optional[List[str]],
) -> Tuple[Optional[str], Optional[str], Optional[str]]:
input_key = _determine_input_key(config, run_inputs)
prediction_key = _determine_prediction_key(config, run_outputs)
reference_key = _determine_reference_key(config, example_outputs)
return input_key, prediction_key, reference_key
def _load_run_evaluators(
config: smith_eval.RunEvalConfig,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
) -> List[RunEvaluator]:
"""
Load run evaluators from a configuration.
Args:
config: Configuration for the run evaluators.
Returns:
A list of run evaluators.
"""
run_evaluators = []
input_key, prediction_key, reference_key = None, None, None
if (
config.evaluators
or any([isinstance(e, EvaluatorType) for e in config.evaluators])
or (
config.custom_evaluators
and any([isinstance(e, StringEvaluator) for e in config.custom_evaluators])
)
):
input_key, prediction_key, reference_key = _get_keys(
config, run_inputs, run_outputs, example_outputs
)
for eval_config in config.evaluators:
run_evaluator = _construct_run_evaluator(
eval_config,
config.eval_llm,
run_type,
data_type,
example_outputs,
reference_key,
input_key,
prediction_key,
)
run_evaluators.append(run_evaluator)
custom_evaluators = config.custom_evaluators or []
for custom_evaluator in custom_evaluators:
if isinstance(custom_evaluator, RunEvaluator):
run_evaluators.append(custom_evaluator)
elif isinstance(custom_evaluator, StringEvaluator):
run_evaluators.append(
smith_eval.StringRunEvaluatorChain.from_run_and_data_type(
custom_evaluator,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
)
)
else:
raise ValueError(
f"Unsupported custom evaluator: {custom_evaluator}."
f" Expected RunEvaluator or StringEvaluator."
)
return run_evaluators
### Async Helpers
async def _arun_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
*,
tags: Optional[List[str]] = None,
callbacks: Callbacks = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""Asynchronously run the language model.
Args:
llm: The language model to run.
inputs: The input dictionary.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map inputs to the expected format.
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
return await llm.apredict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
return await llm.apredict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format"
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
prompt = _get_prompt(inputs)
llm_output: Union[str, BaseMessage] = await llm.apredict(
prompt, callbacks=callbacks, tags=tags
)
except InputFormatError:
messages = _get_messages(inputs)
llm_output = await llm.apredict_messages(
messages, callbacks=callbacks, tags=tags
)
return llm_output
async def _arun_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str]:
"""Run a chain asynchronously on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if (
isinstance(chain, Chain)
and isinstance(inputs_, dict)
and len(inputs_) == 1
and chain.input_keys
):
val = next(iter(inputs_.values()))
output = await chain.acall(val, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = await chain.ainvoke(inputs_, config=runnable_config)
return output
async def _arun_llm_or_chain(
example: Example,
config: RunnableConfig,
*,
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""Asynchronously run the Chain or language model.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map the input to the expected format.
Returns:
A list of outputs.
"""
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = await _arun_llm(
llm_or_chain_factory,
example.inputs,
tags=config["tags"],
callbacks=config["callbacks"],
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = await _arun_chain(
chain,
example.inputs,
tags=config["tags"],
callbacks=config["callbacks"],
input_mapper=input_mapper,
)
result = output
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id} "
f"with inputs {example.inputs}"
f"\n{repr(e)}"
)
result = {"Error": repr(e)}
return result
## Sync Utilities
def _run_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""
Run the language model on the example.
Args:
llm: The language model to run.
inputs: The input dictionary.
callbacks: The callbacks to use during the run.
tags: Optional tags to add to the run.
input_mapper: function to map to the inputs dictionary from an Example
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
llm_output: Union[str, BaseMessage] = llm.predict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
llm_output = llm.predict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format: "
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
llm_prompts = _get_prompt(inputs)
llm_output = llm.predict(llm_prompts, callbacks=callbacks, tags=tags)
except InputFormatError:
llm_messages = _get_messages(inputs)
llm_output = llm.predict_messages(llm_messages, callbacks=callbacks)
return llm_output
def _run_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[Dict, str]:
"""Run a chain on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if (
isinstance(chain, Chain)
and isinstance(inputs_, dict)
and len(inputs_) == 1
and chain.input_keys
):
val = next(iter(inputs_.values()))
output = chain(val, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = chain.invoke(inputs_, config=runnable_config)
return output
def _run_llm_or_chain(
example: Example,
config: RunnableConfig,
*,
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""
Run the Chain or language model synchronously.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
Returns:
Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
The outputs of the model or chain.
"""
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = _run_llm(
llm_or_chain_factory,
example.inputs,
config["callbacks"],
tags=config["tags"],
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = _run_chain(
chain,
example.inputs,
config["callbacks"],
tags=config["tags"],
input_mapper=input_mapper,
)
result = output
except Exception as e:
error_type = type(e).__name__
logger.warning(
f"{chain_or_llm} failed for example {example.id} "
f"with inputs {example.inputs}"
f"\nError Type: {error_type}, Message: {e}"
)
result = {"Error": repr(e)}
return result
## Public API
def _prepare_eval_run(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: str,
project_metadata: Optional[Dict[str, Any]] = None,
) -> Tuple[MCF, str, Dataset, List[Example]]:
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory, dataset_name)
dataset = client.read_dataset(dataset_name=dataset_name)
try:
project = client.create_project(
project_name,
reference_dataset_id=dataset.id,
project_extra={"metadata": project_metadata} if project_metadata else {},
)
except (HTTPError, ValueError, LangSmithError) as e:
if "already exists " not in str(e):
raise e
uid = uuid.uuid4()
example_msg = f"""
run_on_dataset(
...
project_name="{project_name} - {uid}", # Update since {project_name} already exists
)
"""
raise ValueError(
f"Test project {project_name} already exists. Please use a different name:"
f"\n\n{example_msg}"
)
print(
f"View the evaluation results for project '{project_name}'"
f" at:\n{project.url}?eval=true\n\n"
f"View all tests for Dataset {dataset_name} at:\n{dataset.url}",
flush=True,
)
examples = list(client.list_examples(dataset_id=dataset.id))
if not examples:
raise ValueError(f"Dataset {dataset_name} has no example rows.")
return wrapped_model, project_name, dataset, examples
def _prepare_run_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: Optional[str],
evaluation: Optional[smith_eval.RunEvalConfig] = None,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
concurrency_level: int = 5,
project_metadata: Optional[Dict[str, Any]] = None,
) -> Tuple[MCF, str, List[Example], List[RunnableConfig]]:
project_name = project_name or name_generation.random_name()
wrapped_model, project_name, dataset, examples = _prepare_eval_run(
client,
dataset_name,
llm_or_chain_factory,
project_name,
project_metadata=project_metadata,
)
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory)
run_evaluators = _setup_evaluation(
wrapped_model, examples, evaluation, dataset.data_type or DataType.kv
)
_validate_example_inputs(examples[0], wrapped_model, input_mapper)
progress_bar = progress.ProgressBarCallback(len(examples))
configs = [
RunnableConfig(
callbacks=[
LangChainTracer(
project_name=project_name,
client=client,
use_threading=False,
example_id=example.id,
),
EvaluatorCallbackHandler(
evaluators=run_evaluators or [],
client=client,
example_id=example.id,
),
progress_bar,
],
tags=tags or [],
max_concurrency=concurrency_level,
)
for example in examples
]
return wrapped_model, project_name, examples, configs
def _collect_test_results(
examples: List[Example],
batch_results: List[Union[dict, str, LLMResult, ChatResult]],
configs: List[RunnableConfig],
project_name: str,
) -> TestResult:
wait_for_all_evaluators()
all_eval_results = {}
for c in configs:
for callback in cast(list, c["callbacks"]):
if isinstance(callback, EvaluatorCallbackHandler):
eval_results = callback.logged_eval_results
all_eval_results.update(
{example_id: v for (_, example_id), v in eval_results.items()}
)
results = {}
for example, output in zip(examples, batch_results):
feedback = all_eval_results.get(str(example.id), [])
results[str(example.id)] = {
"output": output,
"input": example.inputs,
"feedback": feedback,
}
if example.outputs:
results[str(example.id)]["reference"] = example.outputs
return TestResult(
project_name=project_name,
results=results,
)
_INPUT_MAPPER_DEP_WARNING = (
"The input_mapper argument is deprecated and "
"will be removed in a future release. Please add a "
" RunnableLambda to your chain to map inputs to the expected format"
" instead. Example:\n"
"def construct_chain():\n"
" my_chain = ...\n"
" input_mapper = {'other_key': 'MyOtherInput', 'my_input_key': x}\n"
" return input_mapper | my_chain\n"
"run_on_dataset(..., llm_or_chain_factory=construct_chain)\n"
"(See https://api.python.langchain.com/en/latest/schema/"
"langchain.schema.runnable.base.RunnableLambda.html)"
)
async def arun_on_dataset(
client: Optional[Client],
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[smith_eval.RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
project_metadata: Optional[Dict[str, Any]] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
input_mapper = kwargs.pop("input_mapper", None)
if input_mapper:
warn_deprecated("0.0.305", message=_INPUT_MAPPER_DEP_WARNING, pending=True)
if kwargs:
warn_deprecated(
"0.0.305",
message="The following arguments are deprecated and "
"will be removed in a future release: "
f"{kwargs.keys()}.",
removal="0.0.305",
)
client = client or Client()
wrapped_model, project_name, examples, configs = _prepare_run_on_dataset(
client,
dataset_name,
llm_or_chain_factory,
project_name,
evaluation,
tags,
input_mapper,
concurrency_level,
project_metadata=project_metadata,
)
batch_results = await runnable_utils.gather_with_concurrency(
configs[0].get("max_concurrency"),
*map(
functools.partial(
_arun_llm_or_chain,
llm_or_chain_factory=wrapped_model,
input_mapper=input_mapper,
),
examples,
configs,
),
)
results = _collect_test_results(examples, batch_results, configs, project_name)
if verbose:
try:
agg_feedback = results.get_aggregate_feedback()
print("\n Eval quantiles:")
print(agg_feedback)
except Exception as e:
logger.debug(f"Failed to print aggregate feedback: {repr(e)}")
return results
def run_on_dataset(
client: Optional[Client],
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[smith_eval.RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
project_metadata: Optional[Dict[str, Any]] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
input_mapper = kwargs.pop("input_mapper", None)
if input_mapper:
warn_deprecated("0.0.305", message=_INPUT_MAPPER_DEP_WARNING, pending=True)
if kwargs:
warn_deprecated(
"0.0.305",
message="The following arguments are deprecated and "
"will be removed in a future release: "
f"{kwargs.keys()}.",
removal="0.0.305",
)
client = client or Client()
wrapped_model, project_name, examples, configs = _prepare_run_on_dataset(
client,
dataset_name,
llm_or_chain_factory,
project_name,
evaluation,
tags,
input_mapper,
concurrency_level,
project_metadata=project_metadata,
)
if concurrency_level == 0:
batch_results = [
_run_llm_or_chain(
example,
config,
llm_or_chain_factory=wrapped_model,
input_mapper=input_mapper,
)
for example, config in zip(examples, configs)
]
else:
with runnable_config.get_executor_for_config(configs[0]) as executor:
batch_results = list(
executor.map(
functools.partial(
_run_llm_or_chain,
llm_or_chain_factory=wrapped_model,
input_mapper=input_mapper,
),
examples,
configs,
)
)
results = _collect_test_results(examples, batch_results, configs, project_name)
if verbose:
try:
agg_feedback = results.get_aggregate_feedback()
print("\n Eval quantiles:")
print(agg_feedback)
except Exception as e:
logger.debug(f"Failed to print aggregate feedback: {repr(e)}")
return results
_RUN_ON_DATASET_DOCSTRING = """
Run the Chain or language model on a dataset and store traces
to the specified project name.
Args:
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Configuration for evaluators to run on the
results of the chain
concurrency_level: The number of async tasks to run concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
project_metadata: Optional metadata to add to the project.
Useful for storing information the test variant.
(prompt version, model version, etc.)
client: LangSmith client to use to access the dataset and to
log feedback and run traces.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
Returns:
A dictionary containing the run's project name and the resulting model outputs.
For the (usually faster) async version of this function, see :func:`arun_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import smith_eval.RunEvalConfig, run_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = smith_eval.RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
smith_eval.RunEvalConfig.Criteria("helpfulness"),
smith_eval.RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = smith_eval.RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
run_on_dataset.__doc__ = _RUN_ON_DATASET_DOCSTRING
arun_on_dataset.__doc__ = _RUN_ON_DATASET_DOCSTRING.replace(
"run_on_dataset(", "await arun_on_dataset("
)
| [
"langchain.evaluation.loading.load_evaluator",
"langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler",
"langchain.schema.runnable.RunnableConfig",
"langchain.schema.runnable.RunnableLambda",
"langchain.schema.messages.messages_from_dict",
"langchain.schema.runnable.config.get_executor_for_config",
"langchain.callbacks.tracers.evaluation.wait_for_all_evaluators",
"langchain.evaluation.schema.EvaluatorType",
"langchain.smith.evaluation.StringRunEvaluatorChain.from_run_and_data_type",
"langchain.callbacks.tracers.langchain.LangChainTracer",
"langchain.smith.evaluation.name_generation.random_name",
"langchain._api.warn_deprecated"
] | [((1724, 1751), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1741, 1751), False, 'import logging\n'), ((33983, 34008), 'langchain.callbacks.tracers.evaluation.wait_for_all_evaluators', 'wait_for_all_evaluators', ([], {}), '()\n', (34006, 34008), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler, wait_for_all_evaluators\n'), ((3847, 3883), 'pandas.DataFrame', 'pd.DataFrame', (['records'], {'index': 'indices'}), '(records, index=indices)\n', (3859, 3883), True, 'import pandas as pd\n'), ((9632, 9667), 'langchain.schema.messages.messages_from_dict', 'messages_from_dict', (['raw_messages[0]'], {}), '(raw_messages[0])\n', (9650, 9667), False, 'from langchain.schema.messages import BaseMessage, messages_from_dict\n'), ((17595, 17636), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config'], {'llm': 'eval_llm'}), '(eval_config, llm=eval_llm)\n', (17609, 17636), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((17773, 17825), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config.evaluator_type'], {}), '(eval_config.evaluator_type, **kwargs)\n', (17787, 17825), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((18282, 18483), 'langchain.smith.evaluation.StringRunEvaluatorChain.from_run_and_data_type', 'smith_eval.StringRunEvaluatorChain.from_run_and_data_type', (['evaluator_', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key', 'tags': '[eval_type_tag]'}), '(evaluator_,\n run_type, data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key, tags=[eval_type_tag])\n', (18339, 18483), True, 'from langchain.smith import evaluation as smith_eval\n'), ((24388, 24440), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (24402, 24440), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((28680, 28732), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (28694, 28732), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((32515, 32544), 'langchain.smith.evaluation.name_generation.random_name', 'name_generation.random_name', ([], {}), '()\n', (32542, 32544), False, 'from langchain.smith.evaluation import name_generation, progress\n'), ((34081, 34107), 'typing.cast', 'cast', (['list', "c['callbacks']"], {}), "(list, c['callbacks'])\n", (34085, 34107), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((35958, 36033), 'langchain._api.warn_deprecated', 'warn_deprecated', (['"""0.0.305"""'], {'message': '_INPUT_MAPPER_DEP_WARNING', 'pending': '(True)'}), "('0.0.305', message=_INPUT_MAPPER_DEP_WARNING, pending=True)\n", (35973, 36033), False, 'from langchain._api import warn_deprecated\n'), ((36313, 36321), 'langsmith.client.Client', 'Client', ([], {}), '()\n', (36319, 36321), False, 'from langsmith.client import Client\n'), ((37857, 37932), 'langchain._api.warn_deprecated', 'warn_deprecated', (['"""0.0.305"""'], {'message': '_INPUT_MAPPER_DEP_WARNING', 'pending': '(True)'}), "('0.0.305', message=_INPUT_MAPPER_DEP_WARNING, pending=True)\n", (37872, 37932), False, 'from langchain._api import warn_deprecated\n'), ((38212, 38220), 'langsmith.client.Client', 'Client', ([], {}), '()\n', (38218, 38220), False, 'from langsmith.client import Client\n'), ((17547, 17573), 'langchain.evaluation.schema.EvaluatorType', 'EvaluatorType', (['eval_config'], {}), '(eval_config)\n', (17560, 17573), False, 'from langchain.evaluation.schema import EvaluatorType, PairwiseStringEvaluator, StringEvaluator\n'), ((31267, 31279), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (31277, 31279), False, 'import uuid\n'), ((38858, 38909), 'langchain.schema.runnable.config.get_executor_for_config', 'runnable_config.get_executor_for_config', (['configs[0]'], {}), '(configs[0])\n', (38897, 38909), True, 'from langchain.schema.runnable import config as runnable_config\n'), ((5477, 5520), 'langsmith.run_helpers.is_traceable_function', 'is_traceable_function', (['llm_or_chain_factory'], {}), '(llm_or_chain_factory)\n', (5498, 5520), False, 'from langsmith.run_helpers import as_runnable, is_traceable_function\n'), ((6096, 6132), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (6100, 6132), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((21237, 21422), 'langchain.smith.evaluation.StringRunEvaluatorChain.from_run_and_data_type', 'smith_eval.StringRunEvaluatorChain.from_run_and_data_type', (['custom_evaluator', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key'}), '(custom_evaluator,\n run_type, data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key)\n', (21294, 21422), True, 'from langchain.smith import evaluation as smith_eval\n'), ((33159, 33265), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)', 'example_id': 'example.id'}), '(project_name=project_name, client=client, use_threading=\n False, example_id=example.id)\n', (33174, 33265), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((33377, 33476), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'evaluators': '(run_evaluators or [])', 'client': 'client', 'example_id': 'example.id'}), '(evaluators=run_evaluators or [], client=client,\n example_id=example.id)\n', (33401, 33476), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler, wait_for_all_evaluators\n'), ((36758, 36862), 'functools.partial', 'functools.partial', (['_arun_llm_or_chain'], {'llm_or_chain_factory': 'wrapped_model', 'input_mapper': 'input_mapper'}), '(_arun_llm_or_chain, llm_or_chain_factory=wrapped_model,\n input_mapper=input_mapper)\n', (36775, 36862), False, 'import functools\n'), ((39007, 39110), 'functools.partial', 'functools.partial', (['_run_llm_or_chain'], {'llm_or_chain_factory': 'wrapped_model', 'input_mapper': 'input_mapper'}), '(_run_llm_or_chain, llm_or_chain_factory=wrapped_model,\n input_mapper=input_mapper)\n', (39024, 39110), False, 'import functools\n'), ((5558, 5594), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5562, 5594), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((5836, 5872), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5840, 5872), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((5891, 5919), 'inspect.signature', 'inspect.signature', (['user_func'], {}), '(user_func)\n', (5908, 5919), False, 'import inspect\n'), ((6013, 6038), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['user_func'], {}), '(user_func)\n', (6027, 6038), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((6368, 6390), 'typing.cast', 'cast', (['Callable', '_model'], {}), '(Callable, _model)\n', (6372, 6390), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((6429, 6451), 'typing.cast', 'cast', (['Callable', '_model'], {}), '(Callable, _model)\n', (6433, 6451), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((6642, 6669), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['constructor'], {}), '(constructor)\n', (6656, 6669), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n')] |
from pydantic import BaseModel, Field
import os
from langchain import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, Tool
# from langchain.chains import PALChain
from langchain.chains.conversation.memory import ConversationBufferMemory
from langchain import PromptTemplate, LLMChain
# import streamlit as st
from dateutil import parser
# from datetime import datetime
import datetime
import calendar
import random
import json
# from faker import Faker
# from datetime import datetime, timedelta
# from langchain.agents.agent_toolkits import create_python_agent
from langchain.agents import load_tools, initialize_agent
from langchain.agents import AgentType
# from langchain.tools.python.tool import PythonREPLTool
from langchain.python import PythonREPL
from langchain.chat_models import ChatOpenAI
from langchain.agents import tool
from langchain import PromptTemplate
from langchain_experimental.tools import PythonAstREPLTool
import os
import streamlit as st
from airtable import Airtable
from langchain.chains.router import MultiRetrievalQAChain
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA
from langchain.vectorstores import DocArrayInMemorySearch
from langchain.indexes import VectorstoreIndexCreator
from streamlit_chat import message
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationalRetrievalChain
from langchain.document_loaders.csv_loader import CSVLoader
from langchain.vectorstores import FAISS
from langchain.llms import OpenAI
from langchain import PromptTemplate
from langchain.memory import ConversationBufferMemory
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from pytz import timezone
# import datetime
from langchain.agents.agent_toolkits import create_retriever_tool
from langchain.agents.agent_toolkits import create_conversational_retrieval_agent
from langchain.chat_models import ChatOpenAI
import langchain
from langchain.agents.openai_functions_agent.agent_token_buffer_memory import AgentTokenBufferMemory
from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
from langchain.schema.messages import SystemMessage
from langchain.prompts import MessagesPlaceholder
from langchain.agents import AgentExecutor
from langchain.smith import RunEvalConfig, run_on_dataset
import pandas as pd
import requests
from pydantic import BaseModel, Field
from langchain.tools import tool
# from datetime import datetime
from typing import Dict, Any
hide_share_button_style = """
<style>
.st-emotion-cache-zq5wmm.ezrtsby0 .stActionButton:nth-child(1) {
display: none !important;
}
</style>
"""
hide_star_and_github_style = """
<style>
.st-emotion-cache-1lb4qcp.e3g6aar0,
.st-emotion-cache-30do4w.e3g6aar0 {
display: none !important;
}
</style>
"""
hide_mainmenu_style = """
<style>
#MainMenu {
display: none !important;
}
</style>
"""
hide_fork_app_button_style = """
<style>
.st-emotion-cache-alurl0.e3g6aar0 {
display: none !important;
}
</style>
"""
st.markdown(hide_share_button_style, unsafe_allow_html=True)
st.markdown(hide_star_and_github_style, unsafe_allow_html=True)
st.markdown(hide_mainmenu_style, unsafe_allow_html=True)
st.markdown(hide_fork_app_button_style, unsafe_allow_html=True)
pd.set_option('display.max_rows', 100)
pd.set_option('display.max_columns', 100)
os.environ['OPENAI_API_KEY'] = st.secrets['OPENAI_API_KEY']
st.image("Twitter.jpg")
datetime.datetime.now()
current_date = datetime.date.today().strftime("%m/%d/%y")
day_of_week = datetime.date.today().weekday()
days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
current_day = days[day_of_week]
todays_date = current_date
day_of_the_week = current_day
business_details_text = [
"working days: all Days except sunday",
"working hours: 9 am to 7 pm",
"Phone: (555) 123-4567",
"Address: 567 Oak Avenue, Anytown, CA 98765, Email: [email protected]",
"dealer ship location: https://maps.app.goo.gl/ecHtb6y5f8q5PUxb9"
]
retriever_3 = FAISS.from_texts(business_details_text, OpenAIEmbeddings()).as_retriever()
file_1 = r'inventory.csv'
loader = CSVLoader(file_path=file_1)
docs_1 = loader.load()
embeddings = OpenAIEmbeddings()
vectorstore_1 = FAISS.from_documents(docs_1, embeddings)
retriever_1 = vectorstore_1.as_retriever(search_type="similarity_score_threshold", search_kwargs={"score_threshold": 0.5,"k": 8})
file_2 = r'short_car_details.csv'
loader_2 = CSVLoader(file_path=file_2)
docs_2 = loader_2.load()
num_ret=len(docs_2)
vectordb_2 = FAISS.from_documents(docs_2, embeddings)
retriever_2 = vectordb_2.as_retriever(search_type="similarity", search_kwargs={"k": num_ret})
tool1 = create_retriever_tool(
retriever_1,
"details_of_car",
"use to get car full details and more information. Input to this should be the car's model\
or car features and new or used car as a single argument for example new toeing car or new jeep cherokee"
)
tool2 = create_retriever_tool(
retriever_2,
"Availability_check",
"use to check availabilty of car, Input is car make or model or both"
)
tool3 = create_retriever_tool(
retriever_3,
"business_details",
"Searches and returns documents related to business working days and hours, location and address details."
)
# class CarDetails(BaseModel):
# make: str
# model: str
# year: int
# class VINDetails(BaseModel):
# vin: str = Field(..., description="VIN of the car to get the car details")
# @tool(args_schema=VINDetails)
# def get_car_details_from_vin(vin):
# """Fetch car details for the given VIN."""
# BASE_URL = f"https://vpic.nhtsa.dot.gov/api/vehicles/DecodeVinValues/{vin}?format=json"
# # Make the request
# response = requests.get(BASE_URL)
# # Check if the request was successful
# if response.status_code == 200:
# # Parse the JSON response
# result = response.json()
# # Check if 'Results' key is present and has at least one item
# if 'Results' in result and result['Results']:
# # Extract the first item from 'Results' list
# first_result = result['Results'][0]
# make = first_result.get('Make', '')
# model = first_result.get('Model', '')
# try:
# year = int(first_result.get('ModelYear', ''))
# except ValueError:
# year = 0 # Handle the case where the year is not a valid integer
# # Create CarDetails instance
# car_details = CarDetails(make=make, model=model, year=year)
# # Print the details for debugging
# print("Car Details:")
# print(f"Make: {car_details.make}, Model: {car_details.model}, Year: {car_details.year}")
# else:
# # Handle the case when 'Results' key is not present or is empty
# car_details = CarDetails(make="", model="", year=0)
# print("No results found for the given VIN.")
# return car_details
# else:
# # Handle the case when the request was not successful
# car_details = CarDetails(make="", model="", year=0)
# print(f"Failed to retrieve car details. Status code: {response.status_code}")
# return car_details
class CarDetails(BaseModel):
make: str
model: str
year: int
class VINDetails(BaseModel):
vin: str = Field(..., description="VIN of the car to get the car details")
@tool
def get_car_details_from_vin(vin):
"""Fetch car details for the given VIN."""
BASE_URL = f"https://vpic.nhtsa.dot.gov/api/vehicles/DecodeVinValues/{vin}?format=json"
# BASE_URL = "https://fe9b-2405-201-200a-100d-b840-86ed-9ebd-a606.ngrok-free.app/appointment/"
# Make the request
response = requests.get(BASE_URL)
# print(response)
# Check if the request was successful
if response.status_code == 200:
# Parse the JSON response
result = response.json()
print(result)
# Check if 'Results' key is present and has at least one item
if 'Results' in result and result['Results']:
# Extract the first item from 'Results' list
first_result = result['Results'][0]
# print("These are first_result")
# print(first_result)
make = first_result.get('Make', '')
model = first_result.get('Model', '')
try:
year = int(first_result.get('ModelYear', ''))
except ValueError:
year = 0 # Handle the case where the year is not a valid integer
# Create CarDetails instance
car_details = CarDetails(make=make, model=model, year=year)
else:
# Handle the case when 'Results' key is not present or is empty
car_details = CarDetails(make="", model="", year=0)
return car_details
else:
# Handle the case when the request was not successful
return CarDetails(make="", model="", year=0)
class AppointmentDetails(BaseModel):
time: str
availability: str
class AppointmentInput(BaseModel):
date: str = Field(..., description="Date for which to get appointment details")
@tool
def get_appointment_details(date):
"""Fetch appointment details for the given date and input to this function should be only "mm-dd-yyyy," format\
such as "04-12-2024" not "date":"mm-dd-yyyy" format."""
BASE_URL="https://4730-2405-201-200a-100d-ac7d-3859-60f0-4d3f.ngrok-free.app/test/appointment"
# Make the request
payload = {
"requested_appointment_date": date
}
response = requests.post(BASE_URL, json=payload)
# print("the response is")
# print(response.text)
# Check if the request was successful
if response.status_code == 200:
# Parse the JSON response
result = response.json()
# print(result)
# Check if the date is present in the response
if date in result and result[date] is not None:
# Extract the appointment details for the given date
appointments = result[date]
return appointments # Return the value
else:
# Handle the case when the date is not present in the response or is None
appointments ={
date: "Not_available"
}
return appointments
else:
# Handle the case when the request was not successful
return []
class CustomerDataStore(BaseModel):
name: str = Field(..., description="name of the customer")
phone: str = Field(..., description="phone number of the customer")
email: str = Field(..., description="email of the customer")
make: str = Field(..., description="year of the car")
model: str = Field(..., description="model of the car")
year:int=Field(..., description="year of the vehicle")
company_id:int=Field(..., description="id of the company")
location_id:int=Field(..., description="location id of the company")
start_date:str=Field(..., description="date of appointment")
appointment_timezone:str=Field(..., description="time zone")
intent:str=Field(..., description="costumer intent")
summary:str=Field(..., description="one line about summary of appointment,")
description:str=Field(..., description="one line about description about visit,")
# Uncomment if you want to use the decorator
@tool
def store_appointment_data(name: str,phone: str,email: str ,make: str,model: str,year:int,
company_id:int,location_id:int,start_date:str,appointment_timezone:str,
intent:str,summary:str,description:str) -> dict:
# def store_appointment_data(data: CustomerDataStore) -> dict:
"""Store appointment data using an API."""
# print(data)
# Your API endpoint for storing appointment data
# api_url = "https://889d-2402-a00-172-22e6-71e5-ba36-c2e7-3c81.ngrok-free.app/test/appointment/create"
api_url="https://4730-2405-201-200a-100d-ac7d-3859-60f0-4d3f.ngrok-free.app/test/appointment/create"
data_dict = {
"company_id": 1,
"location_id": 28,
"lead": {
"name": name,
"phone": phone,
"email": email
},
"vehicle": {
"year": 2023,
"make": make,
"model": model,
"intent": intent
},
"appointment": {
"start_date": start_date,
"description": description,
"summary":summary,
"appointment_timezone": appointment_timezone
}
}
# Make the request
response = requests.post(api_url, json=data_dict)
# Check the response status code
if response.status_code == 200:
print("Data stored successfully!")
else:
print(f"Failed to store data. Status code: {response.status_code}")
print(response.text) # Print the response content for debugging
airtable_api_key = st.secrets["AIRTABLE"]["AIRTABLE_API_KEY"]
os.environ["AIRTABLE_API_KEY"] = airtable_api_key
AIRTABLE_BASE_ID = "appN324U6FsVFVmx2"
AIRTABLE_TABLE_NAME = "new_apis"
st.info("Introducing **Otto**, your cutting-edge partner in streamlining dealership and customer-related operations. At EngagedAi, we specialize in harnessing the power of automation to revolutionize the way dealerships and customers interact. Our advanced solutions seamlessly handle tasks, from managing inventory and customer inquiries to optimizing sales processes, all while enhancing customer satisfaction. Discover a new era of efficiency and convenience with us as your trusted automation ally. [engagedai.io](https://funnelai.com/). For this demo application, we will use the Inventory Dataset. Please explore it [here](https://github.com/buravelliprasad/turbo_6_tools/blob/main/car_desription_new.csv) to get a sense for what questions you can ask.")
if 'chat_history' not in st.session_state:
st.session_state.chat_history = []
if 'generated' not in st.session_state:
st.session_state.generated = []
if 'past' not in st.session_state:
st.session_state.past = []
if 'user_name' not in st.session_state:
st.session_state.user_name = None
llm = ChatOpenAI(model="gpt-4-1106-preview", temperature = 0)
langchain.debug=True
memory_key="chat_history"
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
template = """You are an costumer care support exectutive baesd on your performance you will get bonus and incentives
so follow instructions strictly and respond in Personable, Persuvasive, creative, engaging and professional.
The name of the costumer is {name} and the dealership name is {dealership_name} and
do not start with appointment related questions.
To ensure a consistent and effective response, please adhere to the following guidelines:
Use "car_vailability_check" strictly for checking availability of a specific make or model of the car and
also for getting full list of available makes and models in the inventory.
Use "details_of_car" tool that extracts comprehensive information about specific cars in the inventory.
This includes details like trim, price, color, and cost.
Use "car_vailability_check" for checking car availability and "details_of_car" for car information.
To optimize the search process, ensure the system is aware of the car model and whether the customer
is interested in new or used cars.
In cases where specific details are not included in the initial inquiry, initiate a proactive approach
by requesting the missing information.
To streamline the process, ask only one question at a time until all necessary details are obtained.
This ensures a more efficient and accurate retrieval of car information.
If customer inquires about car with features like towing, off-road capability,
good mileage, or pickup trucks in this case no need to ask about make and model of the car
inquire whether they are interested in a new or used vehicle.
After knowing car feature and new or old car preference use the "details_of_car" tool to answer.
Do not disclose or ask the costumer if he likes to know the selling price of a car,
disclose selling price only when the customer explicitly requests it use "details_of_car" function.
If the customer's query matches a car model, respond with a list of car without square brackets,
including the make, year, model, and trim, and **strictly** provide their respective links in the answer.
When using the 'details_of_car' tool to provide car information, adhere to these guidelines
to ensure concise and non-redundant responses:
1. Prioritize Uniqueness:
Consider cars as unique entities when they differ in any of the following core features:
Model
Make
Year
Trim
Exterior color
Interior color
New/used status
Cars sharing identical values for all of these features are considered similar.
2. Avoid Similar Car Duplication:
Display only one instance of a car if other cars with identical core features are present within the dataset.
This ensures concise responses that highlight distinct vehicles without redundancy.
Example:
If two cars have the same make, model, year, trim, exterior color, interior color, and new/used status,
display only one of them in the response.
checking Appointments Avaliability:
{details} use these details and find appointment date from the users input and check for appointment availabity
using "get_appointment_details" tool for that specific day or date and time.
strictly input to "get_appointment_details" tool should be "mm-dd-yyyy" format.
If the requested date and time for the appointment are unavailable,
suggest alternative times close to the customer's preference.
Additionally, provide this link'[click here](https://app.engagedai.io/engagements/appointment)'it will
take them to a URL where they can schedule or reschedule their appointment themselves.
Appointment Scheduling:
After scheduling an appointment, initiate the conversation to get tradein car and personal details.
**Car Trade-In Inquiry and personal details:**
1. Ask the customer if they have a car for trade-in.
- User: [Response]
2. If the user responds with "Yes" to trade-in, ask for the VIN (Vehicle Identification Number).
- User: [Response]
if the costumer provides the VIN use "get_car_details_from_vin" get the details of the car and
cross check with the costumer.
3. If the user responds with "No" to the VIN, ask for the make, model, and year of the car.
- User: [Response]
**Price Expectation:**
4. Once you have the trade-in car details, ask the customer about their expected price for the trade-in.
- User: [Response]
**Personal Information:**
5. Finally, ask for the customer's personal details if you already know the name dont ask again.
- Contact Number:
- Email Address:
Encourage Dealership Visit: Our goal is to encourage customers to visit the dealership for test drives or
receive product briefings from our team. After providing essential information on the car's make, model,
color, and basic features, kindly invite the customer to schedule an appointment for a test drive or visit us
for a comprehensive product overview by our experts.
Business details: Enquiry regarding google maps location of the store, address of the store, working days and working hours
and contact details use search_business_details tool to get information.
company details:
compant id is 24, location id is 07 and timezone is America/New_York
Strictly Keep responses concise, not exceeding two sentences or 100 words and answers should be interactive.
Respond in a polite US english.
strictly answer only from the provided content dont makeup answers.
**Storing data:**
As a support executive you should collect important information about costumer for future reference.
If the appointment schedule is fixed and you got costumer details name,Contact Number,Email Address.
now its time to store data.
Use this tool "store_appointment_data" to store the data.
If any of the above details missing you can enquire about that"""
details= "Today's date is "+ todays_date +" in mm-dd-yyyy format and todays week day is "+day_of_the_week+"."
name = st.session_state.user_name
dealership_name="Gosch Auto Group"
input_template = template.format(details=details,name=name,dealership_name=dealership_name)
system_message = SystemMessage(content=input_template)
prompt = OpenAIFunctionsAgent.create_prompt(
system_message=system_message,
extra_prompt_messages=[MessagesPlaceholder(variable_name=memory_key)]
)
tools = [tool1,tool2,tool3,get_appointment_details,store_appointment_data]
agent = OpenAIFunctionsAgent(llm=llm, tools=tools, prompt=prompt)
if 'agent_executor' not in st.session_state:
agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True, return_source_documents=True,
return_generated_question=True)
st.session_state.agent_executor = agent_executor
else:
agent_executor = st.session_state.agent_executor
chat_history=[]
response_container = st.container()
container = st.container()
airtable = Airtable(AIRTABLE_BASE_ID, AIRTABLE_TABLE_NAME, api_key=airtable_api_key)
if 'chat_history' not in st.session_state:
st.session_state.chat_history = []
if 'user_name' not in st.session_state:
st.session_state.user_name = None
def save_chat_to_airtable(user_name, user_input, output):
try:
timestamp = datetime.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
airtable.insert(
{
"username": user_name,
"question": user_input,
"answer": output,
"timestamp": timestamp,
}
)
except Exception as e:
st.error(f"An error occurred while saving data to Airtable: {e}")
def conversational_chat(user_input, user_name):
input_with_username = f"{user_name}: {user_input}"
result = agent_executor({"input": input_with_username})
output = result["output"]
st.session_state.chat_history.append((user_input, output))
return output
output = ""
with container:
if st.session_state.user_name is None:
user_name = st.text_input("Your name:")
if user_name:
st.session_state.user_name = user_name
with st.form(key='my_form', clear_on_submit=True):
user_input = st.text_input("Query:", placeholder="Type your question here (:")
submit_button = st.form_submit_button(label='Send')
if submit_button and user_input:
output = conversational_chat(user_input, st.session_state.user_name)
with response_container:
for i, (query, answer) in enumerate(st.session_state.chat_history):
message(query, is_user=True, key=f"{i}_user", avatar_style="thumbs")
col1, col2 = st.columns([0.7, 10])
with col1:
st.image("icon-1024.png", width=50)
with col2:
st.markdown(
f'<div style="background-color: black; color: white; border-radius: 10px; padding: 10px; width: 60%;'
f' border-top-right-radius: 10px; border-bottom-right-radius: 10px;'
f' border-top-left-radius: 0; border-bottom-left-radius: 0; box-shadow: 2px 2px 5px #888888;">'
f'<span style="font-family: Arial, sans-serif; font-size: 16px; white-space: pre-wrap;">{answer}</span>'
f'</div>',
unsafe_allow_html=True
)
if st.session_state.user_name:
try:
save_chat_to_airtable(st.session_state.user_name, user_input, output)
except Exception as e:
st.error(f"An error occurred: {e}")
| [
"langchain.chat_models.ChatOpenAI",
"langchain.agents.AgentExecutor",
"langchain.agents.openai_functions_agent.base.OpenAIFunctionsAgent",
"langchain.schema.messages.SystemMessage",
"langchain.document_loaders.csv_loader.CSVLoader",
"langchain.vectorstores.FAISS.from_documents",
"langchain.embeddings.OpenAIEmbeddings",
"langchain.prompts.MessagesPlaceholder",
"langchain.memory.ConversationBufferMemory",
"langchain.agents.agent_toolkits.create_retriever_tool"
] | [((3412, 3472), 'streamlit.markdown', 'st.markdown', (['hide_share_button_style'], {'unsafe_allow_html': '(True)'}), '(hide_share_button_style, unsafe_allow_html=True)\n', (3423, 3472), True, 'import streamlit as st\n'), ((3474, 3537), 'streamlit.markdown', 'st.markdown', (['hide_star_and_github_style'], {'unsafe_allow_html': '(True)'}), '(hide_star_and_github_style, unsafe_allow_html=True)\n', (3485, 3537), True, 'import streamlit as st\n'), ((3539, 3595), 'streamlit.markdown', 'st.markdown', (['hide_mainmenu_style'], {'unsafe_allow_html': '(True)'}), '(hide_mainmenu_style, unsafe_allow_html=True)\n', (3550, 3595), True, 'import streamlit as st\n'), ((3597, 3660), 'streamlit.markdown', 'st.markdown', (['hide_fork_app_button_style'], {'unsafe_allow_html': '(True)'}), '(hide_fork_app_button_style, unsafe_allow_html=True)\n', (3608, 3660), True, 'import streamlit as st\n'), ((3662, 3700), 'pandas.set_option', 'pd.set_option', (['"""display.max_rows"""', '(100)'], {}), "('display.max_rows', 100)\n", (3675, 3700), True, 'import pandas as pd\n'), ((3702, 3743), 'pandas.set_option', 'pd.set_option', (['"""display.max_columns"""', '(100)'], {}), "('display.max_columns', 100)\n", (3715, 3743), True, 'import pandas as pd\n'), ((3808, 3831), 'streamlit.image', 'st.image', (['"""Twitter.jpg"""'], {}), "('Twitter.jpg')\n", (3816, 3831), True, 'import streamlit as st\n'), ((3835, 3858), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (3856, 3858), False, 'import datetime\n'), ((4575, 4602), 'langchain.document_loaders.csv_loader.CSVLoader', 'CSVLoader', ([], {'file_path': 'file_1'}), '(file_path=file_1)\n', (4584, 4602), False, 'from langchain.document_loaders.csv_loader import CSVLoader\n'), ((4641, 4659), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (4657, 4659), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((4677, 4717), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['docs_1', 'embeddings'], {}), '(docs_1, embeddings)\n', (4697, 4717), False, 'from langchain.vectorstores import FAISS\n'), ((4898, 4925), 'langchain.document_loaders.csv_loader.CSVLoader', 'CSVLoader', ([], {'file_path': 'file_2'}), '(file_path=file_2)\n', (4907, 4925), False, 'from langchain.document_loaders.csv_loader import CSVLoader\n'), ((4987, 5027), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['docs_2', 'embeddings'], {}), '(docs_2, embeddings)\n', (5007, 5027), False, 'from langchain.vectorstores import FAISS\n'), ((5136, 5399), 'langchain.agents.agent_toolkits.create_retriever_tool', 'create_retriever_tool', (['retriever_1', '"""details_of_car"""', '"""use to get car full details and more information. Input to this should be the car\'s model or car features and new or used car as a single argument for example new toeing car or new jeep cherokee"""'], {}), '(retriever_1, \'details_of_car\',\n "use to get car full details and more information. Input to this should be the car\'s model or car features and new or used car as a single argument for example new toeing car or new jeep cherokee"\n )\n', (5157, 5399), False, 'from langchain.agents.agent_toolkits import create_retriever_tool\n'), ((5427, 5558), 'langchain.agents.agent_toolkits.create_retriever_tool', 'create_retriever_tool', (['retriever_2', '"""Availability_check"""', '"""use to check availabilty of car, Input is car make or model or both"""'], {}), "(retriever_2, 'Availability_check',\n 'use to check availabilty of car, Input is car make or model or both')\n", (5448, 5558), False, 'from langchain.agents.agent_toolkits import create_retriever_tool\n'), ((5585, 5756), 'langchain.agents.agent_toolkits.create_retriever_tool', 'create_retriever_tool', (['retriever_3', '"""business_details"""', '"""Searches and returns documents related to business working days and hours, location and address details."""'], {}), "(retriever_3, 'business_details',\n 'Searches and returns documents related to business working days and hours, location and address details.'\n )\n", (5606, 5756), False, 'from langchain.agents.agent_toolkits import create_retriever_tool\n'), ((13925, 14695), 'streamlit.info', 'st.info', (['"""Introducing **Otto**, your cutting-edge partner in streamlining dealership and customer-related operations. At EngagedAi, we specialize in harnessing the power of automation to revolutionize the way dealerships and customers interact. Our advanced solutions seamlessly handle tasks, from managing inventory and customer inquiries to optimizing sales processes, all while enhancing customer satisfaction. Discover a new era of efficiency and convenience with us as your trusted automation ally. [engagedai.io](https://funnelai.com/). For this demo application, we will use the Inventory Dataset. Please explore it [here](https://github.com/buravelliprasad/turbo_6_tools/blob/main/car_desription_new.csv) to get a sense for what questions you can ask."""'], {}), "(\n 'Introducing **Otto**, your cutting-edge partner in streamlining dealership and customer-related operations. At EngagedAi, we specialize in harnessing the power of automation to revolutionize the way dealerships and customers interact. Our advanced solutions seamlessly handle tasks, from managing inventory and customer inquiries to optimizing sales processes, all while enhancing customer satisfaction. Discover a new era of efficiency and convenience with us as your trusted automation ally. [engagedai.io](https://funnelai.com/). For this demo application, we will use the Inventory Dataset. Please explore it [here](https://github.com/buravelliprasad/turbo_6_tools/blob/main/car_desription_new.csv) to get a sense for what questions you can ask.'\n )\n", (13932, 14695), True, 'import streamlit as st\n'), ((15009, 15062), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model': '"""gpt-4-1106-preview"""', 'temperature': '(0)'}), "(model='gpt-4-1106-preview', temperature=0)\n", (15019, 15062), False, 'from langchain.chat_models import ChatOpenAI\n'), ((15128, 15201), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(memory_key='chat_history', return_messages=True)\n", (15152, 15201), False, 'from langchain.memory import ConversationBufferMemory\n'), ((21323, 21360), 'langchain.schema.messages.SystemMessage', 'SystemMessage', ([], {'content': 'input_template'}), '(content=input_template)\n', (21336, 21360), False, 'from langchain.schema.messages import SystemMessage\n'), ((21608, 21665), 'langchain.agents.openai_functions_agent.base.OpenAIFunctionsAgent', 'OpenAIFunctionsAgent', ([], {'llm': 'llm', 'tools': 'tools', 'prompt': 'prompt'}), '(llm=llm, tools=tools, prompt=prompt)\n', (21628, 21665), False, 'from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent\n'), ((22034, 22048), 'streamlit.container', 'st.container', ([], {}), '()\n', (22046, 22048), True, 'import streamlit as st\n'), ((22062, 22076), 'streamlit.container', 'st.container', ([], {}), '()\n', (22074, 22076), True, 'import streamlit as st\n'), ((22089, 22162), 'airtable.Airtable', 'Airtable', (['AIRTABLE_BASE_ID', 'AIRTABLE_TABLE_NAME'], {'api_key': 'airtable_api_key'}), '(AIRTABLE_BASE_ID, AIRTABLE_TABLE_NAME, api_key=airtable_api_key)\n', (22097, 22162), False, 'from airtable import Airtable\n'), ((8012, 8075), 'pydantic.Field', 'Field', (['...'], {'description': '"""VIN of the car to get the car details"""'}), "(..., description='VIN of the car to get the car details')\n", (8017, 8075), False, 'from pydantic import BaseModel, Field\n'), ((8408, 8430), 'requests.get', 'requests.get', (['BASE_URL'], {}), '(BASE_URL)\n', (8420, 8430), False, 'import requests\n'), ((9856, 9923), 'pydantic.Field', 'Field', (['...'], {'description': '"""Date for which to get appointment details"""'}), "(..., description='Date for which to get appointment details')\n", (9861, 9923), False, 'from pydantic import BaseModel, Field\n'), ((10363, 10400), 'requests.post', 'requests.post', (['BASE_URL'], {'json': 'payload'}), '(BASE_URL, json=payload)\n', (10376, 10400), False, 'import requests\n'), ((11295, 11341), 'pydantic.Field', 'Field', (['...'], {'description': '"""name of the customer"""'}), "(..., description='name of the customer')\n", (11300, 11341), False, 'from pydantic import BaseModel, Field\n'), ((11360, 11414), 'pydantic.Field', 'Field', (['...'], {'description': '"""phone number of the customer"""'}), "(..., description='phone number of the customer')\n", (11365, 11414), False, 'from pydantic import BaseModel, Field\n'), ((11433, 11480), 'pydantic.Field', 'Field', (['...'], {'description': '"""email of the customer"""'}), "(..., description='email of the customer')\n", (11438, 11480), False, 'from pydantic import BaseModel, Field\n'), ((11498, 11539), 'pydantic.Field', 'Field', (['...'], {'description': '"""year of the car"""'}), "(..., description='year of the car')\n", (11503, 11539), False, 'from pydantic import BaseModel, Field\n'), ((11558, 11600), 'pydantic.Field', 'Field', (['...'], {'description': '"""model of the car"""'}), "(..., description='model of the car')\n", (11563, 11600), False, 'from pydantic import BaseModel, Field\n'), ((11615, 11660), 'pydantic.Field', 'Field', (['...'], {'description': '"""year of the vehicle"""'}), "(..., description='year of the vehicle')\n", (11620, 11660), False, 'from pydantic import BaseModel, Field\n'), ((11681, 11724), 'pydantic.Field', 'Field', (['...'], {'description': '"""id of the company"""'}), "(..., description='id of the company')\n", (11686, 11724), False, 'from pydantic import BaseModel, Field\n'), ((11746, 11798), 'pydantic.Field', 'Field', (['...'], {'description': '"""location id of the company"""'}), "(..., description='location id of the company')\n", (11751, 11798), False, 'from pydantic import BaseModel, Field\n'), ((11819, 11864), 'pydantic.Field', 'Field', (['...'], {'description': '"""date of appointment"""'}), "(..., description='date of appointment')\n", (11824, 11864), False, 'from pydantic import BaseModel, Field\n'), ((11895, 11930), 'pydantic.Field', 'Field', (['...'], {'description': '"""time zone"""'}), "(..., description='time zone')\n", (11900, 11930), False, 'from pydantic import BaseModel, Field\n'), ((11947, 11988), 'pydantic.Field', 'Field', (['...'], {'description': '"""costumer intent"""'}), "(..., description='costumer intent')\n", (11952, 11988), False, 'from pydantic import BaseModel, Field\n'), ((12006, 12070), 'pydantic.Field', 'Field', (['...'], {'description': '"""one line about summary of appointment,"""'}), "(..., description='one line about summary of appointment,')\n", (12011, 12070), False, 'from pydantic import BaseModel, Field\n'), ((12092, 12157), 'pydantic.Field', 'Field', (['...'], {'description': '"""one line about description about visit,"""'}), "(..., description='one line about description about visit,')\n", (12097, 12157), False, 'from pydantic import BaseModel, Field\n'), ((13401, 13439), 'requests.post', 'requests.post', (['api_url'], {'json': 'data_dict'}), '(api_url, json=data_dict)\n', (13414, 13439), False, 'import requests\n'), ((21734, 21868), 'langchain.agents.AgentExecutor', 'AgentExecutor', ([], {'agent': 'agent', 'tools': 'tools', 'memory': 'memory', 'verbose': '(True)', 'return_source_documents': '(True)', 'return_generated_question': '(True)'}), '(agent=agent, tools=tools, memory=memory, verbose=True,\n return_source_documents=True, return_generated_question=True)\n', (21747, 21868), False, 'from langchain.agents import AgentExecutor\n'), ((23017, 23075), 'streamlit.session_state.chat_history.append', 'st.session_state.chat_history.append', (['(user_input, output)'], {}), '((user_input, output))\n', (23053, 23075), True, 'import streamlit as st\n'), ((3875, 3896), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (3894, 3896), False, 'import datetime\n'), ((3933, 3954), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (3952, 3954), False, 'import datetime\n'), ((23196, 23223), 'streamlit.text_input', 'st.text_input', (['"""Your name:"""'], {}), "('Your name:')\n", (23209, 23223), True, 'import streamlit as st\n'), ((23311, 23355), 'streamlit.form', 'st.form', ([], {'key': '"""my_form"""', 'clear_on_submit': '(True)'}), "(key='my_form', clear_on_submit=True)\n", (23318, 23355), True, 'import streamlit as st\n'), ((23379, 23444), 'streamlit.text_input', 'st.text_input', (['"""Query:"""'], {'placeholder': '"""Type your question here (:"""'}), "('Query:', placeholder='Type your question here (:')\n", (23392, 23444), True, 'import streamlit as st\n'), ((23470, 23505), 'streamlit.form_submit_button', 'st.form_submit_button', ([], {'label': '"""Send"""'}), "(label='Send')\n", (23491, 23505), True, 'import streamlit as st\n'), ((4499, 4517), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (4515, 4517), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((21473, 21518), 'langchain.prompts.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': 'memory_key'}), '(variable_name=memory_key)\n', (21492, 21518), False, 'from langchain.prompts import MessagesPlaceholder\n'), ((22745, 22810), 'streamlit.error', 'st.error', (['f"""An error occurred while saving data to Airtable: {e}"""'], {}), "(f'An error occurred while saving data to Airtable: {e}')\n", (22753, 22810), True, 'import streamlit as st\n'), ((23744, 23812), 'streamlit_chat.message', 'message', (['query'], {'is_user': '(True)', 'key': 'f"""{i}_user"""', 'avatar_style': '"""thumbs"""'}), "(query, is_user=True, key=f'{i}_user', avatar_style='thumbs')\n", (23751, 23812), False, 'from streamlit_chat import message\n'), ((23839, 23860), 'streamlit.columns', 'st.columns', (['[0.7, 10]'], {}), '([0.7, 10])\n', (23849, 23860), True, 'import streamlit as st\n'), ((22427, 22453), 'datetime.datetime.utcnow', 'datetime.datetime.utcnow', ([], {}), '()\n', (22451, 22453), False, 'import datetime\n'), ((23903, 23938), 'streamlit.image', 'st.image', (['"""icon-1024.png"""'], {'width': '(50)'}), "('icon-1024.png', width=50)\n", (23911, 23938), True, 'import streamlit as st\n'), ((23980, 24392), 'streamlit.markdown', 'st.markdown', (['f"""<div style="background-color: black; color: white; border-radius: 10px; padding: 10px; width: 60%; border-top-right-radius: 10px; border-bottom-right-radius: 10px; border-top-left-radius: 0; border-bottom-left-radius: 0; box-shadow: 2px 2px 5px #888888;"><span style="font-family: Arial, sans-serif; font-size: 16px; white-space: pre-wrap;">{answer}</span></div>"""'], {'unsafe_allow_html': '(True)'}), '(\n f\'<div style="background-color: black; color: white; border-radius: 10px; padding: 10px; width: 60%; border-top-right-radius: 10px; border-bottom-right-radius: 10px; border-top-left-radius: 0; border-bottom-left-radius: 0; box-shadow: 2px 2px 5px #888888;"><span style="font-family: Arial, sans-serif; font-size: 16px; white-space: pre-wrap;">{answer}</span></div>\'\n , unsafe_allow_html=True)\n', (23991, 24392), True, 'import streamlit as st\n'), ((24716, 24751), 'streamlit.error', 'st.error', (['f"""An error occurred: {e}"""'], {}), "(f'An error occurred: {e}')\n", (24724, 24751), True, 'import streamlit as st\n')] |
import streamlit as st
import openai
import langchain
# from langchain import PromptTemplate, LLMChain
# from langchain.llms import OpenAI
# # Set your OpenAI API key
# openai_api_key = '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'
# # Create a sidebar for language selection
# st.sidebar.title('Translation App')
# input_language = st.sidebar.selectbox('Input Language', ['English', 'Spanish', 'French', 'German'])
# output_language = st.sidebar.selectbox('Output Language', ['English', 'Spanish', 'French', 'German'])
# # Create a text area for user input
# user_input = st.text_area("Enter text here", "")
# # Define your prompt template
# template = "Translate the following text from {input_language} to {output_language}: {text}"
# prompt_template = PromptTemplate(
# template=template,
# input_variables=["input_language", "output_language", "text"]
# )
# # Define your language model
# llm = OpenAI(api_key=openai_api_key, temperature=0)
# # Define your LLMChain
# llm_chain = LLMChain(llm=llm, prompt=prompt_template)
# # Translate the text when the 'Translate' button is clicked
# if st.button('Translate'):
# # Use LangChain for translation
# translation = llm_chain.run({
# "input_language": input_language,
# "output_language": output_language,
# "text": user_input
# })
# # Display the translation
# st.write(f'Translation: {translation}')
# from langchain import PromptTemplate, LLMChain
# from langchain.llms import OpenAI
# import os
# # Create a sidebar for language selection
# st.sidebar.title('Translation App')
# input_language = st.sidebar.selectbox('Input Language', ['English', 'Spanish', 'French', 'German'])
# output_language = st.sidebar.selectbox('Output Language', ['English', 'Spanish', 'French', 'German'])
# # Create a text input for the user to enter their OpenAI API key
# openai_api_key = st.sidebar.text_input("Enter your OpenAI API key here", "")
# # Set the OpenAI API key as an environment variable
# os.environ["OPENAI_API_KEY"] = openai_api_key
# # Create a text area for user input
# user_input = st.text_area("Enter text here", "")
# # Define your prompt template
# template = "Translate the following text from {input_language} to {output_language}: {text}"
# prompt_template = PromptTemplate(
# template=template,
# input_variables=["input_language", "output_language", "text"]
# )
# # Define your language model
# llm = OpenAI(api_key=os.environ["OPENAI_API_KEY"], temperature=0)
# # Define your LLMChain
# llm_chain = LLMChain(llm=llm, prompt=prompt_template)
# # Translate the text when the 'Translate' button is clicked
# if st.button('Translate'):
# # Use LangChain for translation
# translation = llm_chain.run({
# "input_language": input_language,
# "output_language": output_language,
# "text": user_input
# })
# # Display the translation
# st.write(f'Translation: {translation}')
from langchain import PromptTemplate, LLMChain
from langchain.llms import OpenAI
import os
# Create a sidebar for language selection
st.sidebar.title('Translation App')
languages = ['English', 'Spanish', 'French', 'German', 'Other']
input_language = st.sidebar.selectbox('Input Language', languages)
output_language = st.sidebar.selectbox('Output Language', languages)
# If 'Other' is selected, display a text input field
if input_language == 'Other':
input_language = st.sidebar.text_input("Enter your input language", "")
if output_language == 'Other':
output_language = st.sidebar.text_input("Enter your output language", "")
# Create a text input for the user to enter their OpenAI API key
# Set the OpenAI API key as an environment variable
os.environ["OPENAI_API_KEY"] = openai_api_key
# Create a text area for user input
user_input = st.text_area("Enter text here", "", max_chars=600)
if openai_api_key and input_language and output_language and user_input:
# Define your prompt template
template = "Translate the following text from {input_language} to {output_language}: {text}"
prompt_template = PromptTemplate(
template=template,
input_variables=["input_language", "output_language", "text"]
)
# Define your language model
llm = OpenAI(api_key=os.environ["OPENAI_API_KEY"], temperature=0)
# Define your LLMChain
llm_chain = LLMChain(llm=llm, prompt=prompt_template)
# Translate the text when the 'Translate' button is clicked
if st.button('Translate'):
# Use LangChain for translation
translation = llm_chain.run({
"input_language": input_language,
"output_language": output_language,
"text": user_input
})
# Display the translation
st.write(f'Translation: {translation}')
else:
st.write("Please enter all required information.")
| [
"langchain.llms.OpenAI",
"langchain.LLMChain",
"langchain.PromptTemplate"
] | [((3099, 3134), 'streamlit.sidebar.title', 'st.sidebar.title', (['"""Translation App"""'], {}), "('Translation App')\n", (3115, 3134), True, 'import streamlit as st\n'), ((3216, 3265), 'streamlit.sidebar.selectbox', 'st.sidebar.selectbox', (['"""Input Language"""', 'languages'], {}), "('Input Language', languages)\n", (3236, 3265), True, 'import streamlit as st\n'), ((3284, 3334), 'streamlit.sidebar.selectbox', 'st.sidebar.selectbox', (['"""Output Language"""', 'languages'], {}), "('Output Language', languages)\n", (3304, 3334), True, 'import streamlit as st\n'), ((3819, 3869), 'streamlit.text_area', 'st.text_area', (['"""Enter text here"""', '""""""'], {'max_chars': '(600)'}), "('Enter text here', '', max_chars=600)\n", (3831, 3869), True, 'import streamlit as st\n'), ((3440, 3494), 'streamlit.sidebar.text_input', 'st.sidebar.text_input', (['"""Enter your input language"""', '""""""'], {}), "('Enter your input language', '')\n", (3461, 3494), True, 'import streamlit as st\n'), ((3548, 3603), 'streamlit.sidebar.text_input', 'st.sidebar.text_input', (['"""Enter your output language"""', '""""""'], {}), "('Enter your output language', '')\n", (3569, 3603), True, 'import streamlit as st\n'), ((4097, 4197), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'template': 'template', 'input_variables': "['input_language', 'output_language', 'text']"}), "(template=template, input_variables=['input_language',\n 'output_language', 'text'])\n", (4111, 4197), False, 'from langchain import PromptTemplate, LLMChain\n'), ((4260, 4319), 'langchain.llms.OpenAI', 'OpenAI', ([], {'api_key': "os.environ['OPENAI_API_KEY']", 'temperature': '(0)'}), "(api_key=os.environ['OPENAI_API_KEY'], temperature=0)\n", (4266, 4319), False, 'from langchain.llms import OpenAI\n'), ((4364, 4405), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt_template'}), '(llm=llm, prompt=prompt_template)\n', (4372, 4405), False, 'from langchain import PromptTemplate, LLMChain\n'), ((4478, 4500), 'streamlit.button', 'st.button', (['"""Translate"""'], {}), "('Translate')\n", (4487, 4500), True, 'import streamlit as st\n'), ((4817, 4867), 'streamlit.write', 'st.write', (['"""Please enter all required information."""'], {}), "('Please enter all required information.')\n", (4825, 4867), True, 'import streamlit as st\n'), ((4767, 4806), 'streamlit.write', 'st.write', (['f"""Translation: {translation}"""'], {}), "(f'Translation: {translation}')\n", (4775, 4806), True, 'import streamlit as st\n')] |
import langchain.llms
from langchain import GoogleSearchAPIWrapper, LLMChain
from langchain.agents import initialize_agent, AgentType, Tool, ZeroShotAgent, AgentExecutor
from langchain.schema import BaseMemory
def setup_agent(llm: langchain.llms.BaseLLM, memory: BaseMemory):
search = GoogleSearchAPIWrapper()
tools = [
Tool(
name="Google Search",
func=search.run,
description="Useful for when you need to answer questions about current events, the current state of the world or what you don't know."
),
]
prefix = """Answer the following questions as best you can. You have access to the following tools:"""
suffix = """Begin! Use lots of tools, and please answer finally in Japanese.
Question: {input}
{agent_scratchpad}"""
prompt = ZeroShotAgent.create_prompt(
tools,
prefix=prefix,
suffix=suffix,
input_variables=["input", "agent_scratchpad"]
)
llm_chain = LLMChain(
llm=llm,
prompt=prompt)
agent = ZeroShotAgent(
llm_chain=llm_chain,
tools=tools,
memory=memory)
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
verbose=True)
return agent_executor
| [
"langchain.agents.AgentExecutor.from_agent_and_tools",
"langchain.GoogleSearchAPIWrapper",
"langchain.agents.ZeroShotAgent",
"langchain.LLMChain",
"langchain.agents.ZeroShotAgent.create_prompt",
"langchain.agents.Tool"
] | [((291, 315), 'langchain.GoogleSearchAPIWrapper', 'GoogleSearchAPIWrapper', ([], {}), '()\n', (313, 315), False, 'from langchain import GoogleSearchAPIWrapper, LLMChain\n'), ((833, 948), 'langchain.agents.ZeroShotAgent.create_prompt', 'ZeroShotAgent.create_prompt', (['tools'], {'prefix': 'prefix', 'suffix': 'suffix', 'input_variables': "['input', 'agent_scratchpad']"}), "(tools, prefix=prefix, suffix=suffix,\n input_variables=['input', 'agent_scratchpad'])\n", (860, 948), False, 'from langchain.agents import initialize_agent, AgentType, Tool, ZeroShotAgent, AgentExecutor\n'), ((1000, 1032), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (1008, 1032), False, 'from langchain import GoogleSearchAPIWrapper, LLMChain\n'), ((1062, 1124), 'langchain.agents.ZeroShotAgent', 'ZeroShotAgent', ([], {'llm_chain': 'llm_chain', 'tools': 'tools', 'memory': 'memory'}), '(llm_chain=llm_chain, tools=tools, memory=memory)\n', (1075, 1124), False, 'from langchain.agents import initialize_agent, AgentType, Tool, ZeroShotAgent, AgentExecutor\n'), ((1171, 1245), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'agent', 'tools': 'tools', 'verbose': '(True)'}), '(agent=agent, tools=tools, verbose=True)\n', (1205, 1245), False, 'from langchain.agents import initialize_agent, AgentType, Tool, ZeroShotAgent, AgentExecutor\n'), ((339, 529), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""Google Search"""', 'func': 'search.run', 'description': '"""Useful for when you need to answer questions about current events, the current state of the world or what you don\'t know."""'}), '(name=\'Google Search\', func=search.run, description=\n "Useful for when you need to answer questions about current events, the current state of the world or what you don\'t know."\n )\n', (343, 529), False, 'from langchain.agents import initialize_agent, AgentType, Tool, ZeroShotAgent, AgentExecutor\n')] |
import itertools
from langchain.cache import InMemoryCache, SQLiteCache
import langchain
import pandas as pd
from certa.utils import merge_sources
from certa.explain import CertaExplainer
from datetime import datetime
import os
import ellmer.models
import ellmer.metrics
from time import sleep, time
import json
import traceback
from tqdm import tqdm
import argparse
def eval(cache, samples, num_triangles, explanation_granularity, quantitative, base_dir, dataset_names, model_type,
model_name, deployment_name, tag, temperature):
if cache == "memory":
langchain.llm_cache = InMemoryCache()
elif cache == "sqlite":
langchain.llm_cache = SQLiteCache(database_path=".langchain.db")
llm_config = {"model_type": model_type, "model_name": model_name, "deployment_name": deployment_name, "tag": tag}
pase = ellmer.models.GenericEllmer(explanation_granularity=explanation_granularity,
deployment_name=llm_config['deployment_name'], temperature=temperature,
model_name=llm_config['model_name'], model_type=llm_config['model_type'],
prompts={"pase": "ellmer/prompts/constrained13.txt"})
ptse = ellmer.models.GenericEllmer(explanation_granularity=explanation_granularity,
deployment_name=llm_config['deployment_name'], temperature=temperature,
model_name=llm_config['model_name'], model_type=llm_config['model_type'],
prompts={"ptse": {"er": "ellmer/prompts/er.txt",
"saliency": "ellmer/prompts/er-saliency-lc.txt",
"cf": "ellmer/prompts/er-cf-lc.txt"}})
ptsew = ellmer.models.GenericEllmer(explanation_granularity=explanation_granularity,
deployment_name=llm_config['deployment_name'], temperature=temperature,
model_name=llm_config['model_name'], model_type=llm_config['model_type'],
prompts={
"ptse": {"er": "ellmer/prompts/er.txt",
"why": "ellmer/prompts/er-why.txt",
"saliency": "ellmer/prompts/er-saliency-lc.txt",
"cf": "ellmer/prompts/er-cf-lc.txt"}})
ptn = ellmer.models.GenericEllmer(explanation_granularity=explanation_granularity,
deployment_name=llm_config['deployment_name'], temperature=temperature,
model_name=llm_config['model_name'], model_type=llm_config['model_type'],
prompts={"ptse": {"er": "ellmer/prompts/er.txt"}})
for d in dataset_names:
expdir = f'./experiments/{model_type}/{model_name}/{explanation_granularity}/{d}/{datetime.now():%Y%m%d}/{datetime.now():%H_%M}/'
obs_dir = f'experiments/{model_type}/{model_name}/{explanation_granularity}/concordance/{d}//{datetime.now():%Y%m%d}/{datetime.now():%H_%M}'
print(f'using dataset {d}')
dataset_dir = '/'.join([base_dir, d])
lsource = pd.read_csv(dataset_dir + '/tableA.csv')
rsource = pd.read_csv(dataset_dir + '/tableB.csv')
test = pd.read_csv(dataset_dir + '/test.csv')
test_df = merge_sources(test, 'ltable_', 'rtable_', lsource, rsource, ['label'],
[])
certa = CertaExplainer(lsource, rsource)
ellmers = {
"pase_" + llm_config['tag']: pase,
"ptse_" + llm_config['tag']: ptse,
"ptsew_" + llm_config['tag']: ptsew,
"certa(ptse)_" + llm_config['tag']: ellmer.models.CertaEllmer(explanation_granularity, ptn, certa,
num_triangles),
"certa(pase)_" + llm_config['tag']: ellmer.models.CertaEllmer(explanation_granularity, pase, certa,
num_triangles),
"uncerta(pase)_" + llm_config['tag']: ellmer.models.UnCertaEllmer(explanation_granularity, pase, certa,
[pase, ptse, ptsew],
num_triangles=num_triangles),
"uncerta(ptse)_" + llm_config['tag']: ellmer.models.UnCertaEllmer(explanation_granularity, ptse, certa,
[pase, ptse, ptsew],
num_triangles=num_triangles),
}
result_files = []
for key, llm in ellmers.items():
print(f'{key} on {d}')
curr_llm_results = []
start_time = time()
# generate predictions and explanations
test_data_df = test_df[:samples]
ranged = range(len(test_data_df))
for idx in tqdm(ranged, disable=False):
try:
rand_row = test_df.iloc[[idx]]
ltuple, rtuple = ellmer.utils.get_tuples(rand_row)
ptime = time()
answer_dictionary = llm.predict_and_explain(ltuple, rtuple)
ptime = time() - ptime
prediction = answer_dictionary['prediction']
saliency = answer_dictionary['saliency']
cfs = [answer_dictionary['cf']]
row_dict = {"id": idx, "ltuple": ltuple, "rtuple": rtuple, "prediction": prediction,
"label": rand_row['label'].values[0], "saliency": saliency, "cfs": cfs,
"latency": ptime}
if "filter_features" in answer_dictionary:
row_dict["filter_features"] = answer_dictionary["filter_features"]
curr_llm_results.append(row_dict)
except Exception:
traceback.print_exc()
print(f'error, waiting...')
sleep(10)
start_time += 10
total_time = time() - start_time
os.makedirs(expdir, exist_ok=True)
llm_results = {"data": curr_llm_results, "total_time": total_time}
output_file_path = expdir + key + '_results.json'
with open(output_file_path, 'w') as fout:
json.dump(llm_results, fout)
if quantitative:
# generate quantitative explainability metrics for each set of generated explanations
# generate saliency metrics
faithfulness = ellmer.metrics.get_faithfulness([key], llm.evaluation, expdir, test_data_df)
print(f'{key} faithfulness({key}):{faithfulness}')
# generate counterfactual metrics
cf_metrics = ellmer.metrics.get_cf_metrics([key], llm.predict, expdir, test_data_df)
print(f'{key} cf_metrics({key}):{cf_metrics}')
metrics_results = {"faithfulness": faithfulness, "counterfactual_metrics": cf_metrics}
llm_results = {"data": curr_llm_results, "total_time": total_time, "metrics": metrics_results, "tokens": llm.count_tokens()/samples, "predictions":llm.count_predictions()/samples}
output_file_path = expdir + key + '_results.json'
with open(output_file_path, 'w') as fout:
json.dump(llm_results, fout)
result_files.append((key, output_file_path))
print(f'{key} data generated in {total_time}s')
# generate concordance statistics for each pair of results
for pair in itertools.combinations(result_files, 2):
p1 = pair[0]
p1_name = p1[0]
p1_file = p1[1]
p2 = pair[1]
p2_name = p2[0]
p2_file = p2[1]
print(f'concordance statistics for {p1_name} - {p2_name}')
observations = ellmer.metrics.get_concordance(p1_file, p2_file)
print(f'{observations}')
os.makedirs(obs_dir, exist_ok=True)
observations.to_csv(f'{obs_dir}/{p1_name}_{p2_name}.csv')
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Run saliency experiments.')
parser.add_argument('--base_dir', metavar='b', type=str, help='the datasets base directory',
required=True)
parser.add_argument('--model_type', metavar='m', type=str, help='the LLM type to evaluate',
choices=['azure_openai', 'falcon', 'llama2', 'hf'], required=True)
parser.add_argument('--datasets', metavar='d', type=str, nargs='+', required=True,
help='the dataset(s) to be used for the evaluation')
parser.add_argument('--samples', metavar='s', type=int, default=-1,
help='no. of samples from the test set used for the evaluation')
parser.add_argument('--cache', metavar='c', type=str, choices=['', 'sqlite', 'memory'], default='',
help='LLM prediction caching mechanism')
parser.add_argument('--num_triangles', metavar='t', type=int, default=10,
help='no. of open triangles used to generate CERTA explanations')
parser.add_argument('--granularity', metavar='tk', type=str, default='attribute',
choices=['attribute', 'token'], help='explanation granularity')
parser.add_argument('--quantitative', metavar='q', type=bool, default=True,
help='whether to generate quantitative explanation evaluation results')
parser.add_argument('--model_name', metavar='mn', type=str, help='model name/identifier',
default="gpt-3.5-turbo")
parser.add_argument('--deployment_name', metavar='dn', type=str, help='deployment name',
default="gpt-35-turbo")
parser.add_argument('--tag', metavar='tg', type=str, help='run tag', default="run tag")
parser.add_argument('--temperature', metavar='tp', type=float, help='LLM temperature', default=0.01)
args = parser.parse_args()
base_datadir = args.base_dir
samples = args.samples
num_triangles = args.num_triangles
temperature = args.temperature
cache = args.cache
explanation_granularity = args.granularity
quantitative = args.quantitative
dataset_names = args.datasets
base_dir = args.base_dir
model_type = args.model_type
model_name = args.model_name
deployment_name = args.deployment_name
tag = args.tag
eval(cache, samples, num_triangles, explanation_granularity, quantitative, base_dir, dataset_names, model_type,
model_name, deployment_name, tag, temperature)
| [
"langchain.cache.SQLiteCache",
"langchain.cache.InMemoryCache"
] | [((8572, 8636), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Run saliency experiments."""'}), "(description='Run saliency experiments.')\n", (8595, 8636), False, 'import argparse\n'), ((598, 613), 'langchain.cache.InMemoryCache', 'InMemoryCache', ([], {}), '()\n', (611, 613), False, 'from langchain.cache import InMemoryCache, SQLiteCache\n'), ((3392, 3432), 'pandas.read_csv', 'pd.read_csv', (["(dataset_dir + '/tableA.csv')"], {}), "(dataset_dir + '/tableA.csv')\n", (3403, 3432), True, 'import pandas as pd\n'), ((3451, 3491), 'pandas.read_csv', 'pd.read_csv', (["(dataset_dir + '/tableB.csv')"], {}), "(dataset_dir + '/tableB.csv')\n", (3462, 3491), True, 'import pandas as pd\n'), ((3507, 3545), 'pandas.read_csv', 'pd.read_csv', (["(dataset_dir + '/test.csv')"], {}), "(dataset_dir + '/test.csv')\n", (3518, 3545), True, 'import pandas as pd\n'), ((3564, 3638), 'certa.utils.merge_sources', 'merge_sources', (['test', '"""ltable_"""', '"""rtable_"""', 'lsource', 'rsource', "['label']", '[]'], {}), "(test, 'ltable_', 'rtable_', lsource, rsource, ['label'], [])\n", (3577, 3638), False, 'from certa.utils import merge_sources\n'), ((3688, 3720), 'certa.explain.CertaExplainer', 'CertaExplainer', (['lsource', 'rsource'], {}), '(lsource, rsource)\n', (3702, 3720), False, 'from certa.explain import CertaExplainer\n'), ((8025, 8064), 'itertools.combinations', 'itertools.combinations', (['result_files', '(2)'], {}), '(result_files, 2)\n', (8047, 8064), False, 'import itertools\n'), ((672, 714), 'langchain.cache.SQLiteCache', 'SQLiteCache', ([], {'database_path': '""".langchain.db"""'}), "(database_path='.langchain.db')\n", (683, 714), False, 'from langchain.cache import InMemoryCache, SQLiteCache\n'), ((5106, 5112), 'time.time', 'time', ([], {}), '()\n', (5110, 5112), False, 'from time import sleep, time\n'), ((5280, 5307), 'tqdm.tqdm', 'tqdm', (['ranged'], {'disable': '(False)'}), '(ranged, disable=False)\n', (5284, 5307), False, 'from tqdm import tqdm\n'), ((6501, 6535), 'os.makedirs', 'os.makedirs', (['expdir'], {'exist_ok': '(True)'}), '(expdir, exist_ok=True)\n', (6512, 6535), False, 'import os\n'), ((8424, 8459), 'os.makedirs', 'os.makedirs', (['obs_dir'], {'exist_ok': '(True)'}), '(obs_dir, exist_ok=True)\n', (8435, 8459), False, 'import os\n'), ((3094, 3108), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3106, 3108), False, 'from datetime import datetime\n'), ((3118, 3132), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3130, 3132), False, 'from datetime import datetime\n'), ((3244, 3258), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3256, 3258), False, 'from datetime import datetime\n'), ((3268, 3282), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3280, 3282), False, 'from datetime import datetime\n'), ((6468, 6474), 'time.time', 'time', ([], {}), '()\n', (6472, 6474), False, 'from time import sleep, time\n'), ((6748, 6776), 'json.dump', 'json.dump', (['llm_results', 'fout'], {}), '(llm_results, fout)\n', (6757, 6776), False, 'import json\n'), ((5480, 5486), 'time.time', 'time', ([], {}), '()\n', (5484, 5486), False, 'from time import sleep, time\n'), ((7790, 7818), 'json.dump', 'json.dump', (['llm_results', 'fout'], {}), '(llm_results, fout)\n', (7799, 7818), False, 'import json\n'), ((5595, 5601), 'time.time', 'time', ([], {}), '()\n', (5599, 5601), False, 'from time import sleep, time\n'), ((6305, 6326), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (6324, 6326), False, 'import traceback\n'), ((6395, 6404), 'time.sleep', 'sleep', (['(10)'], {}), '(10)\n', (6400, 6404), False, 'from time import sleep, time\n')] |
# Databricks notebook source
# MAGIC %md
# MAGIC # 3. Chatbotの作成とデプロイ
# MAGIC
# MAGIC <br/>
# MAGIC <img src="https://github.com/naoyaabe-db/public_demo_images/blob/3380b6d73937cd95efae845799c37de910b7394c/rag_demo_images/diagram_notebook3.png?raw=true" style="float: right" width="1000px">
# MAGIC <br/>
# MAGIC
# MAGIC ### このNotebookの流れ
# MAGIC このNotebookでは、OpenAIのチャットモデルと前のNotebookで作成したVector Search Indexを組み合わせて、RAGを使用したChatbotを完成させます。<br/><br/>
# MAGIC
# MAGIC 1. 必要なライブラリのインストール
# MAGIC 2. コンフィグ（自身の環境に合わせた各種パラメータの指定）
# MAGIC 3. カタログとスキーマのアクセス権限付与
# MAGIC 4. Vector Search Indexへの権限付与
# MAGIC 5. LangChain Retriever の作成
# MAGIC 6. Chatで使用するOpenAIモデルをエンドポイントとしてデプロイ
# MAGIC 7. RAG Chainを作成する
# MAGIC 8. 作成したRAGチェーンをMLFlowモデルレジストリへ登録する
# MAGIC 9. RAGチェーンをモデルサービングエンドポイントにデプロイする
# MAGIC
# MAGIC ### このNotebookで出てくる主な機能・技術
# MAGIC このNotebookでは、以下の解説されている機能・技術を使用しています。より詳細を調べたい場合は各リンク先のドキュメントをご覧ください。<br/><br/>
# MAGIC
# MAGIC - Unity Catalogによる各オブジェクトの権限管理 [(Databricks公式ドキュメント)](https://docs.databricks.com/ja/data-governance/unity-catalog/manage-privileges/privileges.html)
# MAGIC - ノートブック上でのシークレットの使用 [(Databricks公式ドキュメント)](https://docs.databricks.com/ja/security/secrets/example-secret-workflow.html#use-the-secrets-in-a-notebook)
# MAGIC - 外部モデルのモデルサービングエンドポイント [(Databricks公式ドキュメント)](https://docs.databricks.com/ja/generative-ai/external-models/external-models-tutorial.html)
# MAGIC - LangChainのDatabricks Vector Searchインテグレーション [(LangChain APIリファレンス)](https://api.python.langchain.com/en/latest/vectorstores/langchain_community.vectorstores.databricks_vector_search.DatabricksVectorSearch.html)
# MAGIC - LangChain RetrievalQAチェーン [(LangChain APIリファレンス)](https://api.python.langchain.com/en/stable/chains/langchain.chains.retrieval_qa.base.RetrievalQA.html)
# MAGIC - MLFlowのLangChainインテグレーション [(MLFlow公式ドキュメント)](https://mlflow.org/docs/latest/python_api/mlflow.langchain.html)
# MAGIC
# MAGIC
# MAGIC ### このNotebookの動作環境
# MAGIC Databricks Runtime Version 14.2 ML のクラスター
# COMMAND ----------
# MAGIC %md
# MAGIC ## 必要なライブラリのインストール
# COMMAND ----------
# MAGIC %pip install databricks-vectorsearch mlflow[genai]>=2.9.0 langchain==0.0.344 databricks-sdk==0.12.0
# MAGIC dbutils.library.restartPython()
# COMMAND ----------
# MAGIC %md
# MAGIC ## コンフィグのロード
# MAGIC #### 別のNotebook `config` の中の変数名を自身の環境用に書き換えてから下記を実行してください。
# COMMAND ----------
# MAGIC %run ./config
# COMMAND ----------
# MAGIC %md
# MAGIC ## カタログとスキーマのアクセス権限の付与
# COMMAND ----------
spark.sql(f'GRANT USAGE ON CATALOG {catalog_name} TO `{sp_name}`');
spark.sql(f'GRANT USAGE ON DATABASE {catalog_name}.{schema_name} TO `{sp_name}`');
# COMMAND ----------
# MAGIC %md
# MAGIC ## Vector Search Indexへの権限付与
# MAGIC 以下の手順で、GUIからVector Search Indexへの権限付与を行う。<br/><br/>
# MAGIC 1. 左のメインメニューから`Catalog`を選択
# MAGIC 2. Catalog Explorer内で自身が作成したVector Search Indexの画面まで行く
# MAGIC 3. `Permission`タブを開き、`GRANT`ボタンを押す
# MAGIC <br/>
# MAGIC <img src="https://github.com/naoyaabe-db/public_demo_images/blob/f0bfafc1d892a93c6397bc279c1c0779f7bf4275/rag_demo_images/find_vs_index.png?raw=true" style="float: right" width="600px">
# MAGIC <br/>
# MAGIC 4. 管理者から提供されるService Principalに対して、`SELECT`権限を付与する
# MAGIC <br/>
# MAGIC <img src="https://github.com/naoyaabe-db/public_demo_images/blob/c59e134528fb56d7bcd762d73fe5167a3cf2ff82/rag_demo_images/vector_index_permission.png?raw=true" style="float: right" width="600px">
# COMMAND ----------
import os
host = "https://" + spark.conf.get("spark.databricks.workspaceUrl")
os.environ['DATABRICKS_TOKEN'] = dbutils.secrets.get(f"{scope_name}", f"{secret_name}")
os.environ['OPENAI_API_KEY'] = dbutils.secrets.get(f"{openai_scope_name}", f"{openai_secret_name}")
# COMMAND ----------
# MAGIC %md
# MAGIC ## 埋め込みモデルのサービングエンドポイントに対する権限付与
# MAGIC 以下の手順で、GUIから埋め込みモデルのサービングエンドポイントへの権限付与を行う。<br/><br/>
# MAGIC 1. 左のメインメニューから`Serving`を選択
# MAGIC 2. エンドポイントの一覧から、前のNotebook「02_Vector Search Indexの構築」で自身が作成した埋め込みモデルのサービングエンドポイントを開く
# MAGIC <br/>
# MAGIC <img src="https://github.com/naoyaabe-db/public_demo_images/blob/9a0bb53524ec7009fe6167287b11431f223f17fb/rag_demo_images/model_serving_endpoint_list.png?raw=true" style="float: right" width="600px">
# MAGIC <br/>
# MAGIC 3. 画面右上の`Permission`ボタンから権限設定の画面を開き、Service Principalに対して`Can Manage`権限を付与する
# MAGIC <br/>
# MAGIC <img src="https://github.com/naoyaabe-db/public_demo_images/blob/9a0bb53524ec7009fe6167287b11431f223f17fb/rag_demo_images/model_serving_endpoint_permission.png?raw=true" style="float: right" width="600px">
# COMMAND ----------
# MAGIC %md
# MAGIC ## LangChain Retriever の作成
# COMMAND ----------
from databricks.vector_search.client import VectorSearchClient
from langchain.vectorstores import DatabricksVectorSearch
def get_retriever(persist_dir: str = None):
# Vector Search Client の作成
vsc = VectorSearchClient(workspace_url=host, personal_access_token=os.environ["DATABRICKS_TOKEN"])
# 作成したVector Search Indexをロード
vs_index = vsc.get_index(
endpoint_name=vector_search_endpoint_name,
index_name=f"{catalog_name}.{schema_name}.{index_name}"
)
# LangChainのvectorstoresオブジェクトにする
vectorstore = DatabricksVectorSearch(vs_index)
return vectorstore.as_retriever()
vectorstore_ret = get_retriever()
# COMMAND ----------
# Retrieverのテスト
similar_documents = vectorstore_ret.get_relevant_documents("顧客情報の用途は？")
print(f"Relevant documents: {similar_documents[0]}")
# COMMAND ----------
# MAGIC %md
# MAGIC ## Chatで使用するOpenAIモデルをエンドポイントとしてデプロイ
# MAGIC
# MAGIC #### このサンプルではOpenAIを使用していますが、Azure OpenAIを使用する場合は以下のドキュメントに従ってコードを変更してください
# MAGIC https://docs.databricks.com/ja/generative-ai/external-models/external-models-tutorial.html
# MAGIC #### 以下のコード内の`openai_api_key` は 予め管理者が作成したService Principalの情報を使って、`{{secrets/スコープ名/シークレット名}}`に書き換えてください
# COMMAND ----------
# DBTITLE 1,チャットモデルのサービングエンドポイント作成
import mlflow.deployments
# MLFLow Deployments の各種機能を操作するためのクライアントを用意
mlflow_deploy_client = mlflow.deployments.get_deploy_client("databricks")
try:
# MLFLow Deployments のクライアントを使い、OpenAIのチャットモデル(gpt-3.5-turbo)への
# Proxyとなるモデルサービングエンドポイントを作成する
mlflow_deploy_client.create_endpoint(
name=chat_model_endpoint_name,
config={
"served_entities": [{
"external_model": {
"name": "gpt-3.5-turbo",
"provider": "openai",
"task": "llm/v1/chat",
"openai_config": {
# 下記は管理者から提供されたService Principalのシークレット情報で書き換える
"openai_api_key": "{{secrets/fieldeng/nabe_openai}}"
}
}
}]
}
)
except Exception as e:
print(e)
# COMMAND ----------
# DBTITLE 1,OpenAIのチャットモデル単体でテスト（文脈と異なる、期待していない答え）
from langchain.chat_models import ChatDatabricks
# 今回の文脈では「サブプロセッサー」はサードパーティの事業者といった意味だが、
# OpenAIのチャットモデル単体では全く違う意味の答えが返ってくる
chat_model = ChatDatabricks(endpoint=chat_model_endpoint_name, max_tokens = 200)
print(f"Test chat model: {chat_model.predict('サブプロセッサーとは何ですか？')}")
# COMMAND ----------
# MAGIC %md
# MAGIC ## RAG Chainを作成する
# COMMAND ----------
# DBTITLE 1,RAGチェーンの作成
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
TEMPLATE = """あなたはDatabricksの顧客情報の取り扱い規定を熟知しています。次に与えられるコンテキストを使用して、その後の質問に答えなさい:
{context}
Question: {question}
Answer:
"""
prompt = PromptTemplate(template=TEMPLATE, input_variables=["context", "question"])
# ここまで用意したチャットモデル、Vector Search Index、プロンプトテンプレートを1つのチェーンにまとめる
chain = RetrievalQA.from_chain_type(
llm=chat_model,
chain_type="stuff",
retriever=vectorstore_ret,
chain_type_kwargs={"prompt": prompt}
)
# COMMAND ----------
# DBTITLE 1,RAGチェーンでテスト（ドキュメントの内容を踏まえた期待通りの答え）
# 先ほどのOpenAIのチャットモデル単体では全く違う意味の答えが返ってきたが、
# 今度はVector Search内の情報を使って適切な答えを返してくれる
question = {"query": "サブプロセッサーとは何ですか？"}
answer = chain.run(question)
print(answer)
# COMMAND ----------
# MAGIC %md
# MAGIC ## 作成したRAGチェーンの登録と評価
# COMMAND ----------
# DBTITLE 1,MLFlowエクスペリメントを事前に作成・指定
import requests
api_key = dbutils.secrets.get(f"{scope_name}", f"{secret_name}")
xp_root_path = f"/Shared/rag_demo/experiments/{experiment_dir_name}"
r = requests.post(f"{host}/api/2.0/workspace/mkdirs", headers = {"Accept": "application/json", "Authorization": f"Bearer {api_key}"}, json={ "path": xp_root_path})
mlflow.set_experiment(f"{xp_root_path}/{experiment_name}")
# COMMAND ----------
from mlflow import MlflowClient
# モデルレジストリから最新バージョンの番号を取得する
def get_latest_model_version(model_name):
mlflow_client = MlflowClient()
latest_version = 1
for mv in mlflow_client.search_model_versions(f"name='{model_name}'"):
version_int = int(mv.version)
if version_int > latest_version:
latest_version = version_int
return latest_version
# COMMAND ----------
# DBTITLE 1,評価用データセットの準備
import pandas as pd
# デモのため、3件のみのテストデータセットを手動で作成
# 入力(質問)を入れたカラムの名前を上でテストした時のものに合わせ、「query」とすること
eval_df = pd.DataFrame(
{
"query": [
"「パーソナル データ」の定義を教えてください",
"サブプロセッサーにはどのような義務がありますか？",
"データの暗号化について、Databricksがどのような取り組みを行なっているか教えてください"
],
"ground_truth": [
"パーソナルデータとは、顧客コンテンツに含まれる、または Databricks サービスの提供において顧客によって、または顧客に代わって、本契約に基づいて処理するために Databricks に提供される、すべての「個人データ」または「個人情報」を意味します。",
"Databricks は、下請処理者と書面による契約を締結するものとします。これには、契約および本 DPA と同様に個人データを保護するデータ保護およびセキュリティ対策が含まれます。 その下請処理者の作為、誤りまたは不作為が原因である本契約および本 DPA の違反に対して、Databricks がそのような作為、誤りまたは不作為に対して責任を負っていたであろう範囲で、完全に責任を負います。",
"転送中のデータは、お客様とDatabricksコントロールプレーン間、およびDatabricksコントロールプレーンとデータプレーン間で暗号されています。暗号的には、安全なプロトコル (TLS v.1.2 以上) を使用しています。また、Databricksコントロールプレーン内に保存されているデータは、安全なプロトコル (AES-128 ビット、または同等以上) を使用して暗号化されます。",
],
}
)
# COMMAND ----------
# DBTITLE 1,MLFlowによるロギング、モデルレジストリ登録、評価
from mlflow.models import infer_signature
import mlflow
import langchain
from mlflow.metrics.genai import answer_similarity, answer_correctness, answer_relevance
# Databricks Unity Catalog上にモデルを保存するよう指定
mlflow.set_registry_uri("databricks-uc")
# モデルレジストリに登録する際のモデル名
model_name = f"{catalog_name}.{schema_name}.{rag_model_name}"
with mlflow.start_run(run_name="dbdemos_chatbot_rag") as run:
# 上のセルでサンプルとして試した質問と回答を、入出力のシグネチャとして登録
signature = infer_signature(question, answer)
model_info = mlflow.langchain.log_model(
chain,
loader_fn=get_retriever,
artifact_path="chain",
registered_model_name=model_name,
pip_requirements=[
"mlflow[genai]>=2.9.0",
"langchain==" + langchain.__version__,
"databricks-vectorsearch",
],
input_example=question,
signature=signature
)
# モデルの評価
results = mlflow.evaluate(
# 上記でロギングしたモデルのURI
model_info.model_uri,
# テストデータセットが入ったDataFrame
eval_df,
# 正解(模範回答)を入れたカラムの名前
targets="ground_truth",
# タスクの種類を質問応答で指定
model_type="question-answering",
# 評価指標を追加
extra_metrics=[
answer_similarity(),
answer_correctness(),
answer_relevance()
],
evaluators="default",
evaluator_config={"col_mapping": {"inputs": "query"}}
)
import mlflow.models.utils
mlflow.models.utils.add_libraries_to_model(
f"models:/{model_name}/{get_latest_model_version(model_name)}"
)
# COMMAND ----------
# MAGIC %md
# MAGIC ## RAGチェーンをモデルサービングエンドポイントにデプロイする
# MAGIC
# MAGIC #### 以下のコード内の`DATABRICKS_TOKEN`と`DATABRICKS_HOST`は 予め管理者が作成したService Principalの情報を使って、`{{secrets/スコープ名/シークレット名}}`に書き換えてください
# COMMAND ----------
# DBTITLE 1,RAGチェーンのデプロイ
from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import EndpointCoreConfigInput, ServedModelInput
latest_model_version = get_latest_model_version(model_name)
# モデルサービングエンドポイントへのデプロイ内容を指定
w = WorkspaceClient()
endpoint_config = EndpointCoreConfigInput(
name=rag_endpoint_name,
served_models=[
ServedModelInput(
# デプロイするモデルのモデルレジストリ上での名前
model_name=model_name,
# デプロイするモデルのバージョン（上で取得した最新バージョンを指定）
model_version=latest_model_version,
# モデルサービングエンドポイントのキャパシティ
workload_size="Small",
# リクエストが無い時はリソースをゼロまでスケールダウンする
scale_to_zero_enabled=True,
# モデルサービングエンドポイントに対して渡す環境変数 (SPのシークレット)
environment_vars={
# 下記は、SPのワークスペース接続用のシークレットに書き換え
"DATABRICKS_TOKEN": "{{secrets/fieldeng/nabe-field-eng-ws}}",
# 下記は、SPがシークレットに保存しているワークスペースのホスト名に書き換え
"DATABRICKS_HOST": "{{secrets/fieldeng/nabe-field-eng-host}}"
}
)
]
)
existing_endpoint = next(
(e for e in w.serving_endpoints.list() if e.name == rag_endpoint_name), None
)
# 同じ名前のモデルサービングエンドポイントがまだデプロイされていない場合は新規にデプロイ
if existing_endpoint == None:
print(f"Creating the endpoint {rag_endpoint_name}, this will take a few minutes to package and deploy the endpoint...")
w.serving_endpoints.create_and_wait(name=rag_endpoint_name, config=endpoint_config)
# 同じ名前のモデルサービングエンドポイントがすでにプロイされている場合はアップデート
else:
print(f"Updating the endpoint {rag_endpoint_name} to version {latest_model_version}, this will take a few minutes to package and deploy the endpoint...")
w.serving_endpoints.update_config_and_wait(served_models=endpoint_config.served_models, name=rag_endpoint_name)
# COMMAND ----------
# DBTITLE 1,デプロイしたRAGチェーンのテスト
question = "サブプロセッサーとは何ですか？"
answer = w.serving_endpoints.query(rag_endpoint_name, inputs=[{"query": question}])
print(answer.predictions[0])
| [
"langchain.vectorstores.DatabricksVectorSearch",
"langchain.chains.RetrievalQA.from_chain_type",
"langchain.prompts.PromptTemplate",
"langchain.chat_models.ChatDatabricks"
] | [((5946, 5996), 'mlflow.deployments.get_deploy_client', 'mlflow.deployments.get_deploy_client', (['"""databricks"""'], {}), "('databricks')\n", (5982, 5996), False, 'import mlflow\n'), ((6909, 6974), 'langchain.chat_models.ChatDatabricks', 'ChatDatabricks', ([], {'endpoint': 'chat_model_endpoint_name', 'max_tokens': '(200)'}), '(endpoint=chat_model_endpoint_name, max_tokens=200)\n', (6923, 6974), False, 'from langchain.chat_models import ChatDatabricks\n'), ((7372, 7446), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'TEMPLATE', 'input_variables': "['context', 'question']"}), "(template=TEMPLATE, input_variables=['context', 'question'])\n", (7386, 7446), False, 'from langchain.prompts import PromptTemplate\n'), ((7519, 7652), 'langchain.chains.RetrievalQA.from_chain_type', 'RetrievalQA.from_chain_type', ([], {'llm': 'chat_model', 'chain_type': '"""stuff"""', 'retriever': 'vectorstore_ret', 'chain_type_kwargs': "{'prompt': prompt}"}), "(llm=chat_model, chain_type='stuff', retriever=\n vectorstore_ret, chain_type_kwargs={'prompt': prompt})\n", (7546, 7652), False, 'from langchain.chains import RetrievalQA\n'), ((8179, 8343), 'requests.post', 'requests.post', (['f"""{host}/api/2.0/workspace/mkdirs"""'], {'headers': "{'Accept': 'application/json', 'Authorization': f'Bearer {api_key}'}", 'json': "{'path': xp_root_path}"}), "(f'{host}/api/2.0/workspace/mkdirs', headers={'Accept':\n 'application/json', 'Authorization': f'Bearer {api_key}'}, json={'path':\n xp_root_path})\n", (8192, 8343), False, 'import requests\n'), ((8339, 8397), 'mlflow.set_experiment', 'mlflow.set_experiment', (['f"""{xp_root_path}/{experiment_name}"""'], {}), "(f'{xp_root_path}/{experiment_name}')\n", (8360, 8397), False, 'import mlflow\n'), ((8959, 9677), 'pandas.DataFrame', 'pd.DataFrame', (["{'query': ['「パーソナル データ」の定義を教えてください', 'サブプロセッサーにはどのような義務がありますか？',\n 'データの暗号化について、Databricksがどのような取り組みを行なっているか教えてください'], 'ground_truth': [\n 'パーソナルデータとは、顧客コンテンツに含まれる、または Databricks サービスの提供において顧客によって、または顧客に代わって、本契約に基づいて処理するために Databricks に提供される、すべての「個人データ」または「個人情報」を意味します。'\n ,\n 'Databricks は、下請処理者と書面による契約を締結するものとします。これには、契約および本 DPA と同様に個人データを保護するデータ保護およびセキュリティ対策が含まれます。 その下請処理者の作為、誤りまたは不作為が原因である本契約および本 DPA の違反に対して、Databricks がそのような作為、誤りまたは不作為に対して責任を負っていたであろう範囲で、完全に責任を負います。'\n ,\n '転送中のデータは、お客様とDatabricksコントロールプレーン間、およびDatabricksコントロールプレーンとデータプレーン間で暗号されています。暗号的には、安全なプロトコル (TLS v.1.2 以上) を使用しています。また、Databricksコントロールプレーン内に保存されているデータは、安全なプロトコル (AES-128 ビット、または同等以上) を使用して暗号化されます。'\n ]}"], {}), "({'query': ['「パーソナル データ」の定義を教えてください',\n 'サブプロセッサーにはどのような義務がありますか？',\n 'データの暗号化について、Databricksがどのような取り組みを行なっているか教えてください'], 'ground_truth': [\n 'パーソナルデータとは、顧客コンテンツに含まれる、または Databricks サービスの提供において顧客によって、または顧客に代わって、本契約に基づいて処理するために Databricks に提供される、すべての「個人データ」または「個人情報」を意味します。'\n ,\n 'Databricks は、下請処理者と書面による契約を締結するものとします。これには、契約および本 DPA と同様に個人データを保護するデータ保護およびセキュリティ対策が含まれます。 その下請処理者の作為、誤りまたは不作為が原因である本契約および本 DPA の違反に対して、Databricks がそのような作為、誤りまたは不作為に対して責任を負っていたであろう範囲で、完全に責任を負います。'\n ,\n '転送中のデータは、お客様とDatabricksコントロールプレーン間、およびDatabricksコントロールプレーンとデータプレーン間で暗号されています。暗号的には、安全なプロトコル (TLS v.1.2 以上) を使用しています。また、Databricksコントロールプレーン内に保存されているデータは、安全なプロトコル (AES-128 ビット、または同等以上) を使用して暗号化されます。'\n ]})\n", (8971, 9677), True, 'import pandas as pd\n'), ((10031, 10071), 'mlflow.set_registry_uri', 'mlflow.set_registry_uri', (['"""databricks-uc"""'], {}), "('databricks-uc')\n", (10054, 10071), False, 'import mlflow\n'), ((11885, 11902), 'databricks.sdk.WorkspaceClient', 'WorkspaceClient', ([], {}), '()\n', (11900, 11902), False, 'from databricks.sdk import WorkspaceClient\n'), ((4801, 4898), 'databricks.vector_search.client.VectorSearchClient', 'VectorSearchClient', ([], {'workspace_url': 'host', 'personal_access_token': "os.environ['DATABRICKS_TOKEN']"}), "(workspace_url=host, personal_access_token=os.environ[\n 'DATABRICKS_TOKEN'])\n", (4819, 4898), False, 'from databricks.vector_search.client import VectorSearchClient\n'), ((5141, 5173), 'langchain.vectorstores.DatabricksVectorSearch', 'DatabricksVectorSearch', (['vs_index'], {}), '(vs_index)\n', (5163, 5173), False, 'from langchain.vectorstores import DatabricksVectorSearch\n'), ((8544, 8558), 'mlflow.MlflowClient', 'MlflowClient', ([], {}), '()\n', (8556, 8558), False, 'from mlflow import MlflowClient\n'), ((10162, 10210), 'mlflow.start_run', 'mlflow.start_run', ([], {'run_name': '"""dbdemos_chatbot_rag"""'}), "(run_name='dbdemos_chatbot_rag')\n", (10178, 10210), False, 'import mlflow\n'), ((10278, 10311), 'mlflow.models.infer_signature', 'infer_signature', (['question', 'answer'], {}), '(question, answer)\n', (10293, 10311), False, 'from mlflow.models import infer_signature\n'), ((10329, 10612), 'mlflow.langchain.log_model', 'mlflow.langchain.log_model', (['chain'], {'loader_fn': 'get_retriever', 'artifact_path': '"""chain"""', 'registered_model_name': 'model_name', 'pip_requirements': "['mlflow[genai]>=2.9.0', 'langchain==' + langchain.__version__,\n 'databricks-vectorsearch']", 'input_example': 'question', 'signature': 'signature'}), "(chain, loader_fn=get_retriever, artifact_path=\n 'chain', registered_model_name=model_name, pip_requirements=[\n 'mlflow[genai]>=2.9.0', 'langchain==' + langchain.__version__,\n 'databricks-vectorsearch'], input_example=question, signature=signature)\n", (10355, 10612), False, 'import mlflow\n'), ((12002, 12285), 'databricks.sdk.service.serving.ServedModelInput', 'ServedModelInput', ([], {'model_name': 'model_name', 'model_version': 'latest_model_version', 'workload_size': '"""Small"""', 'scale_to_zero_enabled': '(True)', 'environment_vars': "{'DATABRICKS_TOKEN': '{{secrets/fieldeng/nabe-field-eng-ws}}',\n 'DATABRICKS_HOST': '{{secrets/fieldeng/nabe-field-eng-host}}'}"}), "(model_name=model_name, model_version=latest_model_version,\n workload_size='Small', scale_to_zero_enabled=True, environment_vars={\n 'DATABRICKS_TOKEN': '{{secrets/fieldeng/nabe-field-eng-ws}}',\n 'DATABRICKS_HOST': '{{secrets/fieldeng/nabe-field-eng-host}}'})\n", (12018, 12285), False, 'from databricks.sdk.service.serving import EndpointCoreConfigInput, ServedModelInput\n'), ((11041, 11060), 'mlflow.metrics.genai.answer_similarity', 'answer_similarity', ([], {}), '()\n', (11058, 11060), False, 'from mlflow.metrics.genai import answer_similarity, answer_correctness, answer_relevance\n'), ((11074, 11094), 'mlflow.metrics.genai.answer_correctness', 'answer_correctness', ([], {}), '()\n', (11092, 11094), False, 'from mlflow.metrics.genai import answer_similarity, answer_correctness, answer_relevance\n'), ((11108, 11126), 'mlflow.metrics.genai.answer_relevance', 'answer_relevance', ([], {}), '()\n', (11124, 11126), False, 'from mlflow.metrics.genai import answer_similarity, answer_correctness, answer_relevance\n')] |
# Import Langchain modules
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.llms import OpenAI
# Import Environment Modules
import os
from dotenv import load_dotenv
# Import API Modules
from fastapi import FastAPI
from fastapi.responses import HTMLResponse, JSONResponse
import uvicorn
# Import Other Modules
import json
import logging
import warnings
warnings.filterwarnings("ignore")
# Load configuration
with open('config.json', 'r') as f:
config = json.load(f)
# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
def environment_setup() -> None:
"""
Load environment variables and set OpenAI API key.
"""
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
def load_documents(document_path: str) -> list:
"""
Load the pdf file and split it into pages.
"""
try:
loader = PyPDFLoader(document_path)
pages = loader.load_and_split()
return pages
except Exception as e:
logging.error(f"Error loading documents from {document_path}: {e}")
return []
def split_documents(pages: list) -> list:
"""
Split the pages into chunks.
"""
try:
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=200,
chunk_overlap=0,
length_function=len,
is_separator_regex=True,
)
docs = text_splitter.split_documents(pages)
return docs
except Exception as e:
logging.error(f"Error splitting documents: {e}")
return []
def process_documents() -> list:
"""
Process all documents in the specified path.
"""
document_paths = [os.path.join(config['DOCUMENTS_PATH'], f) for f in os.listdir(config['DOCUMENTS_PATH']) if f.endswith(".pdf")]
all_docs = []
for document_path in document_paths:
pages = load_documents(document_path)
docs = split_documents(pages)
all_docs.extend(docs)
return all_docs
def embeddings(docs: list) -> FAISS:
"""
Load the embeddings and store them in a vector store.
"""
try:
embeddings = OpenAIEmbeddings()
db = FAISS.from_documents(docs, embeddings)
return db
except Exception as e:
logging.error(f"Error creating embeddings: {e}")
return None
def initialize_model() -> OpenAI:
"""
Initialize the model.
"""
llm = OpenAI()
return llm
def LLM_chain(llm: OpenAI, db: FAISS) -> RetrievalQA:
"""
Create a retrieval chain with the LLM and vector store.
"""
if db is None:
logging.error("Error: db is None")
return None
chain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=db.as_retriever(search_kwargs={"k": 5}))
return chain
def initialize_all() -> tuple:
"""
Initialize all components.
"""
environment_setup()
docs = process_documents()
db = embeddings(docs)
llm = initialize_model()
llm_chain = LLM_chain(llm, db)
return llm_chain, db
def process_message(chain: RetrievalQA, user_message: str, db: FAISS) -> str:
"""
Process the user's message and return the bot's response.
"""
try:
query = user_message
docs = db.similarity_search(query)
result = chain.run(input_documents=docs, query=query)
return result
except Exception as e:
logging.error(f"Error generating response: {e}", exc_info=True)
return "Sorry, I couldn't understand your message."
def setup_fastapi(llm_chain: RetrievalQA, db: FAISS) -> FastAPI:
"""
Setup FastAPI with routes.
"""
app = FastAPI()
@app.get("/", response_class=HTMLResponse)
def read_root() -> HTMLResponse:
"""
Serve the chatbot HTML page.
"""
try:
with open('templates/chatbot.html', 'r') as f:
html_content = f.read()
return HTMLResponse(content=html_content, status_code=200)
except Exception as e:
logging.error(f"Error reading HTML file: {e}", exc_info=True)
return HTMLResponse(content="Sorry, something went wrong.", status_code=500)
@app.get("/chatbot/{user_message}")
def get_bot_response(user_message: str) -> JSONResponse:
"""
Process the user's message and return the bot's response.
"""
try:
bot_response = process_message(llm_chain, user_message, db)
return JSONResponse(content={"answer": bot_response})
except Exception as e:
logging.error(f"Error processing message: {e}", exc_info=True)
return JSONResponse(content={"answer": "Sorry, something went wrong."})
return app
if __name__ == "__main__":
try:
llm_chain, db = initialize_all()
fastapi_app = setup_fastapi(llm_chain, db)
uvicorn.run(fastapi_app, host="0.0.0.0", port=8000)
except Exception as e:
logging.error(f"Error during initialization: {e}", exc_info=True) | [
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.llms.OpenAI",
"langchain.vectorstores.FAISS.from_documents",
"langchain.embeddings.OpenAIEmbeddings",
"langchain.document_loaders.PyPDFLoader"
] | [((573, 606), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (596, 606), False, 'import warnings\n'), ((712, 808), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""%(asctime)s - %(levelname)s - %(message)s"""'}), "(level=logging.INFO, format=\n '%(asctime)s - %(levelname)s - %(message)s')\n", (731, 808), False, 'import logging\n'), ((678, 690), 'json.load', 'json.load', (['f'], {}), '(f)\n', (687, 690), False, 'import json\n'), ((913, 926), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (924, 926), False, 'from dotenv import load_dotenv\n'), ((962, 989), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (971, 989), False, 'import os\n'), ((2654, 2662), 'langchain.llms.OpenAI', 'OpenAI', ([], {}), '()\n', (2660, 2662), False, 'from langchain.llms import OpenAI\n'), ((3883, 3892), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (3890, 3892), False, 'from fastapi import FastAPI\n'), ((1128, 1154), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['document_path'], {}), '(document_path)\n', (1139, 1154), False, 'from langchain.document_loaders import PyPDFLoader\n'), ((1462, 1575), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(200)', 'chunk_overlap': '(0)', 'length_function': 'len', 'is_separator_regex': '(True)'}), '(chunk_size=200, chunk_overlap=0,\n length_function=len, is_separator_regex=True)\n', (1492, 1575), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1926, 1967), 'os.path.join', 'os.path.join', (["config['DOCUMENTS_PATH']", 'f'], {}), "(config['DOCUMENTS_PATH'], f)\n", (1938, 1967), False, 'import os\n'), ((2374, 2392), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (2390, 2392), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((2406, 2444), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['docs', 'embeddings'], {}), '(docs, embeddings)\n', (2426, 2444), False, 'from langchain.vectorstores import FAISS\n'), ((2836, 2870), 'logging.error', 'logging.error', (['"""Error: db is None"""'], {}), "('Error: db is None')\n", (2849, 2870), False, 'import logging\n'), ((5102, 5153), 'uvicorn.run', 'uvicorn.run', (['fastapi_app'], {'host': '"""0.0.0.0"""', 'port': '(8000)'}), "(fastapi_app, host='0.0.0.0', port=8000)\n", (5113, 5153), False, 'import uvicorn\n'), ((1251, 1318), 'logging.error', 'logging.error', (['f"""Error loading documents from {document_path}: {e}"""'], {}), "(f'Error loading documents from {document_path}: {e}')\n", (1264, 1318), False, 'import logging\n'), ((1738, 1786), 'logging.error', 'logging.error', (['f"""Error splitting documents: {e}"""'], {}), "(f'Error splitting documents: {e}')\n", (1751, 1786), False, 'import logging\n'), ((1977, 2013), 'os.listdir', 'os.listdir', (["config['DOCUMENTS_PATH']"], {}), "(config['DOCUMENTS_PATH'])\n", (1987, 2013), False, 'import os\n'), ((2498, 2546), 'logging.error', 'logging.error', (['f"""Error creating embeddings: {e}"""'], {}), "(f'Error creating embeddings: {e}')\n", (2511, 2546), False, 'import logging\n'), ((3635, 3698), 'logging.error', 'logging.error', (['f"""Error generating response: {e}"""'], {'exc_info': '(True)'}), "(f'Error generating response: {e}', exc_info=True)\n", (3648, 3698), False, 'import logging\n'), ((4170, 4221), 'fastapi.responses.HTMLResponse', 'HTMLResponse', ([], {'content': 'html_content', 'status_code': '(200)'}), '(content=html_content, status_code=200)\n', (4182, 4221), False, 'from fastapi.responses import HTMLResponse, JSONResponse\n'), ((4712, 4758), 'fastapi.responses.JSONResponse', 'JSONResponse', ([], {'content': "{'answer': bot_response}"}), "(content={'answer': bot_response})\n", (4724, 4758), False, 'from fastapi.responses import HTMLResponse, JSONResponse\n'), ((5189, 5254), 'logging.error', 'logging.error', (['f"""Error during initialization: {e}"""'], {'exc_info': '(True)'}), "(f'Error during initialization: {e}', exc_info=True)\n", (5202, 5254), False, 'import logging\n'), ((4265, 4326), 'logging.error', 'logging.error', (['f"""Error reading HTML file: {e}"""'], {'exc_info': '(True)'}), "(f'Error reading HTML file: {e}', exc_info=True)\n", (4278, 4326), False, 'import logging\n'), ((4346, 4415), 'fastapi.responses.HTMLResponse', 'HTMLResponse', ([], {'content': '"""Sorry, something went wrong."""', 'status_code': '(500)'}), "(content='Sorry, something went wrong.', status_code=500)\n", (4358, 4415), False, 'from fastapi.responses import HTMLResponse, JSONResponse\n'), ((4802, 4864), 'logging.error', 'logging.error', (['f"""Error processing message: {e}"""'], {'exc_info': '(True)'}), "(f'Error processing message: {e}', exc_info=True)\n", (4815, 4864), False, 'import logging\n'), ((4884, 4948), 'fastapi.responses.JSONResponse', 'JSONResponse', ([], {'content': "{'answer': 'Sorry, something went wrong.'}"}), "(content={'answer': 'Sorry, something went wrong.'})\n", (4896, 4948), False, 'from fastapi.responses import HTMLResponse, JSONResponse\n')] |
import streamlit as st
import dotenv
import langchain
import json
from cassandra.cluster import Session
from cassandra.query import PreparedStatement
from langchain.agents.agent_toolkits import create_retriever_tool, create_conversational_retrieval_agent
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.callbacks import StreamlitCallbackHandler
from langchain.schema import BaseRetriever, Document, SystemMessage
from cassandra.cluster import Cluster, Session
from cassandra.auth import PlainTextAuthProvider
# Enable langchain debug mode
langchain.debug = True
dotenv.load_dotenv(dotenv.find_dotenv())
class AstraProductRetriever(BaseRetriever):
session: Session
embedding: OpenAIEmbeddings
lang: str = "English"
search_statement_en: PreparedStatement = None
search_statement_th: PreparedStatement = None
class Config:
arbitrary_types_allowed = True
def get_relevant_documents(self, query):
docs = []
embeddingvector = self.embedding.embed_query(query)
if self.lang == "Thai":
if self.search_statement_th is None:
self.search_statement_th = self.session.prepare("""
SELECT
product_id,
brand,
saleprice,
product_categories,
product_name,
short_description,
long_description
FROM hybridretail.products_cg_hybrid
ORDER BY openai_description_embedding_th ANN OF ?
LIMIT ?
""")
query = self.search_statement_th
else:
if self.search_statement_en is None:
self.search_statement_en = self.session.prepare("""
SELECT
product_id,
brand,
saleprice,
product_categories,
product_name_en,
short_description_en,
long_description_en
FROM hybridretail.products_cg_hybrid
ORDER BY openai_description_embedding_en ANN OF ?
LIMIT ?
""")
query = self.search_statement_en
results = self.session.execute(query, [embeddingvector, 5])
top_products = results._current_rows
for r in top_products:
docs.append(Document(
id=r.product_id,
page_content=r.product_name if self.lang == "Thai" else r.product_name_en,
metadata={"product id": r.product_id,
"brand": r.brand,
"product category": r.product_categories,
"product name": r.product_name if self.lang == "Thai" else r.product_name_en,
"description": r.short_description if self.lang == "Thai" else r.short_description_en,
"price": r.saleprice
}
))
return docs
def get_session(scb: str, secrets: str) -> Session:
"""
Connect to Astra DB using secure connect bundle and credentials.
Parameters
----------
scb : str
Path to secure connect bundle.
secrets : str
Path to credentials.
"""
cloud_config = {
'secure_connect_bundle': scb
}
with open(secrets) as f:
secrets = json.load(f)
CLIENT_ID = secrets["clientId"]
CLIENT_SECRET = secrets["secret"]
auth_provider = PlainTextAuthProvider(CLIENT_ID, CLIENT_SECRET)
cluster = Cluster(cloud=cloud_config, auth_provider=auth_provider)
return cluster.connect()
@st.cache_resource
def create_chatbot(lang: str):
print(f"Creating chatbot for {lang}...")
session = get_session(scb='./config/secure-connect-multilingual.zip',
secrets='./config/multilingual-token.json')
llm = ChatOpenAI(temperature=0, streaming=True)
embedding = OpenAIEmbeddings()
retriever = AstraProductRetriever(
session=session, embedding=embedding, lang=lang)
retriever_tool = create_retriever_tool(
retriever, "products_retrevier", "Useful when searching for products from a product description. Prices are in THB.")
system_message = "You are a customer service of a home improvement store and you are asked to pick products for a customer."
if lang == "Thai":
system_message = f"{system_message} All the responses should be in Thai language."
message = SystemMessage(content=system_message)
agent_executor = create_conversational_retrieval_agent(
llm=llm, tools=[retriever_tool], system_message=message, verbose=True)
return agent_executor
if 'history' not in st.session_state:
st.session_state['history'] = {
"English": [],
"Thai": []
}
st.set_page_config(layout="wide")
with st.sidebar:
lang = st.radio(
"Chat language",
["English", "Thai"],
captions=[".", "Experimental"])
chatbot = create_chatbot(lang)
# Display chat messages from history on app rerun
for (query, answer) in st.session_state['history'][lang]:
with st.chat_message("User"):
st.markdown(query)
with st.chat_message("Bot"):
st.markdown(answer)
prompt = st.chat_input(placeholder="Ask chatbot")
if prompt:
# Display user message in chat message container
with st.chat_message("User"):
st.markdown(prompt)
# Display assistant response in chat message container
with st.chat_message("Bot"):
st_callback = StreamlitCallbackHandler(st.container())
result = result = chatbot.invoke({
"input": prompt,
"chat_history": st.session_state['history'][lang]
}, config={"callbacks": [st_callback]})
st.session_state['history'][lang].append((prompt, result["output"]))
st.markdown(result["output"]) | [
"langchain.chat_models.ChatOpenAI",
"langchain.schema.Document",
"langchain.embeddings.OpenAIEmbeddings",
"langchain.schema.SystemMessage",
"langchain.agents.agent_toolkits.create_conversational_retrieval_agent",
"langchain.agents.agent_toolkits.create_retriever_tool"
] | [((5021, 5054), 'streamlit.set_page_config', 'st.set_page_config', ([], {'layout': '"""wide"""'}), "(layout='wide')\n", (5039, 5054), True, 'import streamlit as st\n'), ((5462, 5502), 'streamlit.chat_input', 'st.chat_input', ([], {'placeholder': '"""Ask chatbot"""'}), "(placeholder='Ask chatbot')\n", (5475, 5502), True, 'import streamlit as st\n'), ((648, 668), 'dotenv.find_dotenv', 'dotenv.find_dotenv', ([], {}), '()\n', (666, 668), False, 'import dotenv\n'), ((3694, 3741), 'cassandra.auth.PlainTextAuthProvider', 'PlainTextAuthProvider', (['CLIENT_ID', 'CLIENT_SECRET'], {}), '(CLIENT_ID, CLIENT_SECRET)\n', (3715, 3741), False, 'from cassandra.auth import PlainTextAuthProvider\n'), ((3756, 3812), 'cassandra.cluster.Cluster', 'Cluster', ([], {'cloud': 'cloud_config', 'auth_provider': 'auth_provider'}), '(cloud=cloud_config, auth_provider=auth_provider)\n', (3763, 3812), False, 'from cassandra.cluster import Cluster, Session\n'), ((4093, 4134), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'streaming': '(True)'}), '(temperature=0, streaming=True)\n', (4103, 4134), False, 'from langchain.chat_models import ChatOpenAI\n'), ((4151, 4169), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (4167, 4169), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((4287, 4435), 'langchain.agents.agent_toolkits.create_retriever_tool', 'create_retriever_tool', (['retriever', '"""products_retrevier"""', '"""Useful when searching for products from a product description. Prices are in THB."""'], {}), "(retriever, 'products_retrevier',\n 'Useful when searching for products from a product description. Prices are in THB.'\n )\n", (4308, 4435), False, 'from langchain.agents.agent_toolkits import create_retriever_tool, create_conversational_retrieval_agent\n'), ((4693, 4730), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'system_message'}), '(content=system_message)\n', (4706, 4730), False, 'from langchain.schema import BaseRetriever, Document, SystemMessage\n'), ((4752, 4864), 'langchain.agents.agent_toolkits.create_conversational_retrieval_agent', 'create_conversational_retrieval_agent', ([], {'llm': 'llm', 'tools': '[retriever_tool]', 'system_message': 'message', 'verbose': '(True)'}), '(llm=llm, tools=[retriever_tool],\n system_message=message, verbose=True)\n', (4789, 4864), False, 'from langchain.agents.agent_toolkits import create_retriever_tool, create_conversational_retrieval_agent\n'), ((5084, 5162), 'streamlit.radio', 'st.radio', (['"""Chat language"""', "['English', 'Thai']"], {'captions': "['.', 'Experimental']"}), "('Chat language', ['English', 'Thai'], captions=['.', 'Experimental'])\n", (5092, 5162), True, 'import streamlit as st\n'), ((3585, 3597), 'json.load', 'json.load', (['f'], {}), '(f)\n', (3594, 3597), False, 'import json\n'), ((5339, 5362), 'streamlit.chat_message', 'st.chat_message', (['"""User"""'], {}), "('User')\n", (5354, 5362), True, 'import streamlit as st\n'), ((5372, 5390), 'streamlit.markdown', 'st.markdown', (['query'], {}), '(query)\n', (5383, 5390), True, 'import streamlit as st\n'), ((5400, 5422), 'streamlit.chat_message', 'st.chat_message', (['"""Bot"""'], {}), "('Bot')\n", (5415, 5422), True, 'import streamlit as st\n'), ((5432, 5451), 'streamlit.markdown', 'st.markdown', (['answer'], {}), '(answer)\n', (5443, 5451), True, 'import streamlit as st\n'), ((5576, 5599), 'streamlit.chat_message', 'st.chat_message', (['"""User"""'], {}), "('User')\n", (5591, 5599), True, 'import streamlit as st\n'), ((5609, 5628), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (5620, 5628), True, 'import streamlit as st\n'), ((5697, 5719), 'streamlit.chat_message', 'st.chat_message', (['"""Bot"""'], {}), "('Bot')\n", (5712, 5719), True, 'import streamlit as st\n'), ((6051, 6080), 'streamlit.markdown', 'st.markdown', (["result['output']"], {}), "(result['output'])\n", (6062, 6080), True, 'import streamlit as st\n'), ((5768, 5782), 'streamlit.container', 'st.container', ([], {}), '()\n', (5780, 5782), True, 'import streamlit as st\n'), ((2574, 2981), 'langchain.schema.Document', 'Document', ([], {'id': 'r.product_id', 'page_content': "(r.product_name if self.lang == 'Thai' else r.product_name_en)", 'metadata': "{'product id': r.product_id, 'brand': r.brand, 'product category': r.\n product_categories, 'product name': r.product_name if self.lang ==\n 'Thai' else r.product_name_en, 'description': r.short_description if \n self.lang == 'Thai' else r.short_description_en, 'price': r.saleprice}"}), "(id=r.product_id, page_content=r.product_name if self.lang ==\n 'Thai' else r.product_name_en, metadata={'product id': r.product_id,\n 'brand': r.brand, 'product category': r.product_categories,\n 'product name': r.product_name if self.lang == 'Thai' else r.\n product_name_en, 'description': r.short_description if self.lang ==\n 'Thai' else r.short_description_en, 'price': r.saleprice})\n", (2582, 2981), False, 'from langchain.schema import BaseRetriever, Document, SystemMessage\n')] |
import os
import langchain
import streamlit as st
from dotenv import load_dotenv
from langchain.chat_models import ChatOpenAI
from langchain.cache import InMemoryCache
from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate, ChatPromptTemplate, PromptTemplate
# Config
load_dotenv(".env")
api_key = os.environ.get("key")
# Cache Config
langchain.llm_cache = InMemoryCache()
chat = ChatOpenAI(api_key=api_key, model='gpt-3.5-turbo', max_tokens=500)
st.header("🧇🥞🍳🥛 BrunchBuddy")
st.sidebar.header("Parameters")
slider_value = st.sidebar.slider("Time", 0, 120, 30)
selectbox_value = st.sidebar.selectbox("Type", ("Vegetarian", "Non-Vegetarian"))
system_message = "You are an AI recipe assistant that specialize in {brunch} dishes that can be prepared in {time}"
system_message_prompt = SystemMessagePromptTemplate.from_template(system_message)
human_template = "{recipe_request}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)
chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
prompt_input = st.text_input("What would you like to have for brunch:")
if prompt_input:
prompt = chat_prompt.format_prompt(time=str(slider_value) + " min", recipe_request=str(prompt_input), brunch=selectbox_value).to_messages()
st.write(chat(prompt).content) | [
"langchain.prompts.SystemMessagePromptTemplate.from_template",
"langchain.chat_models.ChatOpenAI",
"langchain.cache.InMemoryCache",
"langchain.prompts.ChatPromptTemplate.from_messages",
"langchain.prompts.HumanMessagePromptTemplate.from_template"
] | [((326, 345), 'dotenv.load_dotenv', 'load_dotenv', (['""".env"""'], {}), "('.env')\n", (337, 345), False, 'from dotenv import load_dotenv\n'), ((356, 377), 'os.environ.get', 'os.environ.get', (['"""key"""'], {}), "('key')\n", (370, 377), False, 'import os\n'), ((416, 431), 'langchain.cache.InMemoryCache', 'InMemoryCache', ([], {}), '()\n', (429, 431), False, 'from langchain.cache import InMemoryCache\n'), ((439, 505), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'api_key': 'api_key', 'model': '"""gpt-3.5-turbo"""', 'max_tokens': '(500)'}), "(api_key=api_key, model='gpt-3.5-turbo', max_tokens=500)\n", (449, 505), False, 'from langchain.chat_models import ChatOpenAI\n'), ((507, 536), 'streamlit.header', 'st.header', (['"""🧇🥞🍳🥛 BrunchBuddy"""'], {}), "('🧇🥞🍳🥛 BrunchBuddy')\n", (516, 536), True, 'import streamlit as st\n'), ((538, 569), 'streamlit.sidebar.header', 'st.sidebar.header', (['"""Parameters"""'], {}), "('Parameters')\n", (555, 569), True, 'import streamlit as st\n'), ((585, 622), 'streamlit.sidebar.slider', 'st.sidebar.slider', (['"""Time"""', '(0)', '(120)', '(30)'], {}), "('Time', 0, 120, 30)\n", (602, 622), True, 'import streamlit as st\n'), ((642, 704), 'streamlit.sidebar.selectbox', 'st.sidebar.selectbox', (['"""Type"""', "('Vegetarian', 'Non-Vegetarian')"], {}), "('Type', ('Vegetarian', 'Non-Vegetarian'))\n", (662, 704), True, 'import streamlit as st\n'), ((846, 903), 'langchain.prompts.SystemMessagePromptTemplate.from_template', 'SystemMessagePromptTemplate.from_template', (['system_message'], {}), '(system_message)\n', (887, 903), False, 'from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate, ChatPromptTemplate, PromptTemplate\n'), ((963, 1019), 'langchain.prompts.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['human_template'], {}), '(human_template)\n', (1003, 1019), False, 'from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate, ChatPromptTemplate, PromptTemplate\n'), ((1034, 1113), 'langchain.prompts.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (['[system_message_prompt, human_message_prompt]'], {}), '([system_message_prompt, human_message_prompt])\n', (1066, 1113), False, 'from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, AIMessagePromptTemplate, ChatPromptTemplate, PromptTemplate\n'), ((1130, 1186), 'streamlit.text_input', 'st.text_input', (['"""What would you like to have for brunch:"""'], {}), "('What would you like to have for brunch:')\n", (1143, 1186), True, 'import streamlit as st\n')] |
import os
import dotenv
dotenv.load_dotenv()
### Load the credentials
api_key = os.getenv("API_KEY", None)
ibm_cloud_url = os.getenv("IBM_CLOUD_URL", None)
project_id = os.getenv("PROJECT_ID", None)
HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN", None)
min_new_tokens=1
max_new_tokens=300
temperature=1
top_k=50
top_p=1
random_seed=42
repetition_penalty=1.2
from langchain.callbacks.base import BaseCallbackHandler
class StreamHandler(BaseCallbackHandler):
from uuid import UUID
from langchain.schema.output import LLMResult
from typing import Any
def __init__(self, container, initial_text=""):
self.container = container
self.text = initial_text
def on_llm_new_token(self, token: str, **kwargs) -> None:
if token:
self.text += token
self.container.markdown(self.text)
def on_llm_end(self, response: LLMResult, *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> Any:
return super().on_llm_end(response, run_id=run_id, parent_run_id=parent_run_id, **kwargs)
### IBM Watson
def set_params_ibm(decoding_method):
from ibm_watson_machine_learning.metanames import GenTextParamsMetaNames as GenParams
if decoding_method == "sample":
params = {
GenParams.DECODING_METHOD: decoding_method,
GenParams.MIN_NEW_TOKENS: min_new_tokens,
GenParams.MAX_NEW_TOKENS: max_new_tokens,
GenParams.TEMPERATURE: temperature,
GenParams.TOP_K: top_k,
GenParams.TOP_P: top_p,
GenParams.RANDOM_SEED: random_seed,
GenParams.REPETITION_PENALTY: repetition_penalty,
GenParams.STOP_SEQUENCES: ["# [","\n\n","**"],
}
elif decoding_method == "greedy":
params = {
GenParams.DECODING_METHOD: decoding_method,
GenParams.MIN_NEW_TOKENS: min_new_tokens,
GenParams.MAX_NEW_TOKENS: max_new_tokens,
GenParams.RANDOM_SEED: random_seed,
GenParams.TEMPERATURE: temperature,
GenParams.REPETITION_PENALTY: repetition_penalty,
GenParams.STOP_SEQUENCES: ["#","[","\n\n","**"," * "],
}
else:
params = None
print("Decoding method not supported, please use 'sample' or 'greedy'.")
return params
### IBM Research BAM
def llm_param(decoding_method, model_id):
from genai.credentials import Credentials
from genai.model import Model
from genai.extensions.langchain import LangChainInterface
if bam_api_key is None or bam_api_url is None:
llm = None
print("Ensure you copied the .env file that you created earlier into the same directory as this notebook")
else:
creds = Credentials(bam_api_key, api_endpoint=bam_api_url)
# decoding_method = "greedy"
params = set_params_ibm(decoding_method)
message_placeholder = None # You can define this if needed
stream_handler = StreamHandler(message_placeholder)
callback = False
if callback is True:
llm = LangChainInterface(
model=model_id,
credentials=creds,
params=params,
callbacks=[stream_handler]
)
else:
llm = LangChainInterface(
model=model_id,
credentials=creds,
params=params
)
llm = LangChainInterface(model=model_id, credentials=creds, params=params, project_id=project_id)
return llm
### Hugging Face
def hugfacelib(repo_id):
from langchain.embeddings import HuggingFaceHubEmbeddings
repo_id = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
embedding = HuggingFaceHubEmbeddings(
task="feature-extraction",
repo_id = repo_id,
huggingfacehub_api_token = HUGGINGFACEHUB_API_TOKEN
)
return embedding
| [
"langchain.embeddings.HuggingFaceHubEmbeddings"
] | [((24, 44), 'dotenv.load_dotenv', 'dotenv.load_dotenv', ([], {}), '()\n', (42, 44), False, 'import dotenv\n'), ((81, 107), 'os.getenv', 'os.getenv', (['"""API_KEY"""', 'None'], {}), "('API_KEY', None)\n", (90, 107), False, 'import os\n'), ((124, 156), 'os.getenv', 'os.getenv', (['"""IBM_CLOUD_URL"""', 'None'], {}), "('IBM_CLOUD_URL', None)\n", (133, 156), False, 'import os\n'), ((170, 199), 'os.getenv', 'os.getenv', (['"""PROJECT_ID"""', 'None'], {}), "('PROJECT_ID', None)\n", (179, 199), False, 'import os\n'), ((228, 271), 'os.getenv', 'os.getenv', (['"""HUGGINGFACEHUB_API_TOKEN"""', 'None'], {}), "('HUGGINGFACEHUB_API_TOKEN', None)\n", (237, 271), False, 'import os\n'), ((3772, 3895), 'langchain.embeddings.HuggingFaceHubEmbeddings', 'HuggingFaceHubEmbeddings', ([], {'task': '"""feature-extraction"""', 'repo_id': 'repo_id', 'huggingfacehub_api_token': 'HUGGINGFACEHUB_API_TOKEN'}), "(task='feature-extraction', repo_id=repo_id,\n huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN)\n", (3796, 3895), False, 'from langchain.embeddings import HuggingFaceHubEmbeddings\n'), ((2763, 2813), 'genai.credentials.Credentials', 'Credentials', (['bam_api_key'], {'api_endpoint': 'bam_api_url'}), '(bam_api_key, api_endpoint=bam_api_url)\n', (2774, 2813), False, 'from genai.credentials import Credentials\n'), ((3465, 3560), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': 'model_id', 'credentials': 'creds', 'params': 'params', 'project_id': 'project_id'}), '(model=model_id, credentials=creds, params=params,\n project_id=project_id)\n', (3483, 3560), False, 'from genai.extensions.langchain import LangChainInterface\n'), ((3112, 3212), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': 'model_id', 'credentials': 'creds', 'params': 'params', 'callbacks': '[stream_handler]'}), '(model=model_id, credentials=creds, params=params,\n callbacks=[stream_handler])\n', (3130, 3212), False, 'from genai.extensions.langchain import LangChainInterface\n'), ((3319, 3387), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': 'model_id', 'credentials': 'creds', 'params': 'params'}), '(model=model_id, credentials=creds, params=params)\n', (3337, 3387), False, 'from genai.extensions.langchain import LangChainInterface\n')] |
from typing import Any, Dict, List, Optional
from .few_shot_agent import FewShotAgent
from .few_shot_agent import FewShotAgentExecutor
from langchain import LLMChain
from langchain.tools.base import BaseTool
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
from .prompts import *
import nest_asyncio
from .tools import *
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
import langchain
def _make_llm(model, temp, verbose):
if model.startswith("gpt-3.5-turbo") or model.startswith("gpt-4"):
llm = langchain.chat_models.ChatOpenAI(
temperature=temp,
model_name=model,
request_timeout=1000,
streaming=True if verbose else False,
callbacks=[StreamingStdOutCallbackHandler()] if verbose else [None],
)
elif model.startswith("text-"):
llm = langchain.OpenAI(
temperature=temp,
model_name=model,
streaming=True if verbose else False,
callbacks=[StreamingStdOutCallbackHandler()] if verbose else [None],
)
else:
raise ValueError(f"Invalid model name: {model}")
return llm
class ChemAgent:
def __init__(self,
tools: Sequence[BaseTool] = None,
model="gpt-3.5-turbo-0613",
analysis_model = "gpt-3.5-turbo-0613",
temp=0.1,
max_iterations=40,
verbose=True):
if tools is None:
tools = make_tools(model, verbose=verbose)
self.llm_lists = [_make_llm(model, temp, verbose=verbose),
_make_llm(analysis_model, temp, verbose=verbose)]
agent = FewShotAgent.from_llm_and_tools( # FewShotAgent里面包含多个LLMChain
llms=self.llm_lists,
tools=tools,
)
self.agent_executor = FewShotAgentExecutor.from_agent_and_tools(
agent = agent,
tools = tools,
verbose = verbose,
max_iterations = max_iterations,
return_intermediate_steps = True
)
nest_asyncio.apply() # Fix "this event loop is already running" error
def run(self, init_prompt):
outputs = self.agent_executor({"input": init_prompt}) # agent_executor是langchain Chain类的一个子类，有__call__方法
# Parse long output (with intermediate steps)
intermed = outputs["intermediate_steps"]
final = ""
for step in intermed:
final += f"Thought: {step[0].log}\n" f"Observation: {step[1]}\n"
final += f"Final Answer: {outputs['output']}"
final_answer = outputs['output']
return final_answer, final # final: 过程
| [
"langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler"
] | [((2122, 2142), 'nest_asyncio.apply', 'nest_asyncio.apply', ([], {}), '()\n', (2140, 2142), False, 'import nest_asyncio\n'), ((772, 804), 'langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler', 'StreamingStdOutCallbackHandler', ([], {}), '()\n', (802, 804), False, 'from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n'), ((1041, 1073), 'langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler', 'StreamingStdOutCallbackHandler', ([], {}), '()\n', (1071, 1073), False, 'from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n')] |
"""Base interface for large language models to expose."""
import inspect
import json
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
import yaml
from pydantic import Extra, Field, root_validator, validator
import langchain
from langchain.base_language import BaseLanguageModel
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForLLMRun,
CallbackManager,
CallbackManagerForLLMRun,
Callbacks,
)
from langchain.schema import (
AIMessage,
BaseMessage,
Generation,
LLMResult,
PromptValue,
get_buffer_string,
)
def _get_verbosity() -> bool:
return langchain.verbose
def get_prompts(
params: Dict[str, Any], prompts: List[str]
) -> Tuple[Dict[int, List], str, List[int], List[str]]:
"""Get prompts that are already cached."""
llm_string = str(sorted([(k, v) for k, v in params.items()]))
missing_prompts = []
missing_prompt_idxs = []
existing_prompts = {}
for i, prompt in enumerate(prompts):
if langchain.llm_cache is not None:
cache_val = langchain.llm_cache.lookup(prompt, llm_string)
if isinstance(cache_val, list):
existing_prompts[i] = cache_val
else:
missing_prompts.append(prompt)
missing_prompt_idxs.append(i)
return existing_prompts, llm_string, missing_prompt_idxs, missing_prompts
def update_cache(
existing_prompts: Dict[int, List],
llm_string: str,
missing_prompt_idxs: List[int],
new_results: LLMResult,
prompts: List[str],
) -> Optional[dict]:
"""Update the cache and get the LLM output."""
for i, result in enumerate(new_results.generations):
existing_prompts[missing_prompt_idxs[i]] = result
prompt = prompts[missing_prompt_idxs[i]]
if langchain.llm_cache is not None:
langchain.llm_cache.update(prompt, llm_string, result)
llm_output = new_results.llm_output
return llm_output
class BaseLLM(BaseLanguageModel, ABC):
"""LLM wrapper should take in a prompt and return a string."""
cache: Optional[bool] = None
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether to print out response text."""
callbacks: Callbacks = Field(default=None, exclude=True)
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@root_validator()
def raise_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@abstractmethod
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompts."""
@abstractmethod
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompts."""
def generate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return self.generate(prompt_strings, stop=stop, callbacks=callbacks)
async def agenerate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return await self.agenerate(prompt_strings, stop=stop, callbacks=callbacks)
def generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# If string is passed in directly no errors will be raised but outputs will
# not make sense.
if not isinstance(prompts, list):
raise ValueError(
"Argument 'prompts' is expected to be of type List[str], received"
f" argument of type {type(prompts)}."
)
params = self.dict()
params["stop"] = stop
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = CallbackManager.configure(
callbacks, self.callbacks, self.verbose
)
new_arg_supported = inspect.signature(self._generate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompts, invocation_params=params
)
try:
output = (
self._generate(prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._generate(prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(output)
return output
if len(missing_prompts) > 0:
run_manager = callback_manager.on_llm_start(
{"name": self.__class__.__name__},
missing_prompts,
invocation_params=params,
)
try:
new_results = (
self._generate(missing_prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._generate(missing_prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
else:
llm_output = {}
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output)
async def agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
params = self.dict()
params["stop"] = stop
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = AsyncCallbackManager.configure(
callbacks, self.callbacks, self.verbose
)
new_arg_supported = inspect.signature(self._agenerate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = await callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompts, invocation_params=params
)
try:
output = (
await self._agenerate(prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else await self._agenerate(prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e, verbose=self.verbose)
raise e
await run_manager.on_llm_end(output, verbose=self.verbose)
return output
if len(missing_prompts) > 0:
run_manager = await callback_manager.on_llm_start(
{"name": self.__class__.__name__},
missing_prompts,
invocation_params=params,
)
try:
new_results = (
await self._agenerate(
missing_prompts, stop=stop, run_manager=run_manager
)
if new_arg_supported
else await self._agenerate(missing_prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e)
raise e
await run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
else:
llm_output = {}
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output)
def __call__(
self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
if not isinstance(prompt, str):
raise ValueError(
"Argument `prompt` is expected to be a string. Instead found "
f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
"`generate` instead."
)
return (
self.generate([prompt], stop=stop, callbacks=callbacks)
.generations[0][0]
.text
)
async def _call_async(
self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
result = await self.agenerate([prompt], stop=stop, callbacks=callbacks)
return result.generations[0][0].text
def predict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return self(text, stop=_stop)
def predict_messages(
self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = self(text, stop=_stop)
return AIMessage(content=content)
async def apredict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return await self._call_async(text, stop=_stop)
async def apredict_messages(
self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = await self._call_async(text, stop=_stop)
return AIMessage(content=content)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {}
def __str__(self) -> str:
"""Get a string representation of the object for printing."""
cls_name = f"\033[1m{self.__class__.__name__}\033[0m"
return f"{cls_name}\nParams: {self._identifying_params}"
@property
@abstractmethod
def _llm_type(self) -> str:
"""Return type of llm."""
def dict(self, **kwargs: Any) -> Dict:
"""Return a dictionary of the LLM."""
starter_dict = dict(self._identifying_params)
starter_dict["_type"] = self._llm_type
return starter_dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the LLM.
Args:
file_path: Path to file to save the LLM to.
Example:
.. code-block:: python
llm.save(file_path="path/llm.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
prompt_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(prompt_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(prompt_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
class LLM(BaseLLM):
"""LLM class that expect subclasses to implement a simpler call method.
The purpose of this class is to expose a simpler interface for working
with LLMs, rather than expect the user to implement the full _generate method.
"""
@abstractmethod
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> str:
"""Run the LLM on the given prompt and input."""
async def _acall(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> str:
"""Run the LLM on the given prompt and input."""
raise NotImplementedError("Async generation not implemented for this LLM.")
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# TODO: add caching here.
generations = []
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
for prompt in prompts:
text = (
self._call(prompt, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._call(prompt, stop=stop)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
generations = []
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
for prompt in prompts:
text = (
await self._acall(prompt, stop=stop, run_manager=run_manager)
if new_arg_supported
else await self._acall(prompt, stop=stop)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
| [
"langchain.llm_cache.lookup",
"langchain.schema.Generation",
"langchain.schema.AIMessage",
"langchain.llm_cache.update",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.callbacks.manager.CallbackManager.configure",
"langchain.schema.LLMResult",
"langchain.schema.get_buffer_string"
] | [((2302, 2339), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2307, 2339), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2413, 2446), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2418, 2446), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2501, 2534), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2506, 2534), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2683, 2699), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (2697, 2699), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((3135, 3178), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (3144, 3178), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((5507, 5573), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose'], {}), '(callbacks, self.callbacks, self.verbose)\n', (5532, 5573), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((7567, 7624), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (7576, 7624), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((8170, 8241), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose'], {}), '(callbacks, self.callbacks, self.verbose)\n', (8200, 8241), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((10390, 10447), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (10399, 10447), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((11768, 11795), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (11785, 11795), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((11947, 11973), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (11956, 11973), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((12369, 12396), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (12386, 12396), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((12566, 12592), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (12575, 12592), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((15773, 15807), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (15782, 15807), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((16489, 16523), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (16498, 16523), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((1235, 1281), 'langchain.llm_cache.lookup', 'langchain.llm_cache.lookup', (['prompt', 'llm_string'], {}), '(prompt, llm_string)\n', (1261, 1281), False, 'import langchain\n'), ((2023, 2077), 'langchain.llm_cache.update', 'langchain.llm_cache.update', (['prompt', 'llm_string', 'result'], {}), '(prompt, llm_string, result)\n', (2049, 2077), False, 'import langchain\n'), ((2890, 2992), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (2903, 2992), False, 'import warnings\n'), ((13642, 13657), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (13646, 13657), False, 'from pathlib import Path\n'), ((13978, 14013), 'json.dump', 'json.dump', (['prompt_dict', 'f'], {'indent': '(4)'}), '(prompt_dict, f, indent=4)\n', (13987, 14013), False, 'import json\n'), ((5624, 5657), 'inspect.signature', 'inspect.signature', (['self._generate'], {}), '(self._generate)\n', (5641, 5657), False, 'import inspect\n'), ((8292, 8326), 'inspect.signature', 'inspect.signature', (['self._agenerate'], {}), '(self._agenerate)\n', (8309, 8326), False, 'import inspect\n'), ((14116, 14167), 'yaml.dump', 'yaml.dump', (['prompt_dict', 'f'], {'default_flow_style': '(False)'}), '(prompt_dict, f, default_flow_style=False)\n', (14125, 14167), False, 'import yaml\n'), ((15417, 15446), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (15434, 15446), False, 'import inspect\n'), ((15734, 15755), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (15744, 15755), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((16118, 16148), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (16135, 16148), False, 'import inspect\n'), ((16450, 16471), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (16460, 16471), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n')] |
from fastapi import FastAPI
from langchain import ConversationChain
from langchain.chat_models import ChatOpenAI
from scripts.utils import MEMORY
from scripts.doc_loader import load_document
from lanarky import LangchainRouter
from starlette.requests import Request
from starlette.templating import Jinja2Templates
from config import set_environment
set_environment()
app = FastAPI()
def create_chain():
return ConversationChain(
llm=ChatOpenAI(
temperature=0,
streaming=True,
),
verbose=True,
)
templates = Jinja2Templates(directory="serverside/templates")
chain = create_chain()
@app.get("/")
async def get(request: Request):
return templates.TemplateResponse("index.html", {"request": request})
langchain_router = LangchainRouter(
langchain_url="/chat", langchain_object=chain, streaming_mode=1
)
langchain_router.add_langchain_api_route(
"/chat_json", langchain_object=chain, streaming_mode=2
)
langchain_router.add_langchain_api_websocket_route("/ws", langchain_object=chain)
app.include_router(langchain_router)
@app.post('/')
async def post(user_question: str, files: List[UploadFile]):
for uploaded_file in files:
contents = await uploaded_file.read()
if not user_question:
raise HTTPException(status_code=400, detail="User question is required")
CONV_CHAIN = configure_retrieval_chain(files)
response = CONV_CHAIN.run({
"question": user_question,
"chat_history": MEMORY.chat_memory.messages
})
return {"response": response}
| [
"langchain.chat_models.ChatOpenAI"
] | [((352, 369), 'config.set_environment', 'set_environment', ([], {}), '()\n', (367, 369), False, 'from config import set_environment\n'), ((377, 386), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (384, 386), False, 'from fastapi import FastAPI\n'), ((570, 619), 'starlette.templating.Jinja2Templates', 'Jinja2Templates', ([], {'directory': '"""serverside/templates"""'}), "(directory='serverside/templates')\n", (585, 619), False, 'from starlette.templating import Jinja2Templates\n'), ((787, 872), 'lanarky.LangchainRouter', 'LangchainRouter', ([], {'langchain_url': '"""/chat"""', 'langchain_object': 'chain', 'streaming_mode': '(1)'}), "(langchain_url='/chat', langchain_object=chain, streaming_mode=1\n )\n", (802, 872), False, 'from lanarky import LangchainRouter\n'), ((450, 491), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'streaming': '(True)'}), '(temperature=0, streaming=True)\n', (460, 491), False, 'from langchain.chat_models import ChatOpenAI\n')] |
# %%
import torch
import os
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.huggingface import HuggingFaceInferenceAPI
from llama_index.core import Settings
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
from llama_index.embeddings.langchain import LangchainEmbedding
from llama_index.llms.llama_cpp.llama_utils import messages_to_prompt,completion_to_prompt
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core.node_parser import SentenceWindowNodeParser
from llama_index.core.postprocessor import MetadataReplacementPostProcessor
from llama_index.core import PromptTemplate
# %%
os.environ["HUGGINGFACEHUB_API_TOKEN"] = "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"
# %%
print("Please provide pdf file path:")
dir = str(input())
documents = SimpleDirectoryReader(input_dir=dir).load_data()
# %%
query_str = "I'm providing you with a research paper your job is to summarizes the information within it."
query_wrapper_prompt = PromptTemplate(
"Your job is to summarize different sections of the document given to you."
"Write a response that appropriately completes the request given to you.\n\n"
"### Instruction:\n{query_str}\n\n### Response:"
)
# %%
llm = HuggingFaceInferenceAPI(model_name="HuggingFaceH4/zephyr-7b-alpha")
# %%
embed_model = LangchainEmbedding(
HuggingFaceEmbeddings(model_name="BAAI/bge-base-en-v1.5")
)
# %%
Settings.llm = llm
Settings.node_parser = SentenceWindowNodeParser.from_defaults(
window_size=5,
window_metadata_key="window",
original_text_metadata_key="original_text").get_nodes_from_documents(documents)
Settings.text_splitter = SentenceSplitter(chunk_size=128,chunk_overlap=20)
Settings.embed_model = embed_model
# %%
index = VectorStoreIndex.from_documents(documents)
# %%
query_engine = index.as_query_engine(similarity_top_k=20,
verbose=True,
response_mode="tree_summarize",
node_postprocessor=[MetadataReplacementPostProcessor("window")])
print("Generating Sumaary")
response = query_engine.query("Generate a summary about the abstract.")
print(F"Abstract Summary: \n {response}")
print("\n")
# %%
response = query_engine.query("Generate a summary about the Methodology.")
print(F"Methodology Summary: \n {response}")
print("\n")
# %%
response = query_engine.query("Generate a summary about the Results and conclusion")
print(F"Result Summary: \n {response}")
| [
"langchain.embeddings.huggingface.HuggingFaceEmbeddings"
] | [((1018, 1239), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['"""Your job is to summarize different sections of the document given to you.Write a response that appropriately completes the request given to you.\n\n### Instruction:\n{query_str}\n\n### Response:"""'], {}), '(\n """Your job is to summarize different sections of the document given to you.Write a response that appropriately completes the request given to you.\n\n### Instruction:\n{query_str}\n\n### Response:"""\n )\n', (1032, 1239), False, 'from llama_index.core import PromptTemplate\n'), ((1263, 1330), 'llama_index.llms.huggingface.HuggingFaceInferenceAPI', 'HuggingFaceInferenceAPI', ([], {'model_name': '"""HuggingFaceH4/zephyr-7b-alpha"""'}), "(model_name='HuggingFaceH4/zephyr-7b-alpha')\n", (1286, 1330), False, 'from llama_index.llms.huggingface import HuggingFaceInferenceAPI\n'), ((1684, 1734), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {'chunk_size': '(128)', 'chunk_overlap': '(20)'}), '(chunk_size=128, chunk_overlap=20)\n', (1700, 1734), False, 'from llama_index.core.node_parser import SentenceSplitter\n'), ((1783, 1825), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (1814, 1825), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader\n'), ((1374, 1431), 'langchain.embeddings.huggingface.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""BAAI/bge-base-en-v1.5"""'}), "(model_name='BAAI/bge-base-en-v1.5')\n", (1395, 1431), False, 'from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n'), ((832, 868), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': 'dir'}), '(input_dir=dir)\n', (853, 868), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader\n'), ((1482, 1614), 'llama_index.core.node_parser.SentenceWindowNodeParser.from_defaults', 'SentenceWindowNodeParser.from_defaults', ([], {'window_size': '(5)', 'window_metadata_key': '"""window"""', 'original_text_metadata_key': '"""original_text"""'}), "(window_size=5, window_metadata_key=\n 'window', original_text_metadata_key='original_text')\n", (1520, 1614), False, 'from llama_index.core.node_parser import SentenceWindowNodeParser\n'), ((1968, 2010), 'llama_index.core.postprocessor.MetadataReplacementPostProcessor', 'MetadataReplacementPostProcessor', (['"""window"""'], {}), "('window')\n", (2000, 2010), False, 'from llama_index.core.postprocessor import MetadataReplacementPostProcessor\n')] |
import tempfile
from copy import deepcopy
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Sequence
import langchain
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.utils import (
BaseMetadataCallbackHandler,
flatten_dict,
import_pandas,
import_spacy,
import_textstat,
)
from langchain.schema import AgentAction, AgentFinish, Generation, LLMResult
LANGCHAIN_MODEL_NAME = "langchain-model"
def import_comet_ml() -> Any:
"""Import comet_ml and raise an error if it is not installed."""
try:
import comet_ml # noqa: F401
except ImportError:
raise ImportError(
"To use the comet_ml callback manager you need to have the "
"`comet_ml` python package installed. Please install it with"
" `pip install comet_ml`"
)
return comet_ml
def _get_experiment(
workspace: Optional[str] = None, project_name: Optional[str] = None
) -> Any:
comet_ml = import_comet_ml()
experiment = comet_ml.Experiment( # type: ignore
workspace=workspace,
project_name=project_name,
)
return experiment
def _fetch_text_complexity_metrics(text: str) -> dict:
textstat = import_textstat()
text_complexity_metrics = {
"flesch_reading_ease": textstat.flesch_reading_ease(text),
"flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
"smog_index": textstat.smog_index(text),
"coleman_liau_index": textstat.coleman_liau_index(text),
"automated_readability_index": textstat.automated_readability_index(text),
"dale_chall_readability_score": textstat.dale_chall_readability_score(text),
"difficult_words": textstat.difficult_words(text),
"linsear_write_formula": textstat.linsear_write_formula(text),
"gunning_fog": textstat.gunning_fog(text),
"text_standard": textstat.text_standard(text),
"fernandez_huerta": textstat.fernandez_huerta(text),
"szigriszt_pazos": textstat.szigriszt_pazos(text),
"gutierrez_polini": textstat.gutierrez_polini(text),
"crawford": textstat.crawford(text),
"gulpease_index": textstat.gulpease_index(text),
"osman": textstat.osman(text),
}
return text_complexity_metrics
def _summarize_metrics_for_generated_outputs(metrics: Sequence) -> dict:
pd = import_pandas()
metrics_df = pd.DataFrame(metrics)
metrics_summary = metrics_df.describe()
return metrics_summary.to_dict()
class CometCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
"""Callback Handler that logs to Comet.
Parameters:
job_type (str): The type of comet_ml task such as "inference",
"testing" or "qc"
project_name (str): The comet_ml project name
tags (list): Tags to add to the task
task_name (str): Name of the comet_ml task
visualize (bool): Whether to visualize the run.
complexity_metrics (bool): Whether to log complexity metrics
stream_logs (bool): Whether to stream callback actions to Comet
This handler will utilize the associated callback method and formats
the input of each callback function with metadata regarding the state of LLM run,
and adds the response to the list of records for both the {method}_records and
action. It then logs the response to Comet.
"""
def __init__(
self,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
stream_logs: bool = True,
) -> None:
"""Initialize callback handler."""
self.comet_ml = import_comet_ml()
super().__init__()
self.task_type = task_type
self.workspace = workspace
self.project_name = project_name
self.tags = tags
self.visualizations = visualizations
self.complexity_metrics = complexity_metrics
self.custom_metrics = custom_metrics
self.stream_logs = stream_logs
self.temp_dir = tempfile.TemporaryDirectory()
self.experiment = _get_experiment(workspace, project_name)
self.experiment.log_other("Created from", "langchain")
if tags:
self.experiment.add_tags(tags)
self.name = name
if self.name:
self.experiment.set_name(self.name)
warning = (
"The comet_ml callback is currently in beta and is subject to change "
"based on updates to `langchain`. Please report any issues to "
"https://github.com/comet-ml/issue-tracking/issues with the tag "
"`langchain`."
)
self.comet_ml.LOGGER.warning(warning)
self.callback_columns: list = []
self.action_records: list = []
self.complexity_metrics = complexity_metrics
if self.visualizations:
spacy = import_spacy()
self.nlp = spacy.load("en_core_web_sm")
else:
self.nlp = None
def _init_resp(self) -> Dict:
return {k: None for k in self.callback_columns}
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when LLM starts."""
self.step += 1
self.llm_starts += 1
self.starts += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_start"})
metadata.update(flatten_dict(serialized))
metadata.update(self.get_custom_callback_meta())
for prompt in prompts:
prompt_resp = deepcopy(metadata)
prompt_resp["prompts"] = prompt
self.on_llm_start_records.append(prompt_resp)
self.action_records.append(prompt_resp)
if self.stream_logs:
self._log_stream(prompt, metadata, self.step)
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run when LLM generates a new token."""
self.step += 1
self.llm_streams += 1
resp = self._init_resp()
resp.update({"action": "on_llm_new_token", "token": token})
resp.update(self.get_custom_callback_meta())
self.action_records.append(resp)
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when LLM ends running."""
self.step += 1
self.llm_ends += 1
self.ends += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_end"})
metadata.update(flatten_dict(response.llm_output or {}))
metadata.update(self.get_custom_callback_meta())
output_complexity_metrics = []
output_custom_metrics = []
for prompt_idx, generations in enumerate(response.generations):
for gen_idx, generation in enumerate(generations):
text = generation.text
generation_resp = deepcopy(metadata)
generation_resp.update(flatten_dict(generation.dict()))
complexity_metrics = self._get_complexity_metrics(text)
if complexity_metrics:
output_complexity_metrics.append(complexity_metrics)
generation_resp.update(complexity_metrics)
custom_metrics = self._get_custom_metrics(
generation, prompt_idx, gen_idx
)
if custom_metrics:
output_custom_metrics.append(custom_metrics)
generation_resp.update(custom_metrics)
if self.stream_logs:
self._log_stream(text, metadata, self.step)
self.action_records.append(generation_resp)
self.on_llm_end_records.append(generation_resp)
self._log_text_metrics(output_complexity_metrics, step=self.step)
self._log_text_metrics(output_custom_metrics, step=self.step)
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when LLM errors."""
self.step += 1
self.errors += 1
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Run when chain starts running."""
self.step += 1
self.chain_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_chain_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
for chain_input_key, chain_input_val in inputs.items():
if isinstance(chain_input_val, str):
input_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_input_val, resp, self.step)
input_resp.update({chain_input_key: chain_input_val})
self.action_records.append(input_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Input Value for {chain_input_key} will not be logged"
)
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Run when chain ends running."""
self.step += 1
self.chain_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_chain_end"})
resp.update(self.get_custom_callback_meta())
for chain_output_key, chain_output_val in outputs.items():
if isinstance(chain_output_val, str):
output_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_output_val, resp, self.step)
output_resp.update({chain_output_key: chain_output_val})
self.action_records.append(output_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Output Value for {chain_output_key} will not be logged"
)
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when chain errors."""
self.step += 1
self.errors += 1
def on_tool_start(
self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
) -> None:
"""Run when tool starts running."""
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_tool_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(input_str, resp, self.step)
resp.update({"input_str": input_str})
self.action_records.append(resp)
def on_tool_end(self, output: str, **kwargs: Any) -> None:
"""Run when tool ends running."""
self.step += 1
self.tool_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_tool_end"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when tool errors."""
self.step += 1
self.errors += 1
def on_text(self, text: str, **kwargs: Any) -> None:
"""
Run when agent is ending.
"""
self.step += 1
self.text_ctr += 1
resp = self._init_resp()
resp.update({"action": "on_text"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(text, resp, self.step)
resp.update({"text": text})
self.action_records.append(resp)
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run when agent ends running."""
self.step += 1
self.agent_ends += 1
self.ends += 1
resp = self._init_resp()
output = finish.return_values["output"]
log = finish.log
resp.update({"action": "on_agent_finish", "log": log})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
self.step += 1
self.tool_starts += 1
self.starts += 1
tool = action.tool
tool_input = str(action.tool_input)
log = action.log
resp = self._init_resp()
resp.update({"action": "on_agent_action", "log": log, "tool": tool})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(tool_input, resp, self.step)
resp.update({"tool_input": tool_input})
self.action_records.append(resp)
def _get_complexity_metrics(self, text: str) -> dict:
"""Compute text complexity metrics using textstat.
Parameters:
text (str): The text to analyze.
Returns:
(dict): A dictionary containing the complexity metrics.
"""
resp = {}
if self.complexity_metrics:
text_complexity_metrics = _fetch_text_complexity_metrics(text)
resp.update(text_complexity_metrics)
return resp
def _get_custom_metrics(
self, generation: Generation, prompt_idx: int, gen_idx: int
) -> dict:
"""Compute Custom Metrics for an LLM Generated Output
Args:
generation (LLMResult): Output generation from an LLM
prompt_idx (int): List index of the input prompt
gen_idx (int): List index of the generated output
Returns:
dict: A dictionary containing the custom metrics.
"""
resp = {}
if self.custom_metrics:
custom_metrics = self.custom_metrics(generation, prompt_idx, gen_idx)
resp.update(custom_metrics)
return resp
def flush_tracker(
self,
langchain_asset: Any = None,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = "comet-langchain-demo",
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
finish: bool = False,
reset: bool = False,
) -> None:
"""Flush the tracker and setup the session.
Everything after this will be a new table.
Args:
name: Name of the performed session so far so it is identifiable
langchain_asset: The langchain asset to save.
finish: Whether to finish the run.
Returns:
None
"""
self._log_session(langchain_asset)
if langchain_asset:
try:
self._log_model(langchain_asset)
except Exception:
self.comet_ml.LOGGER.error(
"Failed to export agent or LLM to Comet",
exc_info=True,
extra={"show_traceback": True},
)
if finish:
self.experiment.end()
if reset:
self._reset(
task_type,
workspace,
project_name,
tags,
name,
visualizations,
complexity_metrics,
custom_metrics,
)
def _log_stream(self, prompt: str, metadata: dict, step: int) -> None:
self.experiment.log_text(prompt, metadata=metadata, step=step)
def _log_model(self, langchain_asset: Any) -> None:
model_parameters = self._get_llm_parameters(langchain_asset)
self.experiment.log_parameters(model_parameters, prefix="model")
langchain_asset_path = Path(self.temp_dir.name, "model.json")
model_name = self.name if self.name else LANGCHAIN_MODEL_NAME
try:
if hasattr(langchain_asset, "save"):
langchain_asset.save(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
except (ValueError, AttributeError, NotImplementedError) as e:
if hasattr(langchain_asset, "save_agent"):
langchain_asset.save_agent(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
else:
self.comet_ml.LOGGER.error(
f"{e}"
" Could not save Langchain Asset "
f"for {langchain_asset.__class__.__name__}"
)
def _log_session(self, langchain_asset: Optional[Any] = None) -> None:
try:
llm_session_df = self._create_session_analysis_dataframe(langchain_asset)
# Log the cleaned dataframe as a table
self.experiment.log_table("langchain-llm-session.csv", llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
metadata = {"langchain_version": str(langchain.__version__)}
# Log the langchain low-level records as a JSON file directly
self.experiment.log_asset_data(
self.action_records, "langchain-action_records.json", metadata=metadata
)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
self._log_visualizations(llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log visualizations to Comet",
exc_info=True,
extra={"show_traceback": True},
)
def _log_text_metrics(self, metrics: Sequence[dict], step: int) -> None:
if not metrics:
return
metrics_summary = _summarize_metrics_for_generated_outputs(metrics)
for key, value in metrics_summary.items():
self.experiment.log_metrics(value, prefix=key, step=step)
def _log_visualizations(self, session_df: Any) -> None:
if not (self.visualizations and self.nlp):
return
spacy = import_spacy()
prompts = session_df["prompts"].tolist()
outputs = session_df["text"].tolist()
for idx, (prompt, output) in enumerate(zip(prompts, outputs)):
doc = self.nlp(output)
sentence_spans = list(doc.sents)
for visualization in self.visualizations:
try:
html = spacy.displacy.render(
sentence_spans,
style=visualization,
options={"compact": True},
jupyter=False,
page=True,
)
self.experiment.log_asset_data(
html,
name=f"langchain-viz-{visualization}-{idx}.html",
metadata={"prompt": prompt},
step=idx,
)
except Exception as e:
self.comet_ml.LOGGER.warning(
e, exc_info=True, extra={"show_traceback": True}
)
return
def _reset(
self,
task_type: Optional[str] = None,
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
) -> None:
_task_type = task_type if task_type else self.task_type
_workspace = workspace if workspace else self.workspace
_project_name = project_name if project_name else self.project_name
_tags = tags if tags else self.tags
_name = name if name else self.name
_visualizations = visualizations if visualizations else self.visualizations
_complexity_metrics = (
complexity_metrics if complexity_metrics else self.complexity_metrics
)
_custom_metrics = custom_metrics if custom_metrics else self.custom_metrics
self.__init__( # type: ignore
task_type=_task_type,
workspace=_workspace,
project_name=_project_name,
tags=_tags,
name=_name,
visualizations=_visualizations,
complexity_metrics=_complexity_metrics,
custom_metrics=_custom_metrics,
)
self.reset_callback_meta()
self.temp_dir = tempfile.TemporaryDirectory()
def _create_session_analysis_dataframe(self, langchain_asset: Any = None) -> dict:
pd = import_pandas()
llm_parameters = self._get_llm_parameters(langchain_asset)
num_generations_per_prompt = llm_parameters.get("n", 1)
llm_start_records_df = pd.DataFrame(self.on_llm_start_records)
# Repeat each input row based on the number of outputs generated per prompt
llm_start_records_df = llm_start_records_df.loc[
llm_start_records_df.index.repeat(num_generations_per_prompt)
].reset_index(drop=True)
llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
llm_session_df = pd.merge(
llm_start_records_df,
llm_end_records_df,
left_index=True,
right_index=True,
suffixes=["_llm_start", "_llm_end"],
)
return llm_session_df
def _get_llm_parameters(self, langchain_asset: Any = None) -> dict:
if not langchain_asset:
return {}
try:
if hasattr(langchain_asset, "agent"):
llm_parameters = langchain_asset.agent.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm_chain"):
llm_parameters = langchain_asset.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm"):
llm_parameters = langchain_asset.llm.dict()
else:
llm_parameters = langchain_asset.dict()
except Exception:
return {}
return llm_parameters
| [
"langchain.callbacks.utils.import_spacy",
"langchain.callbacks.utils.import_textstat",
"langchain.callbacks.utils.import_pandas",
"langchain.callbacks.utils.flatten_dict"
] | [((1047, 1114), 'comet_ml.Experiment', 'comet_ml.Experiment', ([], {'workspace': 'workspace', 'project_name': 'project_name'}), '(workspace=workspace, project_name=project_name)\n', (1066, 1114), False, 'import comet_ml\n'), ((1249, 1266), 'langchain.callbacks.utils.import_textstat', 'import_textstat', ([], {}), '()\n', (1264, 1266), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((2400, 2415), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (2413, 2415), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((4318, 4347), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (4345, 4347), False, 'import tempfile\n'), ((16471, 16509), 'pathlib.Path', 'Path', (['self.temp_dir.name', '"""model.json"""'], {}), "(self.temp_dir.name, 'model.json')\n", (16475, 16509), False, 'from pathlib import Path\n'), ((19081, 19095), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (19093, 19095), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((21551, 21580), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (21578, 21580), False, 'import tempfile\n'), ((21682, 21697), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (21695, 21697), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5161, 5175), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (5173, 5175), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5701, 5725), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (5713, 5725), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5842, 5860), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (5850, 5860), False, 'from copy import deepcopy\n'), ((6776, 6815), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['(response.llm_output or {})'], {}), '(response.llm_output or {})\n', (6788, 6815), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((8664, 8688), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (8676, 8688), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((10795, 10819), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (10807, 10819), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((7159, 7177), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (7167, 7177), False, 'from copy import deepcopy\n'), ((8886, 8900), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (8894, 8900), False, 'from copy import deepcopy\n'), ((9828, 9842), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (9836, 9842), False, 'from copy import deepcopy\n')] |
import streamlit as st
from langchain import PromptTemplate
from utils.studio_style import apply_studio_style
from utils.studio_style import keyword_label, sentiment_label
from utils import langchain
from utils import bedrock
from utils import config
from datetime import datetime
import pandas as pd
import json
import logging
st.set_page_config(
page_title="Summarize Product Reviews",
page_icon="🛒",
)
config.get_background()
# Read the CSV file
@st.cache_data
def load_data():
data = pd.read_csv("./data/amazon_vfl_reviews.csv")
return data
def display_product_review_summary(review):
with st.expander("See output"):
st.write(review)
# Claude v2.1 always returns text with json
try:
# Find the index of the first '{' and the last '}'
start_idx = review.index('{')
end_idx = review.rindex('}') + 1
# Extract the JSON string
json_string = review[start_idx:end_idx]
# Load JSON data
json_data = json.loads(json_string)
except json.JSONDecodeError:
print("Error decoding JSON.")
return 'Cannot summarize review'
#json_data = json.loads(review)
# Display the summary
st.subheader("Product Reviews Summary")
# Display the overall sentiment
formatted_sentiment = sentiment_label(json_data["overall_sentiment"], json_data["overall_sentiment"])
overall_sentiment =f'<div style="display: inline-block; margin:5px;"><b>Overall Sentiment</b> : {formatted_sentiment} </div>'
formatted_labels = [
sentiment_label(keyword_info["sentiment"],keyword_info["keyword"] )
for keyword_info in json_data["keywords_highlight"]
]
#st.write(' '.join(formatted_labels), unsafe_allow_html=True)
summary = f'{overall_sentiment}</br>{json_data["product_reviews_summary"]}</br></br>{"".join(formatted_labels)}'
styled_summary = f'<div class="output-text">{summary}</div>'
st.markdown(styled_summary, unsafe_allow_html=True)
# Your content and interactive elements for the Summarize Product Reviews page
def generate_review_summary (product_reviews, product_name):
if product_reviews is None:
return
product_reviews = f"""Product Name:{product_name}\n
Reviews: {product_reviews}
"""
map_prompt = """
Write a concise summary of the following product reviews:
"{text}"
CONCISE SUMMARY:
"""
map_prompt_template = PromptTemplate(template=map_prompt, input_variables=["text"])
combine_prompt = """
Generate summary about the reviews for [Product Name] based on Product reviews delimited by triple backquotes.
```{text}```
Also return overall_sentiment as 'POSITIVE', 'NEGATIVE' or 'MIXED' based on the review summary,
and generate maximum 5 most important keywords for the the given product reviews and based on reviews generate sentiment for each keyword.
The output should ALWAYS be valid JSON document with text inside the 'outputFormat' below, do NOT add any text in the output before JSON .
Don't include any preamble.
<outputFormat>
{{
"product_reviews_summary": "Maximum 200 words summary.",
"overall_sentiment": "POSITIVE or NEGATIVE or MIXED",
"keywords_highlight": [
{{"keyword": "Quality", "sentiment": "POSITIVE"}},
{{"keyword": "Affordability", "sentiment": "NEGATIVE"}},
{{"keyword": "Customer Service", "sentiment": "MIXED"}}
]
}}
</outputFormat>
"""
combine_prompt_template = PromptTemplate(template=combine_prompt, input_variables=["text"])
#modelId = 'amazon.titan-tg1-large'
# inference_config = {
# "maxTokenCount":3072,
# "stopSequences":[],
# "temperature":0,
# "topP":0.9
# }
#modelId = 'anthropic.claude-v1'
inference_config = {
"max_tokens_to_sample":4096,
"temperature":1,
"top_k":250,
"top_p":0.5,
"stop_sequences":[]
}
#print(f'Reviews:{product_reviews}')
summary = langchain.summarize_long_text(product_reviews, st.session_state.sm_assistant.boto3_bedrock, modelId, inference_config, map_prompt, combine_prompt)
display_product_review_summary(summary)
return summary
def style_figure_text(text):
return f'<div style="font-style:italic; font-size: 0.875em; text-align:center">{text}</div>'
def load_demo():
# Dropdown to select a product
selected_product = st.selectbox("Select Product for summarizing reviews:", [None] + list(unique_products), index=0)
if selected_product is not None:
# Filter data for the selected product
selected_data = data[data['name'] == selected_product]
# Sort data by date in descending order
selected_data = selected_data.sort_values(by='date', ascending=False)
# Function to load reviews for the selected product
def load_reviews(product_name):
filtered_data = selected_data[selected_data['name'] == product_name]
unique_reviews = filtered_data.drop_duplicates(subset='review')
return unique_reviews[['date', 'rating', 'review']]
#return selected_data[selected_data['name'] == product_name][['date', 'rating', 'review']]
# Load reviews for the selected product
reviews_df = load_reviews(selected_product)
# Display reviews in a scrollable container
if not reviews_df.empty:
# Show "Summarize Reviews" button
if st.button("Summarize Reviews"):
with st.spinner("Summarizing reviews..."):
# Concatenate reviews
combine_prompt = """
Write a concise summary of the following product reviews.
Return overall sentiment of the product reviews.
SUMMARY:
SENTIMENT:
"""
product_reviews = "\n".join(reviews_df['review'])
product_reviews = combine_prompt + product_reviews
summary = generate_review_summary(product_reviews, selected_product)
st.markdown("#### Product Reviews")
for _, row in reviews_df.iterrows():
st.write(f"Date: {row['date']}")
st.write(f"Rating: {row['rating']}")
st.write(f"Review: {row['review']}")
st.write("-" * 10)
else:
st.warning("No reviews available for the selected product.")
else:
st.info("Select a product to view its reviews.")
@st.cache_data
def load_arch():
st.write()
st.image('data/architecture/reviews_1.png')
st.markdown(
'''
When we work with large documents, we can face some challenges as the input text might not fit into the model context length, or the model hallucinates with large documents, or, out of memory errors, etc.
To solve those problems, we are going to show an architecture that is based on the concept of chunking and chaining prompts. This architecture is leveraging [LangChain](https://python.langchain.com/docs/get_started/introduction.html) which is a popular framework for developing applications powered by language models.
'''
)
st.image('data/architecture/reviews_2.png')
st.markdown(
'''
In this architecture:
1. A large document (or a giant file appending small ones) is loaded
2. Langchain utility is used to split it into multiple smaller chunks (chunking)
3. First chunk is sent to the model; Model returns the corresponding summary
4. Langchain gets next chunk and appends it to the returned summary and sends the combined text as a new request to the model; the process repeats until all chunks are processed
5. In the end, you have final summary based on entire content.
'''
)
st.markdown(
'''
**LangChain** `load_summarize_chain` provides three ways of summarization:
1. `stuff` puts all the chunks into one prompt. Thus, this would hit the maximum limit of tokens.
2. `map_reduce` summarizes each chunk on it's own in a "map" step, combines the summary, and summarizes the combined summary into a final summary in "reduce" step. If the combined summary is too large, it would raise error.
'''
)
st.markdown(style_figure_text('Figure Ref: <a href="https://python.langchain.com/docs/use_cases/summarization">LangChain Summarization Stuff & Map Reduce</a>')
, unsafe_allow_html=True)
st.image('data/architecture/summarization_lang_stuff_mapreduce.png')
st.markdown('3. `refine` summarizes the first chunk, and then summarizes the second chunk with the first summary. The same process repeats until all chunks are summarized.')
st.markdown(style_figure_text('Figure Ref: <a href="https://python.langchain.com/docs/modules/chains/document/refine">LangChain Refine Chain</a>')
, unsafe_allow_html=True)
st.image('data/architecture/summarization_lang_stuff_refine.png')
def main():
with demo:
load_demo()
with arch:
load_arch()
@st.cache_resource
def configure_logging():
print("init logger")
logger = logging.getLogger('retail_genai')
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())
st.session_state.logger = logger
return logger
if __name__ == "__main__":
st.title("Summarize Product Reviews")
#modelId = 'amazon.titan-tg1-xlarge'
modelId = 'anthropic.claude-v2:1'
#modelId = 'anthropic.claude-instant-v1'
data = load_data()
# Get unique product names
unique_products = data['name'].unique()
keywords = [f'Model Id: {modelId}','Amazon Bedrock API', 'Langchain']
formatted_labels = [keyword_label(keyword) for keyword in keywords]
st.write(' '.join(formatted_labels), unsafe_allow_html=True)
apply_studio_style()
# Add a description for this specific use case
st.markdown(
'''
#### Use Case:
###### Efficiently tackle the challenges of handling extensive product reviews with advanced summarization technique.
You can access the dataset used for this demo on Kaggle using the following link:
[Indian Products on Amazon](https://www.kaggle.com/datasets/nehaprabhavalkar/indian-products-on-amazon?resource=download)
1. **Product**: Select a product to summarize reviews for.
2. **Summarize Reviews**: Get Summary of reviews for the product. It will both summarize long product reviews, tell the sentiment & extract important keywords.
This architecture effective in summarizing diverse types of content, including call transcripts, meeting notes, books, articles, blog posts, and other relevant textual content. Whether you're dealing with customer feedback, evaluating product sentiment, or conducting in-depth analysis, our summarization technique can enhance your insights and decision-making processes.
'''
)
demo, arch, = st.tabs(["Demo", "Architecture"])
if "logger" not in st.session_state:
st.session_state.logger = configure_logging()
if "sm_assistant" not in st.session_state:
st.session_state.sm_assistant = bedrock.BedrockAssistant(modelId, st.session_state.logger)
main() | [
"langchain.PromptTemplate"
] | [((329, 402), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""Summarize Product Reviews"""', 'page_icon': '"""🛒"""'}), "(page_title='Summarize Product Reviews', page_icon='🛒')\n", (347, 402), True, 'import streamlit as st\n'), ((415, 438), 'utils.config.get_background', 'config.get_background', ([], {}), '()\n', (436, 438), False, 'from utils import config\n'), ((503, 547), 'pandas.read_csv', 'pd.read_csv', (['"""./data/amazon_vfl_reviews.csv"""'], {}), "('./data/amazon_vfl_reviews.csv')\n", (514, 547), True, 'import pandas as pd\n'), ((1220, 1259), 'streamlit.subheader', 'st.subheader', (['"""Product Reviews Summary"""'], {}), "('Product Reviews Summary')\n", (1232, 1259), True, 'import streamlit as st\n'), ((1324, 1403), 'utils.studio_style.sentiment_label', 'sentiment_label', (["json_data['overall_sentiment']", "json_data['overall_sentiment']"], {}), "(json_data['overall_sentiment'], json_data['overall_sentiment'])\n", (1339, 1403), False, 'from utils.studio_style import keyword_label, sentiment_label\n'), ((1966, 2017), 'streamlit.markdown', 'st.markdown', (['styled_summary'], {'unsafe_allow_html': '(True)'}), '(styled_summary, unsafe_allow_html=True)\n', (1977, 2017), True, 'import streamlit as st\n'), ((2463, 2524), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'template': 'map_prompt', 'input_variables': "['text']"}), "(template=map_prompt, input_variables=['text'])\n", (2477, 2524), False, 'from langchain import PromptTemplate\n'), ((3603, 3668), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'template': 'combine_prompt', 'input_variables': "['text']"}), "(template=combine_prompt, input_variables=['text'])\n", (3617, 3668), False, 'from langchain import PromptTemplate\n'), ((4353, 4508), 'utils.langchain.summarize_long_text', 'langchain.summarize_long_text', (['product_reviews', 'st.session_state.sm_assistant.boto3_bedrock', 'modelId', 'inference_config', 'map_prompt', 'combine_prompt'], {}), '(product_reviews, st.session_state.\n sm_assistant.boto3_bedrock, modelId, inference_config, map_prompt,\n combine_prompt)\n', (4382, 4508), False, 'from utils import langchain\n'), ((6926, 6936), 'streamlit.write', 'st.write', ([], {}), '()\n', (6934, 6936), True, 'import streamlit as st\n'), ((6942, 6985), 'streamlit.image', 'st.image', (['"""data/architecture/reviews_1.png"""'], {}), "('data/architecture/reviews_1.png')\n", (6950, 6985), True, 'import streamlit as st\n'), ((6990, 7569), 'streamlit.markdown', 'st.markdown', (['"""\n When we work with large documents, we can face some challenges as the input text might not fit into the model context length, or the model hallucinates with large documents, or, out of memory errors, etc.\n\n To solve those problems, we are going to show an architecture that is based on the concept of chunking and chaining prompts. This architecture is leveraging [LangChain](https://python.langchain.com/docs/get_started/introduction.html) which is a popular framework for developing applications powered by language models.\n """'], {}), '(\n """\n When we work with large documents, we can face some challenges as the input text might not fit into the model context length, or the model hallucinates with large documents, or, out of memory errors, etc.\n\n To solve those problems, we are going to show an architecture that is based on the concept of chunking and chaining prompts. This architecture is leveraging [LangChain](https://python.langchain.com/docs/get_started/introduction.html) which is a popular framework for developing applications powered by language models.\n """\n )\n', (7001, 7569), True, 'import streamlit as st\n'), ((7578, 7621), 'streamlit.image', 'st.image', (['"""data/architecture/reviews_2.png"""'], {}), "('data/architecture/reviews_2.png')\n", (7586, 7621), True, 'import streamlit as st\n'), ((7626, 8204), 'streamlit.markdown', 'st.markdown', (['"""\n In this architecture:\n\n 1. A large document (or a giant file appending small ones) is loaded\n 2. Langchain utility is used to split it into multiple smaller chunks (chunking)\n 3. First chunk is sent to the model; Model returns the corresponding summary\n 4. Langchain gets next chunk and appends it to the returned summary and sends the combined text as a new request to the model; the process repeats until all chunks are processed\n 5. In the end, you have final summary based on entire content.\n\n """'], {}), '(\n """\n In this architecture:\n\n 1. A large document (or a giant file appending small ones) is loaded\n 2. Langchain utility is used to split it into multiple smaller chunks (chunking)\n 3. First chunk is sent to the model; Model returns the corresponding summary\n 4. Langchain gets next chunk and appends it to the returned summary and sends the combined text as a new request to the model; the process repeats until all chunks are processed\n 5. In the end, you have final summary based on entire content.\n\n """\n )\n', (7637, 8204), True, 'import streamlit as st\n'), ((8213, 8673), 'streamlit.markdown', 'st.markdown', (['"""\n **LangChain** `load_summarize_chain` provides three ways of summarization:\n 1. `stuff` puts all the chunks into one prompt. Thus, this would hit the maximum limit of tokens.\n 2. `map_reduce` summarizes each chunk on it\'s own in a "map" step, combines the summary, and summarizes the combined summary into a final summary in "reduce" step. If the combined summary is too large, it would raise error.\n\n """'], {}), '(\n """\n **LangChain** `load_summarize_chain` provides three ways of summarization:\n 1. `stuff` puts all the chunks into one prompt. Thus, this would hit the maximum limit of tokens.\n 2. `map_reduce` summarizes each chunk on it\'s own in a "map" step, combines the summary, and summarizes the combined summary into a final summary in "reduce" step. If the combined summary is too large, it would raise error.\n\n """\n )\n', (8224, 8673), True, 'import streamlit as st\n'), ((8889, 8957), 'streamlit.image', 'st.image', (['"""data/architecture/summarization_lang_stuff_mapreduce.png"""'], {}), "('data/architecture/summarization_lang_stuff_mapreduce.png')\n", (8897, 8957), True, 'import streamlit as st\n'), ((8967, 9150), 'streamlit.markdown', 'st.markdown', (['"""3. `refine` summarizes the first chunk, and then summarizes the second chunk with the first summary. The same process repeats until all chunks are summarized."""'], {}), "(\n '3. `refine` summarizes the first chunk, and then summarizes the second chunk with the first summary. The same process repeats until all chunks are summarized.'\n )\n", (8978, 9150), True, 'import streamlit as st\n'), ((9338, 9403), 'streamlit.image', 'st.image', (['"""data/architecture/summarization_lang_stuff_refine.png"""'], {}), "('data/architecture/summarization_lang_stuff_refine.png')\n", (9346, 9403), True, 'import streamlit as st\n'), ((9575, 9608), 'logging.getLogger', 'logging.getLogger', (['"""retail_genai"""'], {}), "('retail_genai')\n", (9592, 9608), False, 'import logging\n'), ((9778, 9815), 'streamlit.title', 'st.title', (['"""Summarize Product Reviews"""'], {}), "('Summarize Product Reviews')\n", (9786, 9815), True, 'import streamlit as st\n'), ((10255, 10275), 'utils.studio_style.apply_studio_style', 'apply_studio_style', ([], {}), '()\n', (10273, 10275), False, 'from utils.studio_style import apply_studio_style\n'), ((10332, 11358), 'streamlit.markdown', 'st.markdown', (['"""\n #### Use Case: \n ###### Efficiently tackle the challenges of handling extensive product reviews with advanced summarization technique. \n You can access the dataset used for this demo on Kaggle using the following link:\n [Indian Products on Amazon](https://www.kaggle.com/datasets/nehaprabhavalkar/indian-products-on-amazon?resource=download)\n\n 1. **Product**: Select a product to summarize reviews for.\n 2. **Summarize Reviews**: Get Summary of reviews for the product. It will both summarize long product reviews, tell the sentiment & extract important keywords.\n\n This architecture effective in summarizing diverse types of content, including call transcripts, meeting notes, books, articles, blog posts, and other relevant textual content. Whether you\'re dealing with customer feedback, evaluating product sentiment, or conducting in-depth analysis, our summarization technique can enhance your insights and decision-making processes.\n """'], {}), '(\n """\n #### Use Case: \n ###### Efficiently tackle the challenges of handling extensive product reviews with advanced summarization technique. \n You can access the dataset used for this demo on Kaggle using the following link:\n [Indian Products on Amazon](https://www.kaggle.com/datasets/nehaprabhavalkar/indian-products-on-amazon?resource=download)\n\n 1. **Product**: Select a product to summarize reviews for.\n 2. **Summarize Reviews**: Get Summary of reviews for the product. It will both summarize long product reviews, tell the sentiment & extract important keywords.\n\n This architecture effective in summarizing diverse types of content, including call transcripts, meeting notes, books, articles, blog posts, and other relevant textual content. Whether you\'re dealing with customer feedback, evaluating product sentiment, or conducting in-depth analysis, our summarization technique can enhance your insights and decision-making processes.\n """\n )\n', (10343, 11358), True, 'import streamlit as st\n'), ((11383, 11416), 'streamlit.tabs', 'st.tabs', (["['Demo', 'Architecture']"], {}), "(['Demo', 'Architecture'])\n", (11390, 11416), True, 'import streamlit as st\n'), ((627, 652), 'streamlit.expander', 'st.expander', (['"""See output"""'], {}), "('See output')\n", (638, 652), True, 'import streamlit as st\n'), ((662, 678), 'streamlit.write', 'st.write', (['review'], {}), '(review)\n', (670, 678), True, 'import streamlit as st\n'), ((1016, 1039), 'json.loads', 'json.loads', (['json_string'], {}), '(json_string)\n', (1026, 1039), False, 'import json\n'), ((1569, 1636), 'utils.studio_style.sentiment_label', 'sentiment_label', (["keyword_info['sentiment']", "keyword_info['keyword']"], {}), "(keyword_info['sentiment'], keyword_info['keyword'])\n", (1584, 1636), False, 'from utils.studio_style import keyword_label, sentiment_label\n'), ((6840, 6888), 'streamlit.info', 'st.info', (['"""Select a product to view its reviews."""'], {}), "('Select a product to view its reviews.')\n", (6847, 6888), True, 'import streamlit as st\n'), ((9666, 9689), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (9687, 9689), False, 'import logging\n'), ((10138, 10160), 'utils.studio_style.keyword_label', 'keyword_label', (['keyword'], {}), '(keyword)\n', (10151, 10160), False, 'from utils.studio_style import keyword_label, sentiment_label\n'), ((11605, 11663), 'utils.bedrock.BedrockAssistant', 'bedrock.BedrockAssistant', (['modelId', 'st.session_state.logger'], {}), '(modelId, st.session_state.logger)\n', (11629, 11663), False, 'from utils import bedrock\n'), ((5811, 5841), 'streamlit.button', 'st.button', (['"""Summarize Reviews"""'], {}), "('Summarize Reviews')\n", (5820, 5841), True, 'import streamlit as st\n'), ((6459, 6494), 'streamlit.markdown', 'st.markdown', (['"""#### Product Reviews"""'], {}), "('#### Product Reviews')\n", (6470, 6494), True, 'import streamlit as st\n'), ((6761, 6821), 'streamlit.warning', 'st.warning', (['"""No reviews available for the selected product."""'], {}), "('No reviews available for the selected product.')\n", (6771, 6821), True, 'import streamlit as st\n'), ((6560, 6592), 'streamlit.write', 'st.write', (['f"""Date: {row[\'date\']}"""'], {}), '(f"Date: {row[\'date\']}")\n', (6568, 6592), True, 'import streamlit as st\n'), ((6609, 6645), 'streamlit.write', 'st.write', (['f"""Rating: {row[\'rating\']}"""'], {}), '(f"Rating: {row[\'rating\']}")\n', (6617, 6645), True, 'import streamlit as st\n'), ((6662, 6698), 'streamlit.write', 'st.write', (['f"""Review: {row[\'review\']}"""'], {}), '(f"Review: {row[\'review\']}")\n', (6670, 6698), True, 'import streamlit as st\n'), ((6715, 6733), 'streamlit.write', 'st.write', (["('-' * 10)"], {}), "('-' * 10)\n", (6723, 6733), True, 'import streamlit as st\n'), ((5864, 5900), 'streamlit.spinner', 'st.spinner', (['"""Summarizing reviews..."""'], {}), "('Summarizing reviews...')\n", (5874, 5900), True, 'import streamlit as st\n')] |
docs = """When and under what conditions can I apply to your graduate programs? Graduate student admissions are made in the fall and spring semesters specified in the academic calendar. Minimum application requirements:
To have the undergraduate degree required in the program application requirements To have at least 55 points from ALES in the field required in the program application conditions. For the PhD Program, getting at least 55 points from the Foreign Language Exam
Can I apply to more than one graduate program? You can apply to 1 Master's program without thesis and 1 Master's program with thesis or 1 Master's program without thesis and 1 PhD program.
Will I pay a fee for graduate programs? Master's and PhD programs with thesis are free of charge, but if you cannot graduate within the normal period, you will pay a fee until your maximum period expires.
Non-thesis Master's programs are paid and the total fee of our institute's programs is 5500.00 TL. It is collected in two equal installments at the beginning of the semester. Distance Education Non-Thesis Master's Degree programs are paid and the total fee is 6500,00 TL. It is collected in two equal installments at the beginning of the semester.
In non-thesis master's programs, free of charge for the relatives of martyrs and veterans, and for the disabled; discounts are made according to disability rates. The fee for the employees of the institution with a protocol in non-thesis master's programs is 3400TL.
The total fee for Aksaray University staff is 2000TL. How long is the military service deferment (extension) period for graduate programs? Does the institute do this process?
It is 1.5 years for non-thesis Master's programs, 3 years for Master's programs with thesis and 6 years for PhD programs. Our institute makes the deferment procedures within 1 month from the date of registration."""
with open("./AsuAI/FAQ-DeepL.txt", mode="r", encoding="utf-8") as file:
docs2 = file.read()
docs2_1 = docs2[:4000]
# api key
import os
from dotenv import load_dotenv
load_dotenv(".env")
api_key = os.environ.get("OPENAI_API_KEY")
import langchain
from langchain.cache import SQLiteCache
langchain.llm_cache = SQLiteCache(database_path=".langchain.db")
import deepl
from langchain.chat_models import ChatOpenAI
from langchain.document_loaders import WikipediaLoader
from langchain.prompts import (
ChatPromptTemplate,
HumanMessagePromptTemplate,
SystemMessagePromptTemplate,
)
auth_key = os.environ.get("DEEPL_API_KEY")
translator = deepl.Translator(auth_key)
## Connect OpenAI Model
model = ChatOpenAI(openai_api_key=api_key)
def answer_my_question(question, docs):
question = translator.translate_text(question, target_lang="EN-US")
print(question)
## Prompt - Format Question
template = "Answer this question:\n{question}\n Here is some extra context:\n{document}\n If the answer isn't in the context return 'I cannot find the answer.'."
human_prompt = HumanMessagePromptTemplate.from_template(template)
## Chat Prompt - Get Result Content
chat_prompt = ChatPromptTemplate.from_messages([human_prompt])
## Get Result
result = model(
chat_prompt.format_prompt(question=question, document=docs).to_messages()
)
return translator.translate_text(result.content, target_lang="TR")
import streamlit as st
st.title("Aksaray Üniversitesi AI Danışman")
question_text = st.text_area("Size nasıl yardımcı olabilirim?")
if st.button("Cevapla", type="primary"):
answer_text = answer_my_question(question=question_text, docs=docs2_1)
st.markdown(answer_text)
| [
"langchain.prompts.ChatPromptTemplate.from_messages",
"langchain.cache.SQLiteCache",
"langchain.prompts.HumanMessagePromptTemplate.from_template",
"langchain.chat_models.ChatOpenAI"
] | [((2056, 2075), 'dotenv.load_dotenv', 'load_dotenv', (['""".env"""'], {}), "('.env')\n", (2067, 2075), False, 'from dotenv import load_dotenv\n'), ((2086, 2118), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (2100, 2118), False, 'import os\n'), ((2200, 2242), 'langchain.cache.SQLiteCache', 'SQLiteCache', ([], {'database_path': '""".langchain.db"""'}), "(database_path='.langchain.db')\n", (2211, 2242), False, 'from langchain.cache import SQLiteCache\n'), ((2492, 2523), 'os.environ.get', 'os.environ.get', (['"""DEEPL_API_KEY"""'], {}), "('DEEPL_API_KEY')\n", (2506, 2523), False, 'import os\n'), ((2537, 2563), 'deepl.Translator', 'deepl.Translator', (['auth_key'], {}), '(auth_key)\n', (2553, 2563), False, 'import deepl\n'), ((2597, 2631), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': 'api_key'}), '(openai_api_key=api_key)\n', (2607, 2631), False, 'from langchain.chat_models import ChatOpenAI\n'), ((3368, 3412), 'streamlit.title', 'st.title', (['"""Aksaray Üniversitesi AI Danışman"""'], {}), "('Aksaray Üniversitesi AI Danışman')\n", (3376, 3412), True, 'import streamlit as st\n'), ((3429, 3476), 'streamlit.text_area', 'st.text_area', (['"""Size nasıl yardımcı olabilirim?"""'], {}), "('Size nasıl yardımcı olabilirim?')\n", (3441, 3476), True, 'import streamlit as st\n'), ((3481, 3517), 'streamlit.button', 'st.button', (['"""Cevapla"""'], {'type': '"""primary"""'}), "('Cevapla', type='primary')\n", (3490, 3517), True, 'import streamlit as st\n'), ((2984, 3034), 'langchain.prompts.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['template'], {}), '(template)\n', (3024, 3034), False, 'from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate\n'), ((3094, 3142), 'langchain.prompts.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (['[human_prompt]'], {}), '([human_prompt])\n', (3126, 3142), False, 'from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate\n'), ((3598, 3622), 'streamlit.markdown', 'st.markdown', (['answer_text'], {}), '(answer_text)\n', (3609, 3622), True, 'import streamlit as st\n')] |
from typing import List, Optional, Tuple, Dict, Callable, Any, Union
from functools import reduce
import os
import os
from pathlib import Path
import re
from .utils import maybe_is_text, maybe_is_truncated
from .qaprompts import (
summary_prompt,
qa_prompt,
search_prompt,
citation_prompt,
make_chain,
)
from dataclasses import dataclass
from .readers import read_doc
from langchain.vectorstores import FAISS
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.chat_models import ChatOpenAI
from langchain.llms.base import LLM
from langchain.chains import LLMChain
from langchain.callbacks import get_openai_callback
from langchain.cache import SQLiteCache
import langchain
from datetime import datetime
CACHE_PATH = Path.home() / ".paperqa" / "llm_cache.db"
os.makedirs(os.path.dirname(CACHE_PATH), exist_ok=True)
langchain.llm_cache = SQLiteCache(CACHE_PATH)
@dataclass
class Answer:
"""A class to hold the answer to a question."""
question: str
answer: str = ""
context: str = ""
contexts: List[Any] = None
references: str = ""
formatted_answer: str = ""
passages: Dict[str, str] = None
tokens: int = 0
question_embedding: List[float] = None
from_embed: bool = False
def __post_init__(self):
"""Initialize the answer."""
if self.contexts is None:
self.contexts = []
if self.passages is None:
self.passages = {}
def __str__(self) -> str:
"""Return the answer as a string."""
return self.formatted_answer
class Docs:
"""A collection of documents to be used for answering questions."""
def __init__(
self,
chunk_size_limit: int = 3000,
llm: Optional[Union[LLM, str]] = None,
summary_llm: Optional[Union[LLM, str]] = None,
name: str = "default",
index_path: Optional[Path] = None,
) -> None:
"""Initialize the collection of documents.
Args:
chunk_size_limit: The maximum number of characters to use for a single chunk of text.
llm: The language model to use for answering questions. Default - OpenAI chat-gpt-turbo
summary_llm: The language model to use for summarizing documents. If None, llm is used.
name: The name of the collection.
index_path: The path to the index file IF pickled. If None, defaults to using name in $HOME/.paperqa/name
"""
self.docs = dict() # self.docs[path] = dict(texts=texts, metadata=metadata, key=key)
self.chunk_size_limit = chunk_size_limit
self.keys = set()
self._faiss_index = None
self.update_llm(llm, summary_llm)
if index_path is None:
index_path = Path.home() / ".paperqa" / name
self.index_path = index_path
self.name = name
def update_llm(
self,
llm: Optional[Union[LLM, str]] = None,
summary_llm: Optional[Union[LLM, str]] = None,
) -> None:
"""Update the LLM for answering questions."""
if llm is None:
llm = "gpt-3.5-turbo"
if type(llm) is str:
llm = ChatOpenAI(temperature=0.1, model=llm)
if type(summary_llm) is str:
summary_llm = ChatOpenAI(temperature=0.1, model=summary_llm)
self.llm = llm
if summary_llm is None:
summary_llm = llm
self.summary_llm = summary_llm
self.summary_chain = make_chain(prompt=summary_prompt, llm=summary_llm)
self.qa_chain = make_chain(prompt=qa_prompt, llm=llm)
self.search_chain = make_chain(prompt=search_prompt, llm=summary_llm)
self.cite_chain = make_chain(prompt=citation_prompt, llm=summary_llm)
def add(
self,
path: str,
citation: Optional[str] = None,
key: Optional[str] = None,
disable_check: bool = False,
chunk_chars: Optional[int] = 3000,
) -> None:
"""Add a document to the collection."""
# first check to see if we already have this document
# this way we don't make api call to create citation on file we already have
if path in self.docs:
raise ValueError(f"Document {path} already in collection.")
if citation is None:
# peak first chunk
texts, _ = read_doc(path, "", "", chunk_chars=chunk_chars)
with get_openai_callback() as cb:
citation = self.cite_chain.run(texts[0])
if len(citation) < 3 or "Unknown" in citation or "insufficient" in citation:
citation = f"Unknown, {os.path.basename(path)}, {datetime.now().year}"
if key is None:
# get first name and year from citation
try:
author = re.search(r"([A-Z][a-z]+)", citation).group(1)
except AttributeError:
# panicking - no word??
raise ValueError(
f"Could not parse key from citation {citation}. Consider just passing key explicitly - e.g. docs.py (path, citation, key='mykey')"
)
try:
year = re.search(r"(\d{4})", citation).group(1)
except AttributeError:
year = ""
key = f"{author}{year}"
suffix = ""
while key + suffix in self.keys:
# move suffix to next letter
if suffix == "":
suffix = "a"
else:
suffix = chr(ord(suffix) + 1)
key += suffix
self.keys.add(key)
texts, metadata = read_doc(path, citation, key, chunk_chars=chunk_chars)
# loose check to see if document was loaded
if len("".join(texts)) < 10 or (
not disable_check and not maybe_is_text("".join(texts))
):
raise ValueError(
f"This does not look like a text document: {path}. Path disable_check to ignore this error."
)
self.docs[path] = dict(texts=texts, metadata=metadata, key=key)
if self._faiss_index is not None:
self._faiss_index.add_texts(texts, metadatas=metadata)
def add_from_embeddings(
self,
path: str,
texts,
text_embeddings: List[float],
metadatas
) -> None:
"""Add a document to the collection."""
# first check to see if we already have this document
# this way we don't make api call to create citation on file we already have
if path in self.docs:
raise ValueError(f"Document {path} already in collection.")
key = metadatas[0]['dockey']
suffix = ""
while key + suffix in self.keys:
# move suffix to next letter
if suffix == "":
suffix = "a"
else:
suffix = chr(ord(suffix) + 1)
key += suffix
self.keys.add(key)
if key != metadatas[0]['dockey']:
for j in range(len(metadatas)):
metadatas[j]['dockey'] = key
self.docs[path] = dict(texts=texts, metadata=metadatas, key=key)
if self._faiss_index is not None:
self._faiss_index.add_embeddings([*zip(texts, text_embeddings)],
metadatas=metadatas)
else:
"""Instantiate FAISS"""
self._faiss_index = FAISS.from_embeddings([*zip(texts, text_embeddings)],
metadatas=metadatas,
embedding=OpenAIEmbeddings())
def clear(self) -> None:
"""Clear the collection of documents."""
self.docs = dict()
self.keys = set()
self._faiss_index = None
# delete index file
pkl = self.index_path / "index.pkl"
if pkl.exists():
pkl.unlink()
fs = self.index_path / "index.faiss"
if fs.exists():
fs.unlink()
@property
def doc_previews(self) -> List[Tuple[int, str, str]]:
"""Return a list of tuples of (key, citation) for each document."""
return [
(
len(doc["texts"]),
doc["metadata"][0]["dockey"],
doc["metadata"][0]["citation"],
)
for doc in self.docs.values()
]
# to pickle, we have to save the index as a file
def __getstate__(self):
if self._faiss_index is None and len(self.docs) > 0:
self._build_faiss_index()
state = self.__dict__.copy()
if self._faiss_index is not None:
state["_faiss_index"].save_local(self.index_path)
del state["_faiss_index"]
# remove LLMs (they can have callbacks, which can't be pickled)
del state["summary_chain"]
del state["qa_chain"]
del state["cite_chain"]
del state["search_chain"]
return state
def __setstate__(self, state):
self.__dict__.update(state)
try:
self._faiss_index = FAISS.load_local(self.index_path, OpenAIEmbeddings())
except:
# they use some special exception type, but I don't want to import it
self._faiss_index = None
self.update_llm("gpt-3.5-turbo")
def _build_faiss_index(self):
if self._faiss_index is None:
texts = reduce(
lambda x, y: x + y, [doc["texts"] for doc in self.docs.values()], []
)
metadatas = reduce(
lambda x, y: x + y, [doc["metadata"] for doc in self.docs.values()], []
)
self._faiss_index = FAISS.from_texts(
texts, OpenAIEmbeddings(), metadatas=metadatas
)
def get_evidence(
self,
answer: Answer,
k: int = 3,
max_sources: int = 5,
marginal_relevance: bool = True,
key_filter: Optional[List[str]] = None,
) -> str:
if self._faiss_index is None:
self._build_faiss_index()
_k = k
if key_filter is not None:
_k = k * 10 # heuristic
# want to work through indices but less k
if marginal_relevance:
if not answer.from_embed:
docs = self._faiss_index.max_marginal_relevance_search(
answer.question, k=_k, fetch_k=5 * _k
)
else:
docs = self._faiss_index.max_marginal_relevance_search_by_vector(
answer.question_embedding, k=_k, fetch_k=5 * _k
)
else:
docs = self._faiss_index.similarity_search(
answer.question, k=_k, fetch_k=5 * _k
)
for doc in docs:
if key_filter is not None and doc.metadata["dockey"] not in key_filter:
continue
c = (
doc.metadata["key"],
doc.metadata["citation"],
self.summary_chain.run(
question=answer.question,
context_str=doc.page_content,
citation=doc.metadata["citation"],
),
doc.page_content,
)
if "Not applicable" not in c[2]:
answer.contexts.append(c)
yield answer
if len(answer.contexts) == max_sources:
break
context_str = "\n\n".join(
[f"{k}: {s}" for k, c, s, t in answer.contexts if "Not applicable" not in s]
)
valid_keys = [k for k, c, s, t in answer.contexts if "Not applicable" not in s]
if len(valid_keys) > 0:
context_str += "\n\nValid keys: " + ", ".join(valid_keys)
answer.context = context_str
yield answer
def generate_search_query(self, query: str) -> List[str]:
"""Generate a list of search strings that can be used to find
relevant papers.
Args:
query (str): The query to generate search strings for.
"""
search_query = self.search_chain.run(question=query)
queries = [s for s in search_query.split("\n") if len(s) > 3]
# remove 2., 3. from queries
queries = [re.sub(r"^\d+\.\s*", "", q) for q in queries]
return queries
def query_gen(
self,
query: str,
k: int = 10,
max_sources: int = 5,
length_prompt: str = "about 100 words",
marginal_relevance: bool = True,
):
yield from self._query(
query,
k=k,
max_sources=max_sources,
length_prompt=length_prompt,
marginal_relevance=marginal_relevance,
)
def query(
self,
query: str,
k: int = 10,
max_sources: int = 5,
length_prompt: str = "about 100 words",
marginal_relevance: bool = True,
embedding: Optional[List[float]] = None
):
for answer in self._query(
query,
k=k,
max_sources=max_sources,
length_prompt=length_prompt,
marginal_relevance=marginal_relevance,
embedding=embedding
):
pass
return answer
def _query(
self,
query: str,
k: int,
max_sources: int,
length_prompt: str,
marginal_relevance: bool,
embedding
):
if k < max_sources:
raise ValueError("k should be greater than max_sources")
tokens = 0
answer = Answer(query, question_embedding=embedding)
if embedding is not None:
answer.question_embedding = embedding
answer.from_embed = True
with get_openai_callback() as cb:
for answer in self.get_evidence(
answer,
k=k,
max_sources=max_sources,
marginal_relevance=marginal_relevance,
):
yield answer
tokens += cb.total_tokens
context_str, citations = answer.context, answer.contexts
bib = dict()
passages = dict()
if len(context_str) < 10:
answer_text = (
"I cannot answer this question due to insufficient information."
)
else:
with get_openai_callback() as cb:
answer_text = self.qa_chain.run(
question=query, context_str=context_str, length=length_prompt
)
tokens += cb.total_tokens
# it still happens lol
if "(Foo2012)" in answer_text:
answer_text = answer_text.replace("(Foo2012)", "")
for key, citation, summary, text in citations:
# do check for whole key (so we don't catch Callahan2019a with Callahan2019)
skey = key.split(" ")[0]
if skey + " " in answer_text or skey + ")" or skey + "," in answer_text:
bib[skey] = citation
passages[key] = text
bib_str = "\n\n".join(
[f"{i+1}. ({k}): {c}" for i, (k, c) in enumerate(bib.items())]
)
formatted_answer = f"Question: {query}\n\n{answer_text}\n"
if len(bib) > 0:
formatted_answer += f"\nReferences\n\n{bib_str}\n"
formatted_answer += f"\nTokens Used: {tokens} Cost: ${tokens/1000 * 0.002:.2f}"
answer.answer = answer_text
answer.formatted_answer = formatted_answer
answer.references = bib_str
answer.passages = passages
answer.tokens = tokens
yield answer
| [
"langchain.embeddings.openai.OpenAIEmbeddings",
"langchain.cache.SQLiteCache",
"langchain.chat_models.ChatOpenAI",
"langchain.callbacks.get_openai_callback"
] | [((906, 929), 'langchain.cache.SQLiteCache', 'SQLiteCache', (['CACHE_PATH'], {}), '(CACHE_PATH)\n', (917, 929), False, 'from langchain.cache import SQLiteCache\n'), ((839, 866), 'os.path.dirname', 'os.path.dirname', (['CACHE_PATH'], {}), '(CACHE_PATH)\n', (854, 866), False, 'import os\n'), ((784, 795), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (793, 795), False, 'from pathlib import Path\n'), ((3260, 3298), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0.1)', 'model': 'llm'}), '(temperature=0.1, model=llm)\n', (3270, 3298), False, 'from langchain.chat_models import ChatOpenAI\n'), ((3364, 3410), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0.1)', 'model': 'summary_llm'}), '(temperature=0.1, model=summary_llm)\n', (3374, 3410), False, 'from langchain.chat_models import ChatOpenAI\n'), ((12572, 12601), 're.sub', 're.sub', (['"""^\\\\d+\\\\.\\\\s*"""', '""""""', 'q'], {}), "('^\\\\d+\\\\.\\\\s*', '', q)\n", (12578, 12601), False, 'import re\n'), ((14124, 14145), 'langchain.callbacks.get_openai_callback', 'get_openai_callback', ([], {}), '()\n', (14143, 14145), False, 'from langchain.callbacks import get_openai_callback\n'), ((4525, 4546), 'langchain.callbacks.get_openai_callback', 'get_openai_callback', ([], {}), '()\n', (4544, 4546), False, 'from langchain.callbacks import get_openai_callback\n'), ((9363, 9381), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (9379, 9381), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((9981, 9999), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (9997, 9999), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((14738, 14759), 'langchain.callbacks.get_openai_callback', 'get_openai_callback', ([], {}), '()\n', (14757, 14759), False, 'from langchain.callbacks import get_openai_callback\n'), ((2842, 2853), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (2851, 2853), False, 'from pathlib import Path\n'), ((7812, 7830), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (7828, 7830), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((4742, 4764), 'os.path.basename', 'os.path.basename', (['path'], {}), '(path)\n', (4758, 4764), False, 'import os\n'), ((4914, 4950), 're.search', 're.search', (['"""([A-Z][a-z]+)"""', 'citation'], {}), "('([A-Z][a-z]+)', citation)\n", (4923, 4950), False, 'import re\n'), ((5286, 5317), 're.search', 're.search', (['"""(\\\\d{4})"""', 'citation'], {}), "('(\\\\d{4})', citation)\n", (5295, 5317), False, 'import re\n'), ((4768, 4782), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (4780, 4782), False, 'from datetime import datetime\n')] |
import io
import json
import time
from queue import Queue
from typing import Dict, List
import numpy as np
import tiktoken
from anyio.from_thread import start_blocking_portal
from django.conf import settings
from langchain.schema import AIMessage, HumanMessage
from openai import OpenAI
from pinecone import QueryResponse
from ayushma.models import ChatMessage
from ayushma.models.chat import Chat
from ayushma.models.document import Document
from ayushma.models.enums import ChatMessageType, ModelType
from ayushma.utils.langchain import LangChainHelper
from ayushma.utils.language_helpers import text_to_speech, translate_text
from core.settings.base import AI_NAME
# https://github.com/openai/openai-python/blob/main/openai/embeddings_utils.py#L65
def cosine_similarity(a, b):
a = np.array(a).reshape(-1)
b = np.array(b).reshape(-1)
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
def get_embedding(
text: List[str],
model: str = "text-embedding-ada-002",
openai_api_key: str = settings.OPENAI_API_KEY,
) -> List[List[float]]:
"""
Generates embeddings for the given list of texts using the OpenAI API.
Args:
text (List[str]): A list of strings to be embedded.
model (str, optional): The name of the OpenAI model to use for embedding.
Defaults to "text-embedding-ada-002".
Returns:
A list of embeddings generated by the OpenAI API for the input texts.
Raises:
OpenAIError: If there was an error communicating with the OpenAI API.
Example usage:
>>> get_embedding(["Hello, world!", "How are you?"])
[[-0.123, 0.456, 0.789, ...], [0.123, -0.456, 0.789, ...]]
"""
client = OpenAI(api_key=openai_api_key)
embedding_args: Dict[str, str | List[str]] = {"input": text}
if settings.OPENAI_API_TYPE == "azure":
embedding_args["engine"] = settings.AZURE_EMBEDDING_DEPLOYMENT
else:
embedding_args["model"] = model
res = client.embeddings.create(**embedding_args)
return [record.embedding for record in res.data]
def get_sanitized_reference(pinecone_references: List[QueryResponse]) -> str:
"""
Extracts the text from the Pinecone QueryResponse object and sanitizes it.
Args:
pinecone_reference (List[QueryResponse]): The similar documents retrieved from
the Pinecone index.
Returns:
A string containing the document id and text from the Pinecone QueryResponse object.
Example usage:
>>> get_sanitized_reference([QueryResponse(...), QueryResponse(...)])
"{'28': 'Hello how are you, I am fine, thank you.', '21': 'How was your day?, Mine was good.'}"
"""
sanitized_reference = {}
for reference in pinecone_references:
for match in reference.matches:
try:
document_id = str(match.metadata["document"])
text = str(match.metadata["text"]).replace("\n", " ") + ","
if document_id in sanitized_reference:
sanitized_reference[document_id] += text
else:
sanitized_reference[document_id] = text
except Exception as e:
print(e)
pass
return json.dumps(sanitized_reference)
def num_tokens_from_string(string: str, encoding_name: str) -> int:
"""Returns the number of tokens in a text string."""
encoding = tiktoken.get_encoding(encoding_name)
num_tokens = len(encoding.encode(string))
return num_tokens
def split_text(text):
"""Returns one string split into n equal length strings"""
n = len(text)
number_of_chars = 8192
parts = []
for i in range(0, n, number_of_chars):
part = text[i : i + number_of_chars]
parts.append(part)
return parts
def create_json_response(
input_text, chat_id, delta, message, stop, error, ayushma_voice
):
json_data = {
"chat": str(chat_id),
"input": input_text,
"delta": delta,
"message": message,
"stop": stop,
"error": error,
"ayushma_voice": ayushma_voice,
}
return "data: " + json.dumps(json_data) + "\n\n"
def get_reference(text, openai_key, namespace, top_k):
num_tokens = num_tokens_from_string(text, "cl100k_base")
embeddings: List[List[List[float]]] = []
if num_tokens < 8192:
try:
embeddings.append(get_embedding(text=[text], openai_api_key=openai_key))
except Exception as e:
return Exception(
e.__str__(),
)
else:
parts = split_text(text)
for part in parts:
try:
embeddings.append(get_embedding(text=[part], openai_api_key=openai_key))
except Exception as e:
raise Exception(
e.__str__(),
)
# find similar embeddings from pinecone index for each embedding
pinecone_references: List[QueryResponse] = []
for embedding in embeddings:
similar: QueryResponse = settings.PINECONE_INDEX_INSTANCE.query(
vector=embedding,
top_k=int(top_k),
namespace=namespace,
include_metadata=True,
)
pinecone_references.append(similar)
return get_sanitized_reference(pinecone_references=pinecone_references)
def add_reference_documents(chat_message):
ref_text = "References:"
chat_text = str(chat_message.original_message)
ref_start_idx = chat_text.find(ref_text)
if ref_start_idx == -1:
return
try:
doc_ids = chat_text[ref_start_idx + len(ref_text) :].split(",")
doc_ids = [doc_id.strip(" .,[]*'\"“”“\n-") for doc_id in doc_ids]
doc_ids = set([str(doc_id) for doc_id in doc_ids if doc_id != ""])
for doc_id in doc_ids:
try:
doc = Document.objects.get(external_id=doc_id)
chat_message.reference_documents.add(doc)
except Document.DoesNotExist:
pass
except Exception as e:
print("Error adding reference documents: ", e)
chat_message.original_message = chat_text[
:ref_start_idx
].strip() # Strip to remove empty line at the end \nRefereces:
chat_message.save()
def handle_post_response(
chat_response,
chat,
match_number,
user_language,
temperature,
stats,
language,
tts_engine,
generate_audio=True,
):
chat_message: ChatMessage = ChatMessage.objects.create(
original_message=chat_response,
chat=chat,
messageType=ChatMessageType.AYUSHMA,
top_k=match_number,
temperature=temperature,
language=language,
)
add_reference_documents(chat_message)
translated_chat_response = chat_message.original_message
if user_language != "en-IN":
stats["response_translation_start_time"] = time.time()
translated_chat_response = translate_text(
user_language, chat_message.original_message
)
stats["response_translation_end_time"] = time.time()
ayushma_voice = None
if generate_audio:
stats["tts_start_time"] = time.time()
ayushma_voice = text_to_speech(
translated_chat_response, user_language, tts_engine
)
stats["tts_end_time"] = time.time()
url = None
if ayushma_voice:
stats["upload_start_time"] = time.time()
chat_message.audio.save(
f"{chat_message.external_id}.mp3", io.BytesIO(ayushma_voice)
)
stats["upload_end_time"] = time.time()
chat_message.message = translated_chat_response
chat_message.meta = {
"translate_start": stats.get("response_translation_start_time"),
"translate_end": stats.get("response_translation_end_time"),
"reference_start": stats.get("reference_start_time"),
"reference_end": stats.get("reference_end_time"),
"response_start": stats.get("response_start_time"),
"response_end": stats.get("response_end_time"),
"tts_start": stats.get("tts_start_time"),
"tts_end": stats.get("tts_end_time"),
"upload_start": stats.get("upload_start_time"),
"upload_end": stats.get("upload_end_time"),
}
chat_message.save()
return translated_chat_response, url, chat_message
def converse(
english_text,
local_translated_text,
openai_key,
chat,
match_number,
user_language,
temperature,
stats={},
stream=True,
references=None,
generate_audio=True,
noonce=None,
fetch_references=True,
documents=None,
):
if not openai_key:
raise Exception("OpenAI-Key header is required to create a chat or converse")
english_text = english_text.replace("\n", " ")
language = user_language.split("-")[0]
nurse_query = ChatMessage.objects.create(
message=local_translated_text,
original_message=english_text,
chat=chat,
messageType=ChatMessageType.USER,
language=language,
meta={
"translate_start": stats.get("request_translation_start_time"),
"translate_end": stats.get("request_translation_end_time"),
},
noonce=noonce,
)
stats["reference_start_time"] = time.time()
if references:
reference = references
elif fetch_references and chat.project and chat.project.external_id:
try:
reference = get_reference(
english_text, openai_key, str(chat.project.external_id), match_number
)
except Exception as e:
print(e)
reference = ""
else:
reference = ""
stats["reference_end_time"] = time.time()
stats["response_start_time"] = time.time()
prompt = chat.prompt or (chat.project and chat.project.prompt)
if documents or chat.project.model == ModelType.GPT_4_VISUAL:
prompt = "Image Capabilities: Enabled\n" + prompt
# excluding the latest query since it is not a history
previous_messages = (
ChatMessage.objects.filter(chat=chat)
.exclude(id=nurse_query.id)
.order_by("created_at")
)
chat_history = []
for message in previous_messages:
if message.messageType == ChatMessageType.USER:
chat_history.append(HumanMessage(content=f"{message.message}"))
elif message.messageType == ChatMessageType.AYUSHMA:
chat_history.append(AIMessage(content=f"Ayushma: {message.message}"))
tts_engine = chat.project.tts_engine
if not stream:
lang_chain_helper = LangChainHelper(
stream=False,
openai_api_key=openai_key,
prompt_template=prompt,
model=chat.model
or (chat.project and chat.project.model)
or ModelType.GPT_3_5,
temperature=temperature,
)
response = lang_chain_helper.get_response(
english_text, reference, chat_history, documents
)
chat_response = response.replace("Ayushma: ", "")
stats["response_end_time"] = time.time()
translated_chat_response, url, chat_message = handle_post_response(
chat_response,
chat,
match_number,
user_language,
temperature,
stats,
language,
tts_engine,
generate_audio,
)
yield chat_message
else:
token_queue = Queue()
RESPONSE_END = object()
RESPONSE_ERROR = object()
try:
lang_chain_helper = LangChainHelper(
stream=stream,
token_queue=token_queue,
end=RESPONSE_END,
error=RESPONSE_ERROR,
openai_api_key=openai_key,
prompt_template=prompt,
model=chat.model
or (chat.project and chat.project.model)
or ModelType.GPT_3_5,
temperature=temperature,
)
with start_blocking_portal() as portal:
portal.start_task_soon(
lang_chain_helper.get_aresponse,
RESPONSE_END,
RESPONSE_ERROR,
token_queue,
english_text,
reference,
chat_history,
documents,
)
chat_response = ""
skip_token = len(f"{AI_NAME}: ")
while True:
if token_queue.empty():
continue
next_token = token_queue.get(True, timeout=10)
if next_token[0] == RESPONSE_ERROR:
raise next_token[1]
if next_token[0] is RESPONSE_END:
stats["response_end_time"] = time.time()
(
translated_chat_response,
url,
chat_message,
) = handle_post_response(
chat_response,
chat,
match_number,
user_language,
temperature,
stats,
language,
tts_engine,
generate_audio,
)
yield create_json_response(
local_translated_text,
chat.external_id,
"",
translated_chat_response,
True,
False,
ayushma_voice=url,
)
break
if skip_token > 0:
skip_token -= 1
continue
chat_response += next_token[0]
yield create_json_response(
local_translated_text,
chat.external_id,
next_token[0],
chat_response,
False,
False,
None,
)
except Exception as e:
print(e)
error_text = str(e)
translated_error_text = error_text
if user_language != "en-IN":
translated_error_text = translate_text(user_language, error_text)
ChatMessage.objects.create(
message=translated_error_text,
original_message=error_text,
chat=chat,
messageType=ChatMessageType.SYSTEM,
language=language,
meta={
"translate_start": stats.get("response_translation_start_time"),
"translate_end": stats.get("response_translation_end_time"),
"reference_start": stats.get("reference_start_time"),
"reference_end": stats.get("reference_end_time"),
"response_start": stats.get("response_start_time"),
"response_end": stats.get("response_end_time"),
"tts_start": stats.get("tts_start_time"),
"tts_end": stats.get("tts_end_time"),
"upload_start": stats.get("upload_start_time"),
"upload_end": stats.get("upload_end_time"),
},
)
yield create_json_response(
local_translated_text, chat.external_id, "", str(e), True, True, None
)
def converse_thread(
english_text,
thread: Chat,
openai_key,
):
client = OpenAI(api_key=openai_key)
if not thread.thread_id:
thread_id = client.beta.threads.create().id
thread.thread_id = thread_id
thread.save()
client.beta.threads.messages.create(
thread_id=thread.thread_id, content=english_text, role="user"
)
run_id = client.beta.threads.runs.create(
thread_id=thread.thread_id, assistant_id=thread.project.assistant_id
).id
retires = 60
while retires > 0:
retires -= 1
time.sleep(1)
status = client.beta.threads.runs.retrieve(
run_id=run_id, thread_id=thread.thread_id
).status
if status == "completed":
break
else:
raise Exception("Thread timed out")
response = (
client.beta.threads.messages.list(thread_id=thread.thread_id)
.data[0]
.content[0]
.text.value
)
return response
| [
"langchain.schema.AIMessage",
"langchain.schema.HumanMessage"
] | [((1714, 1744), 'openai.OpenAI', 'OpenAI', ([], {'api_key': 'openai_api_key'}), '(api_key=openai_api_key)\n', (1720, 1744), False, 'from openai import OpenAI\n'), ((3257, 3288), 'json.dumps', 'json.dumps', (['sanitized_reference'], {}), '(sanitized_reference)\n', (3267, 3288), False, 'import json\n'), ((3431, 3467), 'tiktoken.get_encoding', 'tiktoken.get_encoding', (['encoding_name'], {}), '(encoding_name)\n', (3452, 3467), False, 'import tiktoken\n'), ((6494, 6673), 'ayushma.models.ChatMessage.objects.create', 'ChatMessage.objects.create', ([], {'original_message': 'chat_response', 'chat': 'chat', 'messageType': 'ChatMessageType.AYUSHMA', 'top_k': 'match_number', 'temperature': 'temperature', 'language': 'language'}), '(original_message=chat_response, chat=chat,\n messageType=ChatMessageType.AYUSHMA, top_k=match_number, temperature=\n temperature, language=language)\n', (6520, 6673), False, 'from ayushma.models import ChatMessage\n'), ((7082, 7093), 'time.time', 'time.time', ([], {}), '()\n', (7091, 7093), False, 'import time\n'), ((9284, 9295), 'time.time', 'time.time', ([], {}), '()\n', (9293, 9295), False, 'import time\n'), ((9719, 9730), 'time.time', 'time.time', ([], {}), '()\n', (9728, 9730), False, 'import time\n'), ((9767, 9778), 'time.time', 'time.time', ([], {}), '()\n', (9776, 9778), False, 'import time\n'), ((15876, 15902), 'openai.OpenAI', 'OpenAI', ([], {'api_key': 'openai_key'}), '(api_key=openai_key)\n', (15882, 15902), False, 'from openai import OpenAI\n'), ((860, 872), 'numpy.dot', 'np.dot', (['a', 'b'], {}), '(a, b)\n', (866, 872), True, 'import numpy as np\n'), ((6907, 6918), 'time.time', 'time.time', ([], {}), '()\n', (6916, 6918), False, 'import time\n'), ((6954, 7014), 'ayushma.utils.language_helpers.translate_text', 'translate_text', (['user_language', 'chat_message.original_message'], {}), '(user_language, chat_message.original_message)\n', (6968, 7014), False, 'from ayushma.utils.language_helpers import text_to_speech, translate_text\n'), ((7177, 7188), 'time.time', 'time.time', ([], {}), '()\n', (7186, 7188), False, 'import time\n'), ((7213, 7280), 'ayushma.utils.language_helpers.text_to_speech', 'text_to_speech', (['translated_chat_response', 'user_language', 'tts_engine'], {}), '(translated_chat_response, user_language, tts_engine)\n', (7227, 7280), False, 'from ayushma.utils.language_helpers import text_to_speech, translate_text\n'), ((7335, 7346), 'time.time', 'time.time', ([], {}), '()\n', (7344, 7346), False, 'import time\n'), ((7422, 7433), 'time.time', 'time.time', ([], {}), '()\n', (7431, 7433), False, 'import time\n'), ((7585, 7596), 'time.time', 'time.time', ([], {}), '()\n', (7594, 7596), False, 'import time\n'), ((10603, 10795), 'ayushma.utils.langchain.LangChainHelper', 'LangChainHelper', ([], {'stream': '(False)', 'openai_api_key': 'openai_key', 'prompt_template': 'prompt', 'model': '(chat.model or chat.project and chat.project.model or ModelType.GPT_3_5)', 'temperature': 'temperature'}), '(stream=False, openai_api_key=openai_key, prompt_template=\n prompt, model=chat.model or chat.project and chat.project.model or\n ModelType.GPT_3_5, temperature=temperature)\n', (10618, 10795), False, 'from ayushma.utils.langchain import LangChainHelper\n'), ((11101, 11112), 'time.time', 'time.time', ([], {}), '()\n', (11110, 11112), False, 'import time\n'), ((11476, 11483), 'queue.Queue', 'Queue', ([], {}), '()\n', (11481, 11483), False, 'from queue import Queue\n'), ((16366, 16379), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (16376, 16379), False, 'import time\n'), ((792, 803), 'numpy.array', 'np.array', (['a'], {}), '(a)\n', (800, 803), True, 'import numpy as np\n'), ((824, 835), 'numpy.array', 'np.array', (['b'], {}), '(b)\n', (832, 835), True, 'import numpy as np\n'), ((876, 893), 'numpy.linalg.norm', 'np.linalg.norm', (['a'], {}), '(a)\n', (890, 893), True, 'import numpy as np\n'), ((896, 913), 'numpy.linalg.norm', 'np.linalg.norm', (['b'], {}), '(b)\n', (910, 913), True, 'import numpy as np\n'), ((4160, 4181), 'json.dumps', 'json.dumps', (['json_data'], {}), '(json_data)\n', (4170, 4181), False, 'import json\n'), ((7514, 7539), 'io.BytesIO', 'io.BytesIO', (['ayushma_voice'], {}), '(ayushma_voice)\n', (7524, 7539), False, 'import io\n'), ((11596, 11858), 'ayushma.utils.langchain.LangChainHelper', 'LangChainHelper', ([], {'stream': 'stream', 'token_queue': 'token_queue', 'end': 'RESPONSE_END', 'error': 'RESPONSE_ERROR', 'openai_api_key': 'openai_key', 'prompt_template': 'prompt', 'model': '(chat.model or chat.project and chat.project.model or ModelType.GPT_3_5)', 'temperature': 'temperature'}), '(stream=stream, token_queue=token_queue, end=RESPONSE_END,\n error=RESPONSE_ERROR, openai_api_key=openai_key, prompt_template=prompt,\n model=chat.model or chat.project and chat.project.model or ModelType.\n GPT_3_5, temperature=temperature)\n', (11611, 11858), False, 'from ayushma.utils.langchain import LangChainHelper\n'), ((5875, 5915), 'ayushma.models.document.Document.objects.get', 'Document.objects.get', ([], {'external_id': 'doc_id'}), '(external_id=doc_id)\n', (5895, 5915), False, 'from ayushma.models.document import Document\n'), ((10326, 10368), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'f"""{message.message}"""'}), "(content=f'{message.message}')\n", (10338, 10368), False, 'from langchain.schema import AIMessage, HumanMessage\n'), ((12040, 12063), 'anyio.from_thread.start_blocking_portal', 'start_blocking_portal', ([], {}), '()\n', (12061, 12063), False, 'from anyio.from_thread import start_blocking_portal\n'), ((10066, 10103), 'ayushma.models.ChatMessage.objects.filter', 'ChatMessage.objects.filter', ([], {'chat': 'chat'}), '(chat=chat)\n', (10092, 10103), False, 'from ayushma.models import ChatMessage\n'), ((10463, 10511), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'f"""Ayushma: {message.message}"""'}), "(content=f'Ayushma: {message.message}')\n", (10472, 10511), False, 'from langchain.schema import AIMessage, HumanMessage\n'), ((14598, 14639), 'ayushma.utils.language_helpers.translate_text', 'translate_text', (['user_language', 'error_text'], {}), '(user_language, error_text)\n', (14612, 14639), False, 'from ayushma.utils.language_helpers import text_to_speech, translate_text\n'), ((12883, 12894), 'time.time', 'time.time', ([], {}), '()\n', (12892, 12894), False, 'import time\n')] |
import json
import os
import langchain.memory.entity
from langchain.chat_models import AzureChatOpenAI
from flask import Flask, request
import httpx
from dotenv import load_dotenv
from langchain.memory import ConversationSummaryBufferMemory, ConversationBufferWindowMemory
from langchain.prompts.prompt import PromptTemplate
from langchain import LLMChain
from tools import searchTravelPol
import myjson
from langchain.prompts import (
ChatPromptTemplate,
MessagesPlaceholder,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)
app = Flask(__name__)
load_dotenv(dotenv_path='./config.env')
# 初始化AzureOpenAI和其他相关组件
llm = AzureChatOpenAI(
api_version="2023-12-01-preview",
azure_endpoint=os.getenv("AZURE_ENDPOINT"),
api_key=os.getenv("AZURE_OPENAI_KEY"),
azure_deployment='test',
http_client=httpx.Client(
proxies="http://localhost:7890",
transport=httpx.HTTPTransport(local_address="0.0.0.0"),
verify=False
)
)
def getGptResponse(data):
"""
获取GPT生成的旅行建议
:param data: 包含旅行信息的字典
:return: GPT生成的旅行建议
"""
# 系统指令
systemCommands = """"作为旅行规划助手，''你的任务是接收关于旅客类型、预算水平、旅行日期和兴趣的信息，并按json格式回答。并按时间顺序规划景点("
"不需要规划高铁站飞机站等地点）。请一定注意点之间不要离得太远''请你规划的时候查询该地区在网上热门的景点," "并选取一个作为出发点。尽量避免音译错误同时你要关注的是整体景点而非其内部的具体地点,例如：一定不要推荐山东大学("
"威海校区)-孔子像这种内部景点，而是要推荐山东大学(威海校区）这种整体景点。最关键的更新是，你现在只需以特定的JSON格式回复规划好的行程，而不提供规划过程的详细描述。你的回复应严格遵循以下json格式：'\n\n"
"{{\"YYYY-MM-DD\":[\n{{\"name\": \"景点A\",\"兴趣点类型\":\"景点\"}},\n{{\"name\":
\"景点B\",\"兴趣点类型\":\"景点\"}},\n " "{{\"name\": \"景点C\",\"兴趣点类型\":\"景点\"}}],\n
" "\"YYYY-MM-DD\":[\n {{\"name\": \"景点A\",\"兴趣点类型\":\"景点\"}},\n {{\"name\":
\"景点B\",\"兴趣点类型\":\"景点\"}},\n" "{{\"name\": \"景点C\",\"兴趣点类型\":\"景点\"}}],\n
" "\"// 更多日期 \"]}}"""
# 从输入数据中获取所需信息
selectedTraveler = data.get('destination')
startDate = data.get('startDate')
endDate = data.get('endDate')
travelDestination = data.get('customerType')
selectedInterests = ', '.join(data.get('tag', []))
selectedBudget = data.get('budget')
# 构建人类输入字符串
humanInput = f"旅客类型:{selectedTraveler}, 旅行时间:{startDate} - {endDate}, 旅行城市:{travelDestination}, 旅客兴趣:{selectedInterests}, 预算水平:{selectedBudget}"
memory = ConversationBufferWindowMemory(llm=llm, k=2, memory_key="chat_history",return_messages=True)
# 设置GPT生成的prompt模板
prompt = ChatPromptTemplate(
messages=[
SystemMessagePromptTemplate.from_template(systemCommands),
# The `variable_name` here is what must align with memory
MessagesPlaceholder(variable_name="chat_history"),
HumanMessagePromptTemplate.from_template("{humanInput}")
]
)
# 初始化LLMChain
llmChain = LLMChain(
llm=llm,
prompt=prompt,
verbose=True,
memory=memory
)
# llmChain.predict(humanInput=humanInput)
#为节省api费用使用的测试数据
memory.chat_memory.add_user_message(
f"旅客类型:{selectedTraveler}, 旅行时间:{startDate}--{endDate}, "
f"旅行城市:{travelDestination}, 旅客兴趣:{selectedInterests}, 预算水平:{selectedBudget}"
)
memory.chat_memory.add_ai_message('''
{
"2024-01-21": [
{"name": "泸州长江大桥", "兴趣点类型": "景点"},
{"name": "四川省泸州市泸州老窖集团", "兴趣点类型": "景点"},
{"name": "蜀南竹海", "兴趣点类型": "景点"}
],
"2024-01-22": [
{"name": "泸州白塔公园", "兴趣点类型": "景点"},
{"name": "江阳区龙马潭", "兴趣点类型": "景点"},
{"name": "泸州古蔺沱江戏水公园", "兴趣点类型": "景点"}
],
"2024-01-23": [
{"name": "泸州国窖酒文化城", "兴趣点类型": "景点"},
{"name": "泸州雒城历史文化街区", "兴趣点类型": "景点"},
{"name": "泸州市博物馆", "兴趣点类型": "景点"}
]
}
''')
print(memory.chat_memory.messages[-1].content)
return memory.chat_memory.messages[-1].content
@app.route('/generatePlanner', methods=['POST'])
def generatePlanner():
"""
处理POST请求，生成旅行计划。
:return: 包含生成的旅行计划的JSON响应
"""
# 从请求中获取JSON数据
data = request.get_json()
# 调用getGptResponse函数获取GPT生成的旅行建议
gptResponse = getGptResponse(data)
# 获取旅行城市信息
city = data.get('travelPurpose')
# 调用getMatpData函数获取旅行兴趣点的详细信息
result = getMatpData(gptResponse, city)
if "error" in result:
return myjson.makeReponse(code="500", message="失败", data=result)
else:
return myjson.makeReponse(code="200", message="成功", data=result)
def getMatpData(data, city):
"""
使用高德api获取旅行兴趣点的详细信息，并组织成新的数据结构
:param data: 包含旅行兴趣点信息的JSON字符串
:param city: 旅行的城市
:return: 包含详细信息的新数据结构
"""
# 将JSON字符串解析为Python字典
try:
# 尝试解析 JSON 字符串
data = json.loads(data)
except json.decoder.JSONDecodeError as e:
error_message = f"Error decoding JSON: {e}"
print(error_message)
return {"error": error_message}
# 存储新的响应结构
new_response = {}
# 遍历日期和兴趣点信息
for date, places in data.items():
# 初始化每个日期的新结构
new_response[date] = []
# 遍历每个兴趣点信息
for place in places:
# 提取兴趣点的名称和类型
name = place['name']
posType = place['兴趣点类型']
# 调用高德api获取兴趣点的详细信息
detailedInfo = searchTravelPol(name, city, posType)
# 解析详细信息的JSON字符串
detailedInfo = json.loads(detailedInfo)['pois'][0]
# 需要过滤的字段
fieldsToRemove = ['parent', 'distance', 'id']
# 过滤详细信息中的特定字段
for field in fieldsToRemove:
detailedInfo.pop(field, None)
# 将详细信息添加到新结构中
new_response[date].append(detailedInfo)
return new_response
@app.route('/chat', methods=['POST'])
def chat():
# 提示词模板
template = """"你是一个聊天助手小明"
{chat_history}
Human: {human_input}
Chatbot:"""
memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=300, memory_key="chat_history")
# 从请求中获取JSON数据
data = request.get_data()
data = json.loads(data)
data = data['ask']
print(data)
humanInput = data
# 设置GPT生成的prompt模板
prompt = PromptTemplate(
input_variables=["chat_history", "human_input"],
template=template
)
llmChain = LLMChain(
llm=llm,
prompt=prompt,
verbose=True,
memory=memory
)
llmChain.predict(human_input=humanInput)
if "error" in data:
return myjson.makeReponse(code="500", message="失败", data=memory.chat_memory.messages[-1].content)
else:
return myjson.makeReponse(code="200", message="成功", data=memory.chat_memory.messages[-1].content)
# @app.route('/generateFreeModeTravelItinerary', methods=['POST'])
# def generateFreeModeTravelItinerary():
# langchain.memory.entity.RedisEntityStore()
if __name__ == '__main__':
app.run(debug=True, host='172.29.20.72')
| [
"langchain.prompts.SystemMessagePromptTemplate.from_template",
"langchain.memory.ConversationSummaryBufferMemory",
"langchain.prompts.HumanMessagePromptTemplate.from_template",
"langchain.prompts.prompt.PromptTemplate",
"langchain.memory.ConversationBufferWindowMemory",
"langchain.prompts.MessagesPlaceholder",
"langchain.LLMChain"
] | [((560, 575), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (565, 575), False, 'from flask import Flask, request\n'), ((576, 615), 'dotenv.load_dotenv', 'load_dotenv', ([], {'dotenv_path': '"""./config.env"""'}), "(dotenv_path='./config.env')\n", (587, 615), False, 'from dotenv import load_dotenv\n'), ((2291, 2388), 'langchain.memory.ConversationBufferWindowMemory', 'ConversationBufferWindowMemory', ([], {'llm': 'llm', 'k': '(2)', 'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(llm=llm, k=2, memory_key='chat_history',\n return_messages=True)\n", (2321, 2388), False, 'from langchain.memory import ConversationSummaryBufferMemory, ConversationBufferWindowMemory\n'), ((2782, 2843), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt', 'verbose': '(True)', 'memory': 'memory'}), '(llm=llm, prompt=prompt, verbose=True, memory=memory)\n', (2790, 2843), False, 'from langchain import LLMChain\n'), ((4021, 4039), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (4037, 4039), False, 'from flask import Flask, request\n'), ((5797, 5890), 'langchain.memory.ConversationSummaryBufferMemory', 'ConversationSummaryBufferMemory', ([], {'llm': 'llm', 'max_token_limit': '(300)', 'memory_key': '"""chat_history"""'}), "(llm=llm, max_token_limit=300, memory_key=\n 'chat_history')\n", (5828, 5890), False, 'from langchain.memory import ConversationSummaryBufferMemory, ConversationBufferWindowMemory\n'), ((5916, 5934), 'flask.request.get_data', 'request.get_data', ([], {}), '()\n', (5932, 5934), False, 'from flask import Flask, request\n'), ((5946, 5962), 'json.loads', 'json.loads', (['data'], {}), '(data)\n', (5956, 5962), False, 'import json\n'), ((6060, 6147), 'langchain.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['chat_history', 'human_input']", 'template': 'template'}), "(input_variables=['chat_history', 'human_input'], template=\n template)\n", (6074, 6147), False, 'from langchain.prompts.prompt import PromptTemplate\n'), ((6180, 6241), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt', 'verbose': '(True)', 'memory': 'memory'}), '(llm=llm, prompt=prompt, verbose=True, memory=memory)\n', (6188, 6241), False, 'from langchain import LLMChain\n'), ((720, 747), 'os.getenv', 'os.getenv', (['"""AZURE_ENDPOINT"""'], {}), "('AZURE_ENDPOINT')\n", (729, 747), False, 'import os\n'), ((761, 790), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_KEY"""'], {}), "('AZURE_OPENAI_KEY')\n", (770, 790), False, 'import os\n'), ((4288, 4345), 'myjson.makeReponse', 'myjson.makeReponse', ([], {'code': '"""500"""', 'message': '"""失败"""', 'data': 'result'}), "(code='500', message='失败', data=result)\n", (4306, 4345), False, 'import myjson\n'), ((4371, 4428), 'myjson.makeReponse', 'myjson.makeReponse', ([], {'code': '"""200"""', 'message': '"""成功"""', 'data': 'result'}), "(code='200', message='成功', data=result)\n", (4389, 4428), False, 'import myjson\n'), ((4669, 4685), 'json.loads', 'json.loads', (['data'], {}), '(data)\n', (4679, 4685), False, 'import json\n'), ((6364, 6459), 'myjson.makeReponse', 'myjson.makeReponse', ([], {'code': '"""500"""', 'message': '"""失败"""', 'data': 'memory.chat_memory.messages[-1].content'}), "(code='500', message='失败', data=memory.chat_memory.\n messages[-1].content)\n", (6382, 6459), False, 'import myjson\n'), ((6480, 6575), 'myjson.makeReponse', 'myjson.makeReponse', ([], {'code': '"""200"""', 'message': '"""成功"""', 'data': 'memory.chat_memory.messages[-1].content'}), "(code='200', message='成功', data=memory.chat_memory.\n messages[-1].content)\n", (6498, 6575), False, 'import myjson\n'), ((5203, 5239), 'tools.searchTravelPol', 'searchTravelPol', (['name', 'city', 'posType'], {}), '(name, city, posType)\n', (5218, 5239), False, 'from tools import searchTravelPol\n'), ((910, 954), 'httpx.HTTPTransport', 'httpx.HTTPTransport', ([], {'local_address': '"""0.0.0.0"""'}), "(local_address='0.0.0.0')\n", (929, 954), False, 'import httpx\n'), ((2471, 2528), 'langchain.prompts.SystemMessagePromptTemplate.from_template', 'SystemMessagePromptTemplate.from_template', (['systemCommands'], {}), '(systemCommands)\n', (2512, 2528), False, 'from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((2612, 2661), 'langchain.prompts.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': '"""chat_history"""'}), "(variable_name='chat_history')\n", (2631, 2661), False, 'from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((2675, 2731), 'langchain.prompts.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['"""{humanInput}"""'], {}), "('{humanInput}')\n", (2715, 2731), False, 'from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((5296, 5320), 'json.loads', 'json.loads', (['detailedInfo'], {}), '(detailedInfo)\n', (5306, 5320), False, 'import json\n')] |
"""Utilities for running language models or Chains over datasets."""
from __future__ import annotations
import asyncio
import functools
import itertools
import logging
import uuid
from enum import Enum
from typing import (
Any,
Callable,
Coroutine,
Dict,
Iterator,
List,
Optional,
Sequence,
Tuple,
Union,
)
from urllib.parse import urlparse, urlunparse
from langsmith import Client, RunEvaluator
from langsmith.schemas import Dataset, DataType, Example
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.manager import Callbacks
from langchain.callbacks.tracers.base import BaseTracer
from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler
from langchain.callbacks.tracers.langchain import LangChainTracer
from langchain.chains.base import Chain
from langchain.chat_models.openai import ChatOpenAI
from langchain.evaluation.loading import load_evaluator
from langchain.evaluation.schema import EvaluatorType, StringEvaluator
from langchain.schema import ChatResult, LLMResult
from langchain.schema.language_model import BaseLanguageModel
from langchain.schema.messages import BaseMessage, messages_from_dict
from langchain.smith.evaluation.config import EvalConfig, RunEvalConfig
from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain
logger = logging.getLogger(__name__)
MODEL_OR_CHAIN_FACTORY = Union[Callable[[], Chain], BaseLanguageModel]
class InputFormatError(Exception):
"""Raised when the input format is invalid."""
## Shared Utilities
def _get_eval_project_url(api_url: str, project_id: str) -> str:
"""Get the project url from the api url."""
parsed = urlparse(api_url)
hostname = parsed.hostname or ""
if "api." in hostname:
hostname = hostname.replace("api.", "", 1)
if "localhost" in hostname:
# Remove the port
hostname = "localhost"
url = urlunparse(parsed._replace(netloc=hostname))
return f"{url}/projects/p/{project_id}?eval=true"
def _wrap_in_chain_factory(
llm_or_chain_factory: Union[Chain, MODEL_OR_CHAIN_FACTORY],
dataset_name: str = "<my_dataset>",
) -> MODEL_OR_CHAIN_FACTORY:
"""Forgive the user if they pass in a chain without memory instead of a chain
factory. It's a common mistake. Raise a more helpful error message as well."""
if isinstance(llm_or_chain_factory, Chain):
chain = llm_or_chain_factory
chain_class = chain.__class__.__name__
if llm_or_chain_factory.memory is not None:
memory_class = chain.memory.__class__.__name__
raise ValueError(
"Cannot directly evaluate a chain with stateful memory."
" To evaluate this chain, pass in a chain constructor"
" that initializes fresh memory each time it is called."
" This will safegaurd against information"
" leakage between dataset examples."
"\nFor example:\n\n"
"def chain_constructor():\n"
f" new_memory = {memory_class}(...)\n"
f" return {chain_class}"
"(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
logger.warning(
"Directly passing in a chain is not recommended as chains may have state."
" This can lead to unexpected behavior as the "
"same chain instance could be used across multiple datasets. Instead,"
" please pass a chain constructor that creates a new "
"chain with fresh memory each time it is called. This will safeguard"
" against information leakage between dataset examples. "
"\nFor example:\n\n"
"def chain_constructor():\n"
f" return {chain_class}(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
return lambda: chain
elif isinstance(llm_or_chain_factory, BaseLanguageModel):
return llm_or_chain_factory
elif callable(llm_or_chain_factory):
_model = llm_or_chain_factory()
if isinstance(_model, BaseLanguageModel):
return _model
return llm_or_chain_factory
return llm_or_chain_factory
def _first_example(examples: Iterator[Example]) -> Tuple[Example, Iterator[Example]]:
"""Get the first example while chaining it back and preserving the iterator."""
try:
example: Example = next(examples)
except StopIteration:
raise ValueError("No examples provided.")
return example, itertools.chain([example], examples)
def _get_prompt(inputs: Dict[str, Any]) -> str:
"""Get prompt from inputs.
Args:
inputs: The input dictionary.
Returns:
A string prompt.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
prompts = []
if "prompt" in inputs:
if not isinstance(inputs["prompt"], str):
raise InputFormatError(
"Expected string for 'prompt', got"
f" {type(inputs['prompt']).__name__}"
)
prompts = [inputs["prompt"]]
elif "prompts" in inputs:
if not isinstance(inputs["prompts"], list) or not all(
isinstance(i, str) for i in inputs["prompts"]
):
raise InputFormatError(
"Expected list of strings for 'prompts',"
f" got {type(inputs['prompts']).__name__}"
)
prompts = inputs["prompts"]
elif len(inputs) == 1:
prompt_ = next(iter(inputs.values()))
if isinstance(prompt_, str):
prompts = [prompt_]
elif isinstance(prompt_, list) and all(isinstance(i, str) for i in prompt_):
prompts = prompt_
else:
raise InputFormatError(f"LLM Run expects string prompt input. Got {inputs}")
else:
raise InputFormatError(
f"LLM Run expects 'prompt' or 'prompts' in inputs. Got {inputs}"
)
if len(prompts) == 1:
return prompts[0]
else:
raise InputFormatError(
f"LLM Run expects single prompt input. Got {len(prompts)} prompts."
)
def _get_messages(inputs: Dict[str, Any]) -> List[BaseMessage]:
"""Get Chat Messages from inputs.
Args:
inputs: The input dictionary.
Returns:
A list of chat messages.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
if "messages" in inputs:
single_input = inputs["messages"]
elif len(inputs) == 1:
single_input = next(iter(inputs.values()))
else:
raise InputFormatError(
f"Chat Run expects 'messages' in inputs when example has multiple"
f" input keys. Got {inputs}"
)
if isinstance(single_input, list) and all(
isinstance(i, dict) for i in single_input
):
raw_messages = [single_input]
elif isinstance(single_input, list) and all(
isinstance(i, list) for i in single_input
):
raw_messages = single_input
else:
raise InputFormatError(
f"Chat Run expects List[dict] or List[List[dict]] values for"
f" 'messages' key input. Got {inputs}"
)
if len(raw_messages) == 1:
return messages_from_dict(raw_messages[0])
else:
raise InputFormatError(
f"Chat Run expects single List[dict] or List[List[dict]] 'messages'"
f" input. Got {len(raw_messages)} messages from inputs {inputs}"
)
def _get_project_name(
project_name: Optional[str],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
) -> str:
"""
Get the project name.
Args:
project_name: The project name if manually specified.
llm_or_chain_factory: The Chain or language model constructor.
Returns:
The project name.
"""
if project_name is not None:
return project_name
if isinstance(llm_or_chain_factory, BaseLanguageModel):
model_name = llm_or_chain_factory.__class__.__name__
else:
model_name = llm_or_chain_factory().__class__.__name__
hex = uuid.uuid4().hex
return f"{hex}-{model_name}"
## Shared Validation Utilities
def _validate_example_inputs_for_language_model(
first_example: Example,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
if input_mapper:
prompt_input = input_mapper(first_example.inputs)
if not isinstance(prompt_input, str) and not (
isinstance(prompt_input, list)
and all(isinstance(msg, BaseMessage) for msg in prompt_input)
):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for an LLM or chat model, the output must a single string or"
" a list of chat messages."
f"\nGot: {prompt_input} of type {type(prompt_input)}."
)
else:
try:
_get_prompt(first_example.inputs)
except InputFormatError:
try:
_get_messages(first_example.inputs)
except InputFormatError:
raise InputFormatError(
"Example inputs do not match language model input format. "
"Expected a dictionary with messages or a single prompt."
f" Got: {first_example.inputs}"
" Please update your dataset OR provide an input_mapper"
" to convert the example.inputs to a compatible format"
" for the llm or chat model you wish to evaluate."
)
def _validate_example_inputs_for_chain(
first_example: Example,
chain: Chain,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs match the chain input keys."""
if input_mapper:
first_inputs = input_mapper(first_example.inputs)
if not isinstance(first_inputs, dict):
raise InputFormatError(
"When using an input_mapper to prepare dataset example"
" inputs for a chain, the mapped value must be a dictionary."
f"\nGot: {first_inputs} of type {type(first_inputs)}."
)
if not set(first_inputs.keys()) == set(chain.input_keys):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for a chain mapped value must have keys that match the chain's"
" expected input keys."
f"\nExpected: {chain.input_keys}. Got: {first_inputs.keys()}"
)
else:
first_inputs = first_example.inputs
if len(first_inputs) == 1 and len(chain.input_keys) == 1:
# We can pass this through the run method.
# Refrain from calling to validate.
pass
elif not set(first_inputs.keys()) == set(chain.input_keys):
raise InputFormatError(
"Example inputs do not match chain input keys."
" Please provide an input_mapper to convert the example.inputs"
" to a compatible format for the chain you wish to evaluate."
f"Expected: {chain.input_keys}. "
f"Got: {first_inputs.keys()}"
)
def _validate_example_inputs(
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
input_mapper: Optional[Callable[[Dict], Any]],
) -> Iterator[Example]:
"""Validate that the example inputs are valid for the model."""
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
_validate_example_inputs_for_language_model(first_example, input_mapper)
else:
chain = llm_or_chain_factory()
_validate_example_inputs_for_chain(first_example, chain, input_mapper)
return examples
## Shared Evaluator Setup Utilities
def _setup_evaluation(
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
examples: Iterator[Example],
evaluation: Optional[RunEvalConfig],
data_type: DataType,
) -> Tuple[Optional[List[RunEvaluator]], Iterator[Example]]:
"""Configure the evaluators to run on the results of the chain."""
if evaluation:
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
run_inputs, run_outputs = None, None
run_type = "llm"
else:
run_type = "chain"
if data_type in (DataType.chat, DataType.llm):
val = data_type.value if isinstance(data_type, Enum) else data_type
raise ValueError(
"Cannot evaluate a chain on dataset with "
f"data_type={val}. "
"Please specify a dataset with the default 'kv' data type."
)
chain = llm_or_chain_factory()
run_inputs = chain.input_keys
run_outputs = chain.output_keys
run_evaluators = _load_run_evaluators(
evaluation,
run_type,
data_type,
list(first_example.outputs) if first_example.outputs else None,
run_inputs,
run_outputs,
)
else:
# TODO: Create a default helpfulness evaluator
run_evaluators = None
return run_evaluators, examples
def _determine_input_key(
config: RunEvalConfig,
run_inputs: Optional[List[str]],
run_type: str,
) -> Optional[str]:
if config.input_key:
input_key = config.input_key
if run_inputs and input_key not in run_inputs:
raise ValueError(f"Input key {input_key} not in run inputs {run_inputs}")
elif run_type == "llm":
input_key = None
elif run_inputs and len(run_inputs) == 1:
input_key = run_inputs[0]
else:
raise ValueError(
f"Must specify input key for model with multiple inputs: {run_inputs}"
)
return input_key
def _determine_prediction_key(
config: RunEvalConfig,
run_outputs: Optional[List[str]],
run_type: str,
) -> Optional[str]:
if config.prediction_key:
prediction_key = config.prediction_key
if run_outputs and prediction_key not in run_outputs:
raise ValueError(
f"Prediction key {prediction_key} not in run outputs {run_outputs}"
)
elif run_type == "llm":
prediction_key = None
elif run_outputs and len(run_outputs) == 1:
prediction_key = run_outputs[0]
else:
raise ValueError(
f"Must specify prediction key for model"
f" with multiple outputs: {run_outputs}"
)
return prediction_key
def _determine_reference_key(
config: RunEvalConfig,
example_outputs: Optional[List[str]],
) -> Optional[str]:
if config.reference_key:
reference_key = config.reference_key
if example_outputs and reference_key not in example_outputs:
raise ValueError(
f"Reference key {reference_key} not in Dataset"
f" example outputs: {example_outputs}"
)
elif example_outputs and len(example_outputs) == 1:
reference_key = list(example_outputs)[0]
else:
reference_key = None
return reference_key
def _construct_run_evaluator(
eval_config: Union[EvaluatorType, EvalConfig],
eval_llm: BaseLanguageModel,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
reference_key: Optional[str],
input_key: Optional[str],
prediction_key: Optional[str],
) -> RunEvaluator:
if isinstance(eval_config, EvaluatorType):
evaluator_ = load_evaluator(eval_config, llm=eval_llm)
eval_type_tag = eval_config.value
else:
kwargs = {"llm": eval_llm, **eval_config.get_kwargs()}
evaluator_ = load_evaluator(eval_config.evaluator_type, **kwargs)
eval_type_tag = eval_config.evaluator_type.value
if isinstance(evaluator_, StringEvaluator):
if evaluator_.requires_reference and reference_key is None:
raise ValueError(
f"Must specify reference_key in RunEvalConfig to use"
f" evaluator of type {eval_type_tag} with"
f" dataset with multiple output keys: {example_outputs}."
)
run_evaluator = StringRunEvaluatorChain.from_run_and_data_type(
evaluator_,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
tags=[eval_type_tag],
)
else:
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented"
)
return run_evaluator
def _load_run_evaluators(
config: RunEvalConfig,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
) -> List[RunEvaluator]:
"""
Load run evaluators from a configuration.
Args:
config: Configuration for the run evaluators.
Returns:
A list of run evaluators.
"""
eval_llm = config.eval_llm or ChatOpenAI(model="gpt-4", temperature=0.0)
run_evaluators = []
input_key = _determine_input_key(config, run_inputs, run_type)
prediction_key = _determine_prediction_key(config, run_outputs, run_type)
reference_key = _determine_reference_key(config, example_outputs)
for eval_config in config.evaluators:
run_evaluator = _construct_run_evaluator(
eval_config,
eval_llm,
run_type,
data_type,
example_outputs,
reference_key,
input_key,
prediction_key,
)
run_evaluators.append(run_evaluator)
custom_evaluators = config.custom_evaluators or []
for custom_evaluator in custom_evaluators:
if isinstance(custom_evaluator, RunEvaluator):
run_evaluators.append(custom_evaluator)
elif isinstance(custom_evaluator, StringEvaluator):
run_evaluators.append(
StringRunEvaluatorChain.from_run_and_data_type(
custom_evaluator,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
)
)
else:
raise ValueError(
f"Unsupported custom evaluator: {custom_evaluator}."
f" Expected RunEvaluator or StringEvaluator."
)
return run_evaluators
### Async Helpers
async def _arun_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
*,
tags: Optional[List[str]] = None,
callbacks: Callbacks = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""Asynchronously run the language model.
Args:
llm: The language model to run.
inputs: The input dictionary.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map inputs to the expected format.
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
return await llm.apredict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
return await llm.apredict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format"
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
prompt = _get_prompt(inputs)
llm_output: Union[str, BaseMessage] = await llm.apredict(
prompt, callbacks=callbacks, tags=tags
)
except InputFormatError:
messages = _get_messages(inputs)
llm_output = await llm.apredict_messages(
messages, callbacks=callbacks, tags=tags
)
return llm_output
async def _arun_chain(
chain: Chain,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str]:
"""Run a chain asynchronously on inputs."""
if input_mapper is not None:
inputs_ = input_mapper(inputs)
output: Union[dict, str] = await chain.acall(
inputs_, callbacks=callbacks, tags=tags
)
else:
inputs_ = next(iter(inputs.values())) if len(inputs) == 1 else inputs
output = await chain.acall(inputs_, callbacks=callbacks, tags=tags)
return output
async def _arun_llm_or_chain(
example: Example,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
n_repetitions: int,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
"""Asynchronously run the Chain or language model.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
n_repetitions: The number of times to run the model on each example.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map the input to the expected format.
Returns:
A list of outputs.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
outputs = []
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
for _ in range(n_repetitions):
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = await _arun_llm(
llm_or_chain_factory,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = await _arun_chain(
chain,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
outputs.append(output)
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id}. Error: {e}"
)
outputs.append({"Error": str(e)})
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return outputs
async def _gather_with_concurrency(
n: int,
initializer: Callable[[], Coroutine[Any, Any, Any]],
*async_funcs: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
],
) -> List[Any]:
"""Run coroutines with a concurrency limit.
Args:
n: The maximum number of concurrent tasks.
initializer: A coroutine that initializes shared resources for the tasks.
async_funcs: The async_funcs to be run concurrently.
Returns:
A list of results from the coroutines.
"""
semaphore = asyncio.Semaphore(n)
job_state = {"num_processed": 0}
callback_queue: asyncio.Queue[Sequence[BaseCallbackHandler]] = asyncio.Queue()
for _ in range(n):
callback_queue.put_nowait(await initializer())
async def run_coroutine_with_semaphore(
async_func: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
]
) -> Any:
async with semaphore:
callbacks = await callback_queue.get()
try:
result = await async_func(callbacks, job_state)
finally:
callback_queue.put_nowait(callbacks)
return result
results = await asyncio.gather(
*(run_coroutine_with_semaphore(function) for function in async_funcs)
)
while callback_queue:
try:
callbacks = callback_queue.get_nowait()
except asyncio.QueueEmpty:
break
for callback in callbacks:
if isinstance(callback, (LangChainTracer, EvaluatorCallbackHandler)):
callback.wait_for_futures()
return results
async def _callbacks_initializer(
project_name: Optional[str],
client: Client,
run_evaluators: Sequence[RunEvaluator],
evaluation_handler_collector: List[EvaluatorCallbackHandler],
) -> List[BaseTracer]:
"""
Initialize a tracer to share across tasks.
Args:
project_name: The project name for the tracer.
client: The client to use for the tracer.
run_evaluators: The evaluators to run.
evaluation_handler_collector: A list to collect the evaluators.
Used to wait for the evaluators to finish.
Returns:
The callbacks for this thread.
"""
callbacks: List[BaseTracer] = []
if project_name:
callbacks.append(
LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
)
evaluator_project_name = f"{project_name}-evaluators" if project_name else None
if run_evaluators:
callback = EvaluatorCallbackHandler(
client=client,
evaluators=run_evaluators,
# We already have concurrency, don't want to overload the machine
max_workers=1,
project_name=evaluator_project_name,
)
callbacks.append(callback)
evaluation_handler_collector.append(callback)
return callbacks
async def _arun_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Asynchronously run the chain on examples and store traces
to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Project name to use when tracing runs.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
llm_or_chain_factory = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, llm_or_chain_factory)
run_evaluators, examples = _setup_evaluation(
llm_or_chain_factory, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, llm_or_chain_factory, input_mapper)
results: Dict[str, List[Any]] = {}
async def process_example(
example: Example, callbacks: List[BaseCallbackHandler], job_state: dict
) -> None:
"""Process a single example."""
result = await _arun_llm_or_chain(
example,
llm_or_chain_factory,
num_repetitions,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
results[str(example.id)] = result
job_state["num_processed"] += 1
if verbose:
print(
f"Processed examples: {job_state['num_processed']}",
end="\r",
flush=True,
)
evaluation_handlers: List[EvaluatorCallbackHandler] = []
await _gather_with_concurrency(
concurrency_level,
functools.partial(
_callbacks_initializer,
project_name=project_name,
client=client,
evaluation_handler_collector=evaluation_handlers,
run_evaluators=run_evaluators or [],
),
*(functools.partial(process_example, e) for e in examples),
)
for handler in evaluation_handlers:
handler.wait_for_futures()
return results
## Sync Utilities
def _run_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""
Run the language model on the example.
Args:
llm: The language model to run.
inputs: The input dictionary.
callbacks: The callbacks to use during the run.
tags: Optional tags to add to the run.
input_mapper: function to map to the inputs dictionary from an Example
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
llm_output: Union[str, BaseMessage] = llm.predict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
llm_output = llm.predict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format: "
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
llm_prompts = _get_prompt(inputs)
llm_output = llm.predict(llm_prompts, callbacks=callbacks, tags=tags)
except InputFormatError:
llm_messages = _get_messages(inputs)
llm_output = llm.predict_messages(llm_messages, callbacks=callbacks)
return llm_output
def _run_chain(
chain: Chain,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[Dict, str]:
"""Run a chain on inputs."""
if input_mapper is not None:
inputs_ = input_mapper(inputs)
output: Union[dict, str] = chain(inputs_, callbacks=callbacks, tags=tags)
else:
inputs_ = next(iter(inputs.values())) if len(inputs) == 1 else inputs
output = chain(inputs_, callbacks=callbacks, tags=tags)
return output
def _run_llm_or_chain(
example: Example,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
n_repetitions: int,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
"""
Run the Chain or language model synchronously.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
n_repetitions: The number of times to run the model on each example.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
Returns:
Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
The outputs of the model or chain.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
outputs = []
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
for _ in range(n_repetitions):
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = _run_llm(
llm_or_chain_factory,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = _run_chain(
chain,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
outputs.append(output)
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id}. Error: {e}"
)
outputs.append({"Error": str(e)})
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return outputs
def _run_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Run the Chain or language model on examples and store
traces to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
results: Dict[str, Any] = {}
llm_or_chain_factory = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, llm_or_chain_factory)
tracer = LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
evaluator_project_name = f"{project_name}-evaluators"
run_evaluators, examples = _setup_evaluation(
llm_or_chain_factory, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, llm_or_chain_factory, input_mapper)
evalution_handler = EvaluatorCallbackHandler(
evaluators=run_evaluators or [],
client=client,
project_name=evaluator_project_name,
)
callbacks: List[BaseCallbackHandler] = [tracer, evalution_handler]
for i, example in enumerate(examples):
result = _run_llm_or_chain(
example,
llm_or_chain_factory,
num_repetitions,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
if verbose:
print(f"{i+1} processed", flush=True, end="\r")
results[str(example.id)] = result
tracer.wait_for_futures()
evalution_handler.wait_for_futures()
return results
## Public API
def _prepare_eval_run(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: Optional[str],
) -> Tuple[MODEL_OR_CHAIN_FACTORY, str, Dataset, Iterator[Example]]:
llm_or_chain_factory = _wrap_in_chain_factory(llm_or_chain_factory, dataset_name)
project_name = _get_project_name(project_name, llm_or_chain_factory)
try:
project = client.create_project(project_name)
except ValueError as e:
if "already exists " not in str(e):
raise e
raise ValueError(
f"Project {project_name} already exists. Please use a different name."
)
project_url = _get_eval_project_url(client.api_url, project.id)
print(
f"View the evaluation results for project '{project_name}' at:\n{project_url}"
)
dataset = client.read_dataset(dataset_name=dataset_name)
examples = client.list_examples(dataset_id=str(dataset.id))
return llm_or_chain_factory, project_name, dataset, examples
async def arun_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Dict[str, Any]:
"""
Asynchronously run the Chain or language model on a dataset
and store traces to the specified project name.
Args:
client: LangSmith client to use to read the dataset, and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the
resulting model outputs.
For the synchronous version, see :func:`run_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, arun_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
llm_or_chain_factory, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
results = await _arun_on_examples(
client,
examples,
llm_or_chain_factory,
concurrency_level=concurrency_level,
num_repetitions=num_repetitions,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
return {
"project_name": project_name,
"results": results,
}
def run_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Dict[str, Any]:
"""
Run the Chain or language model on a dataset and store traces
to the specified project name.
Args:
client: LangSmith client to use to access the dataset and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Configuration for evaluators to run on the
results of the chain
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the resulting model outputs.
For the (usually faster) async version of this function, see :func:`arun_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, run_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
llm_or_chain_factory, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
results = _run_on_examples(
client,
examples,
llm_or_chain_factory,
num_repetitions=num_repetitions,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
return {
"project_name": project_name,
"results": results,
}
| [
"langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type",
"langchain.evaluation.loading.load_evaluator",
"langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler",
"langchain.chat_models.openai.ChatOpenAI",
"langchain.schema.messages.messages_from_dict",
"langchain.callbacks.tracers.langchain.LangChainTracer"
] | [((1370, 1397), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1387, 1397), False, 'import logging\n'), ((1708, 1725), 'urllib.parse.urlparse', 'urlparse', (['api_url'], {}), '(api_url)\n', (1716, 1725), False, 'from urllib.parse import urlparse, urlunparse\n'), ((24648, 24668), 'asyncio.Semaphore', 'asyncio.Semaphore', (['n'], {}), '(n)\n', (24665, 24668), False, 'import asyncio\n'), ((24774, 24789), 'asyncio.Queue', 'asyncio.Queue', ([], {}), '()\n', (24787, 24789), False, 'import asyncio\n'), ((37766, 37844), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (37781, 37844), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((38145, 38258), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'evaluators': '(run_evaluators or [])', 'client': 'client', 'project_name': 'evaluator_project_name'}), '(evaluators=run_evaluators or [], client=client,\n project_name=evaluator_project_name)\n', (38169, 38258), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((4660, 4696), 'itertools.chain', 'itertools.chain', (['[example]', 'examples'], {}), '([example], examples)\n', (4675, 4696), False, 'import itertools\n'), ((7539, 7574), 'langchain.schema.messages.messages_from_dict', 'messages_from_dict', (['raw_messages[0]'], {}), '(raw_messages[0])\n', (7557, 7574), False, 'from langchain.schema.messages import BaseMessage, messages_from_dict\n'), ((8394, 8406), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (8404, 8406), False, 'import uuid\n'), ((16022, 16063), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config'], {'llm': 'eval_llm'}), '(eval_config, llm=eval_llm)\n', (16036, 16063), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((16200, 16252), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config.evaluator_type'], {}), '(eval_config.evaluator_type, **kwargs)\n', (16214, 16252), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((16698, 16888), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['evaluator_', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key', 'tags': '[eval_type_tag]'}), '(evaluator_, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key, tags=[eval_type_tag])\n', (16744, 16888), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((17574, 17616), 'langchain.chat_models.openai.ChatOpenAI', 'ChatOpenAI', ([], {'model': '"""gpt-4"""', 'temperature': '(0.0)'}), "(model='gpt-4', temperature=0.0)\n", (17584, 17616), False, 'from langchain.chat_models.openai import ChatOpenAI\n'), ((26719, 26841), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'client': 'client', 'evaluators': 'run_evaluators', 'max_workers': '(1)', 'project_name': 'evaluator_project_name'}), '(client=client, evaluators=run_evaluators,\n max_workers=1, project_name=evaluator_project_name)\n', (26743, 26841), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((26474, 26552), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (26489, 26552), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((30344, 30523), 'functools.partial', 'functools.partial', (['_callbacks_initializer'], {'project_name': 'project_name', 'client': 'client', 'evaluation_handler_collector': 'evaluation_handlers', 'run_evaluators': '(run_evaluators or [])'}), '(_callbacks_initializer, project_name=project_name, client\n =client, evaluation_handler_collector=evaluation_handlers,\n run_evaluators=run_evaluators or [])\n', (30361, 30523), False, 'import functools\n'), ((18522, 18696), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['custom_evaluator', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key'}), '(custom_evaluator, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key)\n', (18568, 18696), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((30597, 30634), 'functools.partial', 'functools.partial', (['process_example', 'e'], {}), '(process_example, e)\n', (30614, 30634), False, 'import functools\n')] |
"""Utilities for running language models or Chains over datasets."""
from __future__ import annotations
import asyncio
import functools
import inspect
import itertools
import logging
import uuid
import warnings
from enum import Enum
from typing import (
TYPE_CHECKING,
Any,
Callable,
Coroutine,
Dict,
Iterator,
List,
Optional,
Sequence,
Tuple,
Union,
cast,
)
from urllib.parse import urlparse, urlunparse
from langsmith import Client, RunEvaluator
from langsmith.schemas import Dataset, DataType, Example
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.manager import Callbacks
from langchain.callbacks.tracers.base import BaseTracer
from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler
from langchain.callbacks.tracers.langchain import LangChainTracer
from langchain.chains.base import Chain
from langchain.evaluation.loading import load_evaluator
from langchain.evaluation.schema import EvaluatorType, StringEvaluator
from langchain.schema import ChatResult, LLMResult
from langchain.schema.language_model import BaseLanguageModel
from langchain.schema.messages import BaseMessage, messages_from_dict
from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda
from langchain.smith.evaluation.config import EvalConfig, RunEvalConfig
from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain
if TYPE_CHECKING:
import pandas as pd
logger = logging.getLogger(__name__)
MODEL_OR_CHAIN_FACTORY = Union[
Callable[[], Union[Chain, Runnable]],
BaseLanguageModel,
Callable[[dict], Any],
Runnable,
Chain,
]
MCF = Union[Callable[[], Union[Chain, Runnable]], BaseLanguageModel]
class InputFormatError(Exception):
"""Raised when the input format is invalid."""
## Shared Utilities
class TestResult(dict):
"""A dictionary of the results of a single test run."""
def to_dataframe(self) -> pd.DataFrame:
"""Convert the results to a dataframe."""
try:
import pandas as pd
except ImportError as e:
raise ImportError(
"Pandas is required to convert the results to a dataframe."
" to install pandas, run `pip install pandas`."
) from e
indices = []
records = []
for example_id, result in self["results"].items():
feedback = result["feedback"]
records.append(
{**{f.key: f.score for f in feedback}, "output": result["output"]}
)
indices.append(example_id)
return pd.DataFrame(records, index=indices)
def _get_eval_project_url(api_url: str, project_id: str) -> str:
"""Get the project url from the api url."""
parsed = urlparse(api_url)
hostname = parsed.hostname or ""
if "api." in hostname:
hostname = hostname.replace("api.", "", 1)
if "localhost" in hostname:
# Remove the port
hostname = "localhost"
url = urlunparse(parsed._replace(netloc=hostname))
return f"{url}/projects/p/{project_id}?eval=true"
def _wrap_in_chain_factory(
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
dataset_name: str = "<my_dataset>",
) -> MCF:
"""Forgive the user if they pass in a chain without memory instead of a chain
factory. It's a common mistake. Raise a more helpful error message as well."""
if isinstance(llm_or_chain_factory, Chain):
chain = llm_or_chain_factory
chain_class = chain.__class__.__name__
if llm_or_chain_factory.memory is not None:
memory_class = chain.memory.__class__.__name__
raise ValueError(
"Cannot directly evaluate a chain with stateful memory."
" To evaluate this chain, pass in a chain constructor"
" that initializes fresh memory each time it is called."
" This will safegaurd against information"
" leakage between dataset examples."
"\nFor example:\n\n"
"def chain_constructor():\n"
f" new_memory = {memory_class}(...)\n"
f" return {chain_class}"
"(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
logger.warning(
"Directly passing in a chain is not recommended as chains may have state."
" This can lead to unexpected behavior as the "
"same chain instance could be used across multiple datasets. Instead,"
" please pass a chain constructor that creates a new "
"chain with fresh memory each time it is called. This will safeguard"
" against information leakage between dataset examples. "
"\nFor example:\n\n"
"def chain_constructor():\n"
f" return {chain_class}(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
return lambda: chain
elif isinstance(llm_or_chain_factory, BaseLanguageModel):
return llm_or_chain_factory
elif isinstance(llm_or_chain_factory, Runnable):
# Memory may exist here, but it's not elegant to check all those cases.
lcf = llm_or_chain_factory
return lambda: lcf
elif callable(llm_or_chain_factory):
try:
_model = llm_or_chain_factory() # type: ignore[call-arg]
except TypeError:
# It's an arbitrary function, wrap it in a RunnableLambda
user_func = cast(Callable, llm_or_chain_factory)
sig = inspect.signature(user_func)
logger.info(f"Wrapping function {sig} as RunnableLambda.")
wrapped = RunnableLambda(user_func)
return lambda: wrapped
constructor = cast(Callable, llm_or_chain_factory)
if isinstance(_model, BaseLanguageModel):
# It's not uncommon to do an LLM constructor instead of raw LLM,
# so we'll unpack it for the user.
return _model
elif not isinstance(_model, Runnable):
# This is unlikely to happen - a constructor for a model function
return lambda: RunnableLambda(constructor)
else:
# Typical correct case
return constructor # noqa
return llm_or_chain_factory
def _first_example(examples: Iterator[Example]) -> Tuple[Example, Iterator[Example]]:
"""Get the first example while chaining it back and preserving the iterator."""
try:
example: Example = next(examples)
except StopIteration:
raise ValueError("No examples provided.")
return example, itertools.chain([example], examples)
def _get_prompt(inputs: Dict[str, Any]) -> str:
"""Get prompt from inputs.
Args:
inputs: The input dictionary.
Returns:
A string prompt.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
prompts = []
if "prompt" in inputs:
if not isinstance(inputs["prompt"], str):
raise InputFormatError(
"Expected string for 'prompt', got"
f" {type(inputs['prompt']).__name__}"
)
prompts = [inputs["prompt"]]
elif "prompts" in inputs:
if not isinstance(inputs["prompts"], list) or not all(
isinstance(i, str) for i in inputs["prompts"]
):
raise InputFormatError(
"Expected list of strings for 'prompts',"
f" got {type(inputs['prompts']).__name__}"
)
prompts = inputs["prompts"]
elif len(inputs) == 1:
prompt_ = next(iter(inputs.values()))
if isinstance(prompt_, str):
prompts = [prompt_]
elif isinstance(prompt_, list) and all(isinstance(i, str) for i in prompt_):
prompts = prompt_
else:
raise InputFormatError(f"LLM Run expects string prompt input. Got {inputs}")
else:
raise InputFormatError(
f"LLM Run expects 'prompt' or 'prompts' in inputs. Got {inputs}"
)
if len(prompts) == 1:
return prompts[0]
else:
raise InputFormatError(
f"LLM Run expects single prompt input. Got {len(prompts)} prompts."
)
def _get_messages(inputs: Dict[str, Any]) -> List[BaseMessage]:
"""Get Chat Messages from inputs.
Args:
inputs: The input dictionary.
Returns:
A list of chat messages.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
if "messages" in inputs:
single_input = inputs["messages"]
elif len(inputs) == 1:
single_input = next(iter(inputs.values()))
else:
raise InputFormatError(
f"Chat Run expects 'messages' in inputs when example has multiple"
f" input keys. Got {inputs}"
)
if isinstance(single_input, list) and all(
isinstance(i, dict) for i in single_input
):
raw_messages = [single_input]
elif isinstance(single_input, list) and all(
isinstance(i, list) for i in single_input
):
raw_messages = single_input
else:
raise InputFormatError(
f"Chat Run expects List[dict] or List[List[dict]] values for"
f" 'messages' key input. Got {inputs}"
)
if len(raw_messages) == 1:
return messages_from_dict(raw_messages[0])
else:
raise InputFormatError(
f"Chat Run expects single List[dict] or List[List[dict]] 'messages'"
f" input. Got {len(raw_messages)} messages from inputs {inputs}"
)
def _get_project_name(
project_name: Optional[str],
llm_or_chain_factory: MCF,
) -> str:
"""
Get the project name.
Args:
project_name: The project name if manually specified.
llm_or_chain_factory: The Chain or language model constructor.
Returns:
The project name.
"""
if project_name is not None:
return project_name
if isinstance(llm_or_chain_factory, BaseLanguageModel):
model_name = llm_or_chain_factory.__class__.__name__
else:
model_name = llm_or_chain_factory().__class__.__name__
hex = uuid.uuid4().hex
return f"{hex}-{model_name}"
## Shared Validation Utilities
def _validate_example_inputs_for_language_model(
first_example: Example,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
if input_mapper:
prompt_input = input_mapper(first_example.inputs)
if not isinstance(prompt_input, str) and not (
isinstance(prompt_input, list)
and all(isinstance(msg, BaseMessage) for msg in prompt_input)
):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for an LLM or chat model, the output must a single string or"
" a list of chat messages."
f"\nGot: {prompt_input} of type {type(prompt_input)}."
)
else:
try:
_get_prompt(first_example.inputs)
except InputFormatError:
try:
_get_messages(first_example.inputs)
except InputFormatError:
raise InputFormatError(
"Example inputs do not match language model input format. "
"Expected a dictionary with messages or a single prompt."
f" Got: {first_example.inputs}"
" Please update your dataset OR provide an input_mapper"
" to convert the example.inputs to a compatible format"
" for the llm or chat model you wish to evaluate."
)
def _validate_example_inputs_for_chain(
first_example: Example,
chain: Chain,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs match the chain input keys."""
if input_mapper:
first_inputs = input_mapper(first_example.inputs)
missing_keys = set(chain.input_keys).difference(first_inputs)
if not isinstance(first_inputs, dict):
raise InputFormatError(
"When using an input_mapper to prepare dataset example"
" inputs for a chain, the mapped value must be a dictionary."
f"\nGot: {first_inputs} of type {type(first_inputs)}."
)
if missing_keys:
raise InputFormatError(
"Missing keys after loading example using input_mapper."
f"\nExpected: {chain.input_keys}. Got: {first_inputs.keys()}"
)
else:
first_inputs = first_example.inputs
missing_keys = set(chain.input_keys).difference(first_inputs)
if len(first_inputs) == 1 and len(chain.input_keys) == 1:
# We can pass this through the run method.
# Refrain from calling to validate.
pass
elif missing_keys:
raise InputFormatError(
"Example inputs missing expected chain input keys."
" Please provide an input_mapper to convert the example.inputs"
" to a compatible format for the chain you wish to evaluate."
f"Expected: {chain.input_keys}. "
f"Got: {first_inputs.keys()}"
)
def _validate_example_inputs(
examples: Iterator[Example],
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]],
) -> Iterator[Example]:
"""Validate that the example inputs are valid for the model."""
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
_validate_example_inputs_for_language_model(first_example, input_mapper)
else:
chain = llm_or_chain_factory()
if isinstance(chain, Chain):
# Otherwise it's a runnable
_validate_example_inputs_for_chain(first_example, chain, input_mapper)
elif isinstance(chain, Runnable):
logger.debug(f"Skipping input validation for {chain}")
return examples
## Shared Evaluator Setup Utilities
def _setup_evaluation(
llm_or_chain_factory: MCF,
examples: Iterator[Example],
evaluation: Optional[RunEvalConfig],
data_type: DataType,
) -> Tuple[Optional[List[RunEvaluator]], Iterator[Example]]:
"""Configure the evaluators to run on the results of the chain."""
if evaluation:
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
run_inputs, run_outputs = None, None
run_type = "llm"
else:
run_type = "chain"
if data_type in (DataType.chat, DataType.llm):
val = data_type.value if isinstance(data_type, Enum) else data_type
raise ValueError(
"Cannot evaluate a chain on dataset with "
f"data_type={val}. "
"Please specify a dataset with the default 'kv' data type."
)
chain = llm_or_chain_factory()
run_inputs = chain.input_keys if isinstance(chain, Chain) else None
run_outputs = chain.output_keys if isinstance(chain, Chain) else None
run_evaluators = _load_run_evaluators(
evaluation,
run_type,
data_type,
list(first_example.outputs) if first_example.outputs else None,
run_inputs,
run_outputs,
)
else:
# TODO: Create a default helpfulness evaluator
run_evaluators = None
return run_evaluators, examples
def _determine_input_key(
config: RunEvalConfig,
run_inputs: Optional[List[str]],
) -> Optional[str]:
input_key = None
if config.input_key:
input_key = config.input_key
if run_inputs and input_key not in run_inputs:
raise ValueError(f"Input key {input_key} not in run inputs {run_inputs}")
elif run_inputs and len(run_inputs) == 1:
input_key = run_inputs[0]
elif run_inputs is not None and len(run_inputs) > 1:
raise ValueError(
f"Must specify input key for model with multiple inputs: {run_inputs}"
)
return input_key
def _determine_prediction_key(
config: RunEvalConfig,
run_outputs: Optional[List[str]],
) -> Optional[str]:
prediction_key = None
if config.prediction_key:
prediction_key = config.prediction_key
if run_outputs and prediction_key not in run_outputs:
raise ValueError(
f"Prediction key {prediction_key} not in run outputs {run_outputs}"
)
elif run_outputs and len(run_outputs) == 1:
prediction_key = run_outputs[0]
elif run_outputs is not None and len(run_outputs) > 1:
raise ValueError(
f"Must specify prediction key for model"
f" with multiple outputs: {run_outputs}"
)
return prediction_key
def _determine_reference_key(
config: RunEvalConfig,
example_outputs: Optional[List[str]],
) -> Optional[str]:
if config.reference_key:
reference_key = config.reference_key
if example_outputs and reference_key not in example_outputs:
raise ValueError(
f"Reference key {reference_key} not in Dataset"
f" example outputs: {example_outputs}"
)
elif example_outputs and len(example_outputs) == 1:
reference_key = list(example_outputs)[0]
else:
reference_key = None
return reference_key
def _construct_run_evaluator(
eval_config: Union[EvaluatorType, str, EvalConfig],
eval_llm: Optional[BaseLanguageModel],
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
reference_key: Optional[str],
input_key: Optional[str],
prediction_key: Optional[str],
) -> RunEvaluator:
if isinstance(eval_config, (EvaluatorType, str)):
if not isinstance(eval_config, EvaluatorType):
eval_config = EvaluatorType(eval_config)
evaluator_ = load_evaluator(eval_config, llm=eval_llm)
eval_type_tag = eval_config.value
else:
kwargs = {"llm": eval_llm, **eval_config.get_kwargs()}
evaluator_ = load_evaluator(eval_config.evaluator_type, **kwargs)
eval_type_tag = eval_config.evaluator_type.value
if isinstance(evaluator_, StringEvaluator):
if evaluator_.requires_reference and reference_key is None:
raise ValueError(
f"Must specify reference_key in RunEvalConfig to use"
f" evaluator of type {eval_type_tag} with"
f" dataset with multiple output keys: {example_outputs}."
)
run_evaluator = StringRunEvaluatorChain.from_run_and_data_type(
evaluator_,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
tags=[eval_type_tag],
)
else:
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented"
)
return run_evaluator
def _get_keys(
config: RunEvalConfig,
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
example_outputs: Optional[List[str]],
) -> Tuple[Optional[str], Optional[str], Optional[str]]:
input_key = _determine_input_key(config, run_inputs)
prediction_key = _determine_prediction_key(config, run_outputs)
reference_key = _determine_reference_key(config, example_outputs)
return input_key, prediction_key, reference_key
def _load_run_evaluators(
config: RunEvalConfig,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
) -> List[RunEvaluator]:
"""
Load run evaluators from a configuration.
Args:
config: Configuration for the run evaluators.
Returns:
A list of run evaluators.
"""
run_evaluators = []
input_key, prediction_key, reference_key = None, None, None
if (
config.evaluators
or any([isinstance(e, EvaluatorType) for e in config.evaluators])
or (
config.custom_evaluators
and any([isinstance(e, StringEvaluator) for e in config.custom_evaluators])
)
):
input_key, prediction_key, reference_key = _get_keys(
config, run_inputs, run_outputs, example_outputs
)
for eval_config in config.evaluators:
run_evaluator = _construct_run_evaluator(
eval_config,
config.eval_llm,
run_type,
data_type,
example_outputs,
reference_key,
input_key,
prediction_key,
)
run_evaluators.append(run_evaluator)
custom_evaluators = config.custom_evaluators or []
for custom_evaluator in custom_evaluators:
if isinstance(custom_evaluator, RunEvaluator):
run_evaluators.append(custom_evaluator)
elif isinstance(custom_evaluator, StringEvaluator):
run_evaluators.append(
StringRunEvaluatorChain.from_run_and_data_type(
custom_evaluator,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
)
)
else:
raise ValueError(
f"Unsupported custom evaluator: {custom_evaluator}."
f" Expected RunEvaluator or StringEvaluator."
)
return run_evaluators
### Async Helpers
async def _arun_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
*,
tags: Optional[List[str]] = None,
callbacks: Callbacks = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""Asynchronously run the language model.
Args:
llm: The language model to run.
inputs: The input dictionary.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map inputs to the expected format.
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
return await llm.apredict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
return await llm.apredict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format"
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
prompt = _get_prompt(inputs)
llm_output: Union[str, BaseMessage] = await llm.apredict(
prompt, callbacks=callbacks, tags=tags
)
except InputFormatError:
messages = _get_messages(inputs)
llm_output = await llm.apredict_messages(
messages, callbacks=callbacks, tags=tags
)
return llm_output
async def _arun_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str]:
"""Run a chain asynchronously on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if isinstance(chain, Chain):
if isinstance(inputs_, dict) and len(inputs_) == 1:
val = next(iter(inputs_.values()))
output = await chain.acall(val, callbacks=callbacks, tags=tags)
else:
output = await chain.acall(inputs_, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = await chain.ainvoke(inputs_, config=runnable_config)
return output
async def _arun_llm_or_chain(
example: Example,
llm_or_chain_factory: MCF,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""Asynchronously run the Chain or language model.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map the input to the expected format.
Returns:
A list of outputs.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = await _arun_llm(
llm_or_chain_factory,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = await _arun_chain(
chain,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
result = output
except Exception as e:
logger.warning(f"{chain_or_llm} failed for example {example.id}. Error: {e}")
result = {"Error": str(e)}
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return result
async def _gather_with_concurrency(
n: int,
initializer: Callable[[], Coroutine[Any, Any, Any]],
*async_funcs: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
],
) -> List[Any]:
"""Run coroutines with a concurrency limit.
Args:
n: The maximum number of concurrent tasks.
initializer: A coroutine that initializes shared resources for the tasks.
async_funcs: The async_funcs to be run concurrently.
Returns:
A list of results from the coroutines.
"""
semaphore = asyncio.Semaphore(n)
job_state = {"num_processed": 0}
callback_queue: asyncio.Queue[Sequence[BaseCallbackHandler]] = asyncio.Queue()
for _ in range(n):
callback_queue.put_nowait(await initializer())
async def run_coroutine_with_semaphore(
async_func: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
]
) -> Any:
async with semaphore:
callbacks = await callback_queue.get()
try:
result = await async_func(callbacks, job_state)
finally:
callback_queue.put_nowait(callbacks)
return result
results = await asyncio.gather(
*(run_coroutine_with_semaphore(function) for function in async_funcs)
)
while callback_queue:
try:
callbacks = callback_queue.get_nowait()
except asyncio.QueueEmpty:
break
for callback in callbacks:
if isinstance(callback, (LangChainTracer, EvaluatorCallbackHandler)):
callback.wait_for_futures()
return results
async def _callbacks_initializer(
project_name: Optional[str],
client: Client,
run_evaluators: Sequence[RunEvaluator],
evaluation_handler_collector: List[EvaluatorCallbackHandler],
) -> List[BaseTracer]:
"""
Initialize a tracer to share across tasks.
Args:
project_name: The project name for the tracer.
client: The client to use for the tracer.
run_evaluators: The evaluators to run.
evaluation_handler_collector: A list to collect the evaluators.
Used to wait for the evaluators to finish.
Returns:
The callbacks for this thread.
"""
callbacks: List[BaseTracer] = []
if project_name:
callbacks.append(
LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
)
if run_evaluators:
callback = EvaluatorCallbackHandler(
client=client,
evaluators=run_evaluators,
# We already have concurrency, don't want to overload the machine
max_workers=1,
)
callbacks.append(callback)
evaluation_handler_collector.append(callback)
return callbacks
async def _arun_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Asynchronously run the chain on examples and store traces
to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
project_name: Project name to use when tracing runs.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, wrapped_model)
run_evaluators, examples = _setup_evaluation(
wrapped_model, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, wrapped_model, input_mapper)
results: Dict[str, dict] = {}
async def process_example(
example: Example, callbacks: List[BaseCallbackHandler], job_state: dict
) -> None:
"""Process a single example."""
result = await _arun_llm_or_chain(
example,
wrapped_model,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
results[str(example.id)] = {"output": result}
job_state["num_processed"] += 1
if verbose:
print(
f"Processed examples: {job_state['num_processed']}",
end="\r",
flush=True,
)
evaluation_handlers: List[EvaluatorCallbackHandler] = []
await _gather_with_concurrency(
concurrency_level,
functools.partial(
_callbacks_initializer,
project_name=project_name,
client=client,
evaluation_handler_collector=evaluation_handlers,
run_evaluators=run_evaluators or [],
),
*(functools.partial(process_example, e) for e in examples),
)
all_feedback = {}
for handler in evaluation_handlers:
handler.wait_for_futures()
all_feedback.update(handler.logged_feedback)
# join the results and feedback on the example id
for example_id, output_dict in results.items():
feedback = all_feedback.get(example_id, [])
output_dict["feedback"] = feedback
return results
## Sync Utilities
def _run_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""
Run the language model on the example.
Args:
llm: The language model to run.
inputs: The input dictionary.
callbacks: The callbacks to use during the run.
tags: Optional tags to add to the run.
input_mapper: function to map to the inputs dictionary from an Example
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
llm_output: Union[str, BaseMessage] = llm.predict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
llm_output = llm.predict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format: "
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
llm_prompts = _get_prompt(inputs)
llm_output = llm.predict(llm_prompts, callbacks=callbacks, tags=tags)
except InputFormatError:
llm_messages = _get_messages(inputs)
llm_output = llm.predict_messages(llm_messages, callbacks=callbacks)
return llm_output
def _run_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[Dict, str]:
"""Run a chain on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if isinstance(chain, Chain):
if isinstance(inputs_, dict) and len(inputs_) == 1:
val = next(iter(inputs_.values()))
output = chain(val, callbacks=callbacks, tags=tags)
else:
output = chain(inputs_, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = chain.invoke(inputs_, config=runnable_config)
return output
def _run_llm_or_chain(
example: Example,
llm_or_chain_factory: MCF,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""
Run the Chain or language model synchronously.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
Returns:
Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
The outputs of the model or chain.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = _run_llm(
llm_or_chain_factory,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = _run_chain(
chain,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
result = output
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id} with inputs:"
f" {example.inputs}.\nError: {e}",
)
result = {"Error": str(e)}
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return result
def _run_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Run the Chain or language model on examples and store
traces to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
results: Dict[str, dict] = {}
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, wrapped_model)
tracer = LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
run_evaluators, examples = _setup_evaluation(
wrapped_model, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, wrapped_model, input_mapper)
evaluation_handler = EvaluatorCallbackHandler(
evaluators=run_evaluators or [],
client=client,
)
callbacks: List[BaseCallbackHandler] = [tracer, evaluation_handler]
for i, example in enumerate(examples):
result = _run_llm_or_chain(
example,
wrapped_model,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
if verbose:
print(f"{i+1} processed", flush=True, end="\r")
results[str(example.id)] = {"output": result}
tracer.wait_for_futures()
evaluation_handler.wait_for_futures()
all_feedback = evaluation_handler.logged_feedback
# join the results and feedback on the example id
for example_id, output_dict in results.items():
feedback = all_feedback.get(example_id, [])
output_dict["feedback"] = feedback
return results
## Public API
def _prepare_eval_run(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: Optional[str],
) -> Tuple[MCF, str, Dataset, Iterator[Example]]:
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory, dataset_name)
project_name = _get_project_name(project_name, wrapped_model)
try:
project = client.create_project(project_name)
except ValueError as e:
if "already exists " not in str(e):
raise e
raise ValueError(
f"Project {project_name} already exists. Please use a different name."
)
project_url = _get_eval_project_url(client.api_url, project.id)
print(
f"View the evaluation results for project '{project_name}' at:\n{project_url}"
)
dataset = client.read_dataset(dataset_name=dataset_name)
examples = client.list_examples(dataset_id=str(dataset.id))
return wrapped_model, project_name, dataset, examples
async def arun_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
"""
Asynchronously run the Chain or language model on a dataset
and store traces to the specified project name.
Args:
client: LangSmith client to use to read the dataset, and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the
resulting model outputs.
For the synchronous version, see :func:`run_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, arun_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
if kwargs:
warnings.warn(
"The following arguments are deprecated and will "
"be removed in a future release: "
f"{kwargs.keys()}.",
DeprecationWarning,
)
wrapped_model, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
results = await _arun_on_examples(
client,
examples,
wrapped_model,
concurrency_level=concurrency_level,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
return TestResult(
project_name=project_name,
results=results,
)
def _handle_coroutine(coro: Coroutine) -> Any:
"""
Handles a coroutine from a sync context.
Args:
coro (asyncio.coroutine): The coroutine to be handled.
Returns:
any: The result of the executed coroutine.
"""
# Check if there's a running event loop
try:
loop = asyncio.get_event_loop()
except RuntimeError: # No event loop
return asyncio.run(coro)
if loop.is_running():
return loop.run_until_complete(coro)
else:
return asyncio.run(coro)
def run_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
"""
Run the Chain or language model on a dataset and store traces
to the specified project name.
Args:
client: LangSmith client to use to access the dataset and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Configuration for evaluators to run on the
results of the chain
concurrency_level: The number of async tasks to run concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the resulting model outputs.
For the (usually faster) async version of this function, see :func:`arun_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, run_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
if kwargs:
warnings.warn(
"The following arguments are deprecated and "
"will be removed in a future release: "
f"{kwargs.keys()}.",
DeprecationWarning,
)
wrapped_model, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
if concurrency_level in (0, 1):
results = _run_on_examples(
client,
examples,
wrapped_model,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
else:
# TODO: Use runnables and the batch method
coro = _arun_on_examples(
client,
examples,
wrapped_model,
concurrency_level=concurrency_level,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
results = _handle_coroutine(coro)
return TestResult(
project_name=project_name,
results=results,
)
| [
"langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type",
"langchain.evaluation.loading.load_evaluator",
"langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler",
"langchain.schema.runnable.RunnableConfig",
"langchain.schema.messages.messages_from_dict",
"langchain.evaluation.schema.EvaluatorType",
"langchain.callbacks.tracers.langchain.LangChainTracer",
"langchain.schema.runnable.RunnableLambda"
] | [((1500, 1527), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1517, 1527), False, 'import logging\n'), ((2799, 2816), 'urllib.parse.urlparse', 'urlparse', (['api_url'], {}), '(api_url)\n', (2807, 2816), False, 'from urllib.parse import urlparse, urlunparse\n'), ((27519, 27539), 'asyncio.Semaphore', 'asyncio.Semaphore', (['n'], {}), '(n)\n', (27536, 27539), False, 'import asyncio\n'), ((27645, 27660), 'asyncio.Queue', 'asyncio.Queue', ([], {}), '()\n', (27658, 27660), False, 'import asyncio\n'), ((40275, 40353), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (40290, 40353), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((40583, 40655), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'evaluators': '(run_evaluators or [])', 'client': 'client'}), '(evaluators=run_evaluators or [], client=client)\n', (40607, 40655), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((2634, 2670), 'pandas.DataFrame', 'pd.DataFrame', (['records'], {'index': 'indices'}), '(records, index=indices)\n', (2646, 2670), True, 'import pandas as pd\n'), ((6729, 6765), 'itertools.chain', 'itertools.chain', (['[example]', 'examples'], {}), '([example], examples)\n', (6744, 6765), False, 'import itertools\n'), ((9608, 9643), 'langchain.schema.messages.messages_from_dict', 'messages_from_dict', (['raw_messages[0]'], {}), '(raw_messages[0])\n', (9626, 9643), False, 'from langchain.schema.messages import BaseMessage, messages_from_dict\n'), ((10444, 10456), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (10454, 10456), False, 'import uuid\n'), ((18358, 18399), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config'], {'llm': 'eval_llm'}), '(eval_config, llm=eval_llm)\n', (18372, 18399), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((18536, 18588), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config.evaluator_type'], {}), '(eval_config.evaluator_type, **kwargs)\n', (18550, 18588), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((19034, 19224), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['evaluator_', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key', 'tags': '[eval_type_tag]'}), '(evaluator_, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key, tags=[eval_type_tag])\n', (19080, 19224), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((24688, 24740), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (24702, 24740), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((29506, 29591), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'client': 'client', 'evaluators': 'run_evaluators', 'max_workers': '(1)'}), '(client=client, evaluators=run_evaluators,\n max_workers=1)\n', (29530, 29591), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((36030, 36082), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (36044, 36082), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((47863, 47887), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (47885, 47887), False, 'import asyncio\n'), ((48059, 48076), 'asyncio.run', 'asyncio.run', (['coro'], {}), '(coro)\n', (48070, 48076), False, 'import asyncio\n'), ((18310, 18336), 'langchain.evaluation.schema.EvaluatorType', 'EvaluatorType', (['eval_config'], {}), '(eval_config)\n', (18323, 18336), False, 'from langchain.evaluation.schema import EvaluatorType, StringEvaluator\n'), ((29345, 29423), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (29360, 29423), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((32818, 32997), 'functools.partial', 'functools.partial', (['_callbacks_initializer'], {'project_name': 'project_name', 'client': 'client', 'evaluation_handler_collector': 'evaluation_handlers', 'run_evaluators': '(run_evaluators or [])'}), '(_callbacks_initializer, project_name=project_name, client\n =client, evaluation_handler_collector=evaluation_handlers,\n run_evaluators=run_evaluators or [])\n', (32835, 32997), False, 'import functools\n'), ((47945, 47962), 'asyncio.run', 'asyncio.run', (['coro'], {}), '(coro)\n', (47956, 47962), False, 'import asyncio\n'), ((5873, 5909), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5877, 5909), False, 'from typing import TYPE_CHECKING, Any, Callable, Coroutine, Dict, Iterator, List, Optional, Sequence, Tuple, Union, cast\n'), ((21499, 21673), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['custom_evaluator', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key'}), '(custom_evaluator, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key)\n', (21545, 21673), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((33071, 33108), 'functools.partial', 'functools.partial', (['process_example', 'e'], {}), '(process_example, e)\n', (33088, 33108), False, 'import functools\n'), ((5613, 5649), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5617, 5649), False, 'from typing import TYPE_CHECKING, Any, Callable, Coroutine, Dict, Iterator, List, Optional, Sequence, Tuple, Union, cast\n'), ((5668, 5696), 'inspect.signature', 'inspect.signature', (['user_func'], {}), '(user_func)\n', (5685, 5696), False, 'import inspect\n'), ((5790, 5815), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['user_func'], {}), '(user_func)\n', (5804, 5815), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((6262, 6289), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['constructor'], {}), '(constructor)\n', (6276, 6289), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n')] |
from langchain.llms import HuggingFacePipeline, CTransformers
import langchain
from ingest import load_db
from langchain.cache import InMemoryCache
from langchain.schema import prompt
from langchain.chains import RetrievalQA
from langchain.callbacks import StdOutCallbackHandler
from langchain import PromptTemplate
import chainlit as cl
DB_FAISS_PATH = 'vectorstoredb/db_faiss'
langchain.llm_cache = InMemoryCache()
PROMPT_TEMPLATE = '''
Use the following pieces of information to answer the user's question.
If you don't know the answer, just say that you don't know, don't try to make up an answer.
Context: {context}
Question: {question}
Do provide only helpful answers
Helpful answer:
'''
handler = StdOutCallbackHandler()
def set_custom_prompt():
input_variables = ['context', 'question']
prompt = PromptTemplate(template=PROMPT_TEMPLATE, input_variables=input_variables)
return prompt
def load_retriever():
return load_db()
def load_llm():
llm = CTransformers(model="models/mistral-7b-instruct-v0.1.Q2_K.gguf", config={'max_new_tokens': 128, 'temperature': 0.01})
return llm
def retrieval_qa_chain(llm, prompt, db):
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever = db,
verbose=True,
callbacks=[handler],
chain_type_kwargs={"prompt": prompt},
return_source_documents=True
)
return qa_chain
def qa_bot():
db = load_retriever()
llm = load_llm()
qa_prompt = set_custom_prompt()
qa = retrieval_qa_chain(llm, qa_prompt, db)
return qa
def final_result(query):
qa_result = qa_bot()
response = qa_result({"query": query})
return response
@cl.on_chat_start
async def start():
chain = qa_bot()
msg = cl.Message(content="Starting the bot...")
await msg.send()
msg.content = "Hi, Welcome to Medical Bot. What is your query?"
await msg.update()
cl.user_session.set("chain", chain)
@cl.on_message
async def main(message: cl.Message):
chain = cl.user_session.get("chain")
cb = cl.AsyncLangchainCallbackHandler(
stream_final_answer=True, answer_prefix_tokens=["FINAL", "ANSWER"]
)
cb.answer_reached = True
res = await chain.acall(message.content, callbacks=[cb])
answer = res["result"]
sources = res["source_documents"]
if sources:
answer += f"\nSources:" + str(sources)
else:
answer += "\nNo sources found"
await cl.Message(content=answer).send()
| [
"langchain.PromptTemplate",
"langchain.cache.InMemoryCache",
"langchain.llms.CTransformers",
"langchain.callbacks.StdOutCallbackHandler",
"langchain.chains.RetrievalQA.from_chain_type"
] | [((403, 418), 'langchain.cache.InMemoryCache', 'InMemoryCache', ([], {}), '()\n', (416, 418), False, 'from langchain.cache import InMemoryCache\n'), ((709, 732), 'langchain.callbacks.StdOutCallbackHandler', 'StdOutCallbackHandler', ([], {}), '()\n', (730, 732), False, 'from langchain.callbacks import StdOutCallbackHandler\n'), ((817, 890), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'template': 'PROMPT_TEMPLATE', 'input_variables': 'input_variables'}), '(template=PROMPT_TEMPLATE, input_variables=input_variables)\n', (831, 890), False, 'from langchain import PromptTemplate\n'), ((943, 952), 'ingest.load_db', 'load_db', ([], {}), '()\n', (950, 952), False, 'from ingest import load_db\n'), ((980, 1102), 'langchain.llms.CTransformers', 'CTransformers', ([], {'model': '"""models/mistral-7b-instruct-v0.1.Q2_K.gguf"""', 'config': "{'max_new_tokens': 128, 'temperature': 0.01}"}), "(model='models/mistral-7b-instruct-v0.1.Q2_K.gguf', config={\n 'max_new_tokens': 128, 'temperature': 0.01})\n", (993, 1102), False, 'from langchain.llms import HuggingFacePipeline, CTransformers\n'), ((1170, 1351), 'langchain.chains.RetrievalQA.from_chain_type', 'RetrievalQA.from_chain_type', ([], {'llm': 'llm', 'chain_type': '"""stuff"""', 'retriever': 'db', 'verbose': '(True)', 'callbacks': '[handler]', 'chain_type_kwargs': "{'prompt': prompt}", 'return_source_documents': '(True)'}), "(llm=llm, chain_type='stuff', retriever=db,\n verbose=True, callbacks=[handler], chain_type_kwargs={'prompt': prompt},\n return_source_documents=True)\n", (1197, 1351), False, 'from langchain.chains import RetrievalQA\n'), ((1745, 1786), 'chainlit.Message', 'cl.Message', ([], {'content': '"""Starting the bot..."""'}), "(content='Starting the bot...')\n", (1755, 1786), True, 'import chainlit as cl\n'), ((1904, 1939), 'chainlit.user_session.set', 'cl.user_session.set', (['"""chain"""', 'chain'], {}), "('chain', chain)\n", (1923, 1939), True, 'import chainlit as cl\n'), ((2005, 2033), 'chainlit.user_session.get', 'cl.user_session.get', (['"""chain"""'], {}), "('chain')\n", (2024, 2033), True, 'import chainlit as cl\n'), ((2044, 2148), 'chainlit.AsyncLangchainCallbackHandler', 'cl.AsyncLangchainCallbackHandler', ([], {'stream_final_answer': '(True)', 'answer_prefix_tokens': "['FINAL', 'ANSWER']"}), "(stream_final_answer=True,\n answer_prefix_tokens=['FINAL', 'ANSWER'])\n", (2076, 2148), True, 'import chainlit as cl\n'), ((2438, 2464), 'chainlit.Message', 'cl.Message', ([], {'content': 'answer'}), '(content=answer)\n', (2448, 2464), True, 'import chainlit as cl\n')] |
# Import Langchain dependencies
from langchain.document_loaders import PyPDFLoader
from langchain.indexes import VectorstoreIndexCreator
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
# Bring in streamlit for UI dev
import streamlit as st
# Bring in watsonx interface
from watsonxlangchain import LangChainInterface
# Setup credentials dictionary
creds = {
"apiKey": "",
"url": "",
}
# Create LLM using langchain
llm = LangChainInterface(
credentials = creds,
model = "meta-llama/llama-2-70b-chat",
params = {
"decoding_method": "sample",
"max_new_tokens": 200,
"temperature": 0.5
},
project_id=""
)
# This function loads a PDF of your choosing
@st.cache_resource
def load_pdf():
# Update PDF name here to whatever you like
pdf_name= "what is generative ai.pdf"
loaders = [PyPDFLoader(pdf_name)]
# Create index - aka vector database - aka chromadb
index = VectorstoreIndexCreator(
embedding = HuggingFaceEmbeddings(model_name="all-MiniLM-L12-v2"),
text_splitter=RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=0)
).from_loaders(loaders)
# Return the vector database
return index
# Load er on up
index = load_pdf()
# Create a Q&A chain
chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=index.vectorstore.as_retriever()
)
# Setup the app title
st.title("Ask watsonx")
# Setup a session state message variable to hild all the old messages
if "messages" not in st.session_state:
st.session_state.messages = []
# Display all the historical messages
for message in st.session_state.messages:
st.chat_message(message["role"])
# Build a prompt input template to display the prompts
prompt = st.chat_input("Pass Your Prompt Here")
# If the user hits enter then
if prompt:
# Display the prompt
st.chat_message("user").markdown(prompt)
# Store the user prompt in state
st.session_state.messages.append({"role":"user", "content":prompt})
# Send the prompt to the llm
st.chat_message("assistant").markdown(response)
# Store the LLM response in state
st.session_state.messages.append(
{"role": "assistant", "content": response}
)
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.document_loaders.PyPDFLoader",
"langchain.embeddings.HuggingFaceEmbeddings"
] | [((539, 717), 'watsonxlangchain.LangChainInterface', 'LangChainInterface', ([], {'credentials': 'creds', 'model': '"""meta-llama/llama-2-70b-chat"""', 'params': "{'decoding_method': 'sample', 'max_new_tokens': 200, 'temperature': 0.5}", 'project_id': '""""""'}), "(credentials=creds, model='meta-llama/llama-2-70b-chat',\n params={'decoding_method': 'sample', 'max_new_tokens': 200,\n 'temperature': 0.5}, project_id='')\n", (557, 717), False, 'from watsonxlangchain import LangChainInterface\n'), ((1432, 1455), 'streamlit.title', 'st.title', (['"""Ask watsonx"""'], {}), "('Ask watsonx')\n", (1440, 1455), True, 'import streamlit as st\n'), ((1778, 1816), 'streamlit.chat_input', 'st.chat_input', (['"""Pass Your Prompt Here"""'], {}), "('Pass Your Prompt Here')\n", (1791, 1816), True, 'import streamlit as st\n'), ((1680, 1712), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (1695, 1712), True, 'import streamlit as st\n'), ((1958, 2027), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (1990, 2027), True, 'import streamlit as st\n'), ((2141, 2217), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'assistant', 'content': response}"], {}), "({'role': 'assistant', 'content': response})\n", (2173, 2217), True, 'import streamlit as st\n'), ((908, 929), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['pdf_name'], {}), '(pdf_name)\n', (919, 929), False, 'from langchain.document_loaders import PyPDFLoader\n'), ((1882, 1905), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (1897, 1905), True, 'import streamlit as st\n'), ((2057, 2085), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (2072, 2085), True, 'import streamlit as st\n'), ((1032, 1085), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""all-MiniLM-L12-v2"""'}), "(model_name='all-MiniLM-L12-v2')\n", (1053, 1085), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((1103, 1166), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(100)', 'chunk_overlap': '(0)'}), '(chunk_size=100, chunk_overlap=0)\n', (1133, 1166), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n')] |
import streamlit as st
import langchain
from langchain_community.document_loaders import RecursiveUrlLoader, TextLoader, JSONLoader
from langchain_community.document_transformers import Html2TextTransformer
from langchain.docstore.document import Document
from langchain_community.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter, CharacterTextSplitter
from langchain.vectorstores.faiss import FAISS
from langchain_community.vectorstores import Chroma
from langchain_community.callbacks import StreamlitCallbackHandler
from langchain.tools import tool
from langchain.tools.json.tool import JsonSpec
from langchain.agents import OpenAIFunctionsAgent, AgentExecutor, load_tools
#from langchain_experimental.tools.python.tool import PythonREPLTool
from langchain_community.agent_toolkits import JsonToolkit
from langchain.tools.retriever import create_retriever_tool
from langchain.agents.openai_functions_agent.agent_token_buffer_memory import (AgentTokenBufferMemory,)
from langchain_community.chat_models.openai import ChatOpenAI
from langchain.schema import SystemMessage, AIMessage, HumanMessage
from langchain.prompts import MessagesPlaceholder
from langsmith import Client
from langchain_community.vectorstores.redis import Redis
from langchain.vectorstores.redis import RedisText, RedisNum, RedisTag
from langchain.memory import RedisChatMessageHistory
from langchain.globals import set_llm_cache
import os, openai, requests, json, zeep, datetime, pandas as pd
from requests.auth import HTTPBasicAuth
#from dotenv import load_dotenv, find_dotenv
from zeep.wsse.username import UsernameToken
#_ = load_dotenv(find_dotenv()) # read local .env file
openai.api_key = os.getenv('OPENAI_API_KEY')
model = "gpt-4-1106-preview"
#model = "gpt-3.5-turbo-16k"
#model = "gpt-3.5-turbo"
embeddings = OpenAIEmbeddings()
TENANT = 'wdmarketdesk_dpt1'
WD_USER_ID = os.getenv('WD_USER_ID')
WD_PWD = os.getenv('WD_PWD')
WD_Worker_URL = "https://impl-services1.wd12.myworkday.com/ccx/service/customreport2/wdmarketdesk_dpt1/xjin-impl/Worker_Data?format=json"
WD_Absence_URL = "https://impl-services1.wd12.myworkday.com/ccx/service/customreport2/wdmarketdesk_dpt1/xjin-impl/Worker_Absence_Data_2?format=json&employee_id="
WD_COMP_URL = "https://impl-services1.wd12.myworkday.com/ccx/service/customreport2/wdmarketdesk_dpt1/xjin-impl/Worker_Comp_Data_2?format=json&employee_id="
WD_STAFFING_WSDL_URL = "https://impl-services1.wd12.myworkday.com/ccx/service/wdmarketdesk_dpt1/Staffing/v41.1?wsdl"
WD_HR_WSDL_URL = "https://impl-services1.wd12.myworkday.com/ccx/service/wdmarketdesk_dpt1/Human_Resources/v42.0?wsdl"
basicAuth = HTTPBasicAuth(WD_USER_ID, WD_PWD)
wd_hr_client = zeep.Client(WD_HR_WSDL_URL, wsse=UsernameToken(WD_USER_ID + '@' + TENANT, WD_PWD))
wd_staffing_client = zeep.Client(WD_STAFFING_WSDL_URL, wsse=UsernameToken(WD_USER_ID + '@' + TENANT, WD_PWD))
#client = Client()
rds = Redis.from_existing_index(
embeddings,
index_name="worker_hr",
redis_url="redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042",
password="1iI48215k0GAEC3gzmpfPrXD2UDXYOYN",
schema="worker_hr.yaml"
)
retriever = None
st.set_page_config(
page_title="Ask HR",
page_icon="🦜",
layout="wide",
initial_sidebar_state="collapsed",
)
"# Ask HR🦜🔗"
with st.form(key='login_form'):
col1, col2, col3 = st.columns([1,2,1])
with col1:
input_number = st.number_input(label='Enter Employee ID', min_value=0, max_value=1000000)
login_submit = st.form_submit_button(label='Submit')
def get_cache():
# construct cache implementation based on env var
CACHE_TYPE = os.getenv("CACHE_TYPE", "semantic")
REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
if CACHE_TYPE == "semantic":
from langchain.cache import RedisSemanticCache
print("Using semantic cache")
return RedisSemanticCache(
redis_url=REDIS_URL,
embedding=embeddings,
score_threshold=0.001,
)
else:
from langchain.cache import RedisCache
from langchain_community.utilities import redis
print("Using regular cache")
return RedisCache(redis_= redis.get_client(REDIS_URL))
def get_raas_data():
response = requests.get(WD_Worker_URL, auth = basicAuth)
responseJson = json.dumps(json.loads(response.content))
return responseJson
def get_worker_data():
employee_id = '21082'
worker_request_dict = {
'Worker_Reference': {
'ID': {
'type': 'Employee_ID',
'_value_1': employee_id
},
'Descriptor': None
},
'Skip_Non_Existing_Instances': None,
'Ignore_Invalid_References': None
}
response = zeep_client.service.Get_Workers(worker_request_dict)
return response.Response_Data
def get_worker_name(employee_id=0):
print("Trying to get Worker Name")
is_emp_id = RedisNum("Employee_ID") == employee_id
results = rds.similarity_search_with_score("", k=3, filter=is_emp_id if is_emp_id!=0 else None)
return results[0][0].metadata['Employee_Legal_Full_Name']
#@st.cache_resource(ttl="4h")
def initialize_retriever_redis(employee_id=0):
"""Initializes with all of worker data. If any information is not found, \
please use this tool as the default tool to look for the data needed. \
Do not try to get the same data more than 2 times.
"""
print("Initializing with Worker data in Redis", employee_id)
rds2 = Redis.from_existing_index(
embeddings,
index_name="worker_hr",
redis_url="redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042",
password="1iI48215k0GAEC3gzmpfPrXD2UDXYOYN",
schema="worker_hr.yaml"
)
print("returning from Redis")
return rds2.as_retriever(search_type="similarity",
search_kwargs={"k": 10, "filter": employee_id if employee_id!=0 else None})
#@st.cache_resource(ttl="4h")
def initialize_policies():
"""Initializes with all policies data for GMS. If any information is not found, \
please say you don't know. Do not make up answers. \
For each answer, provide source in brackets. \
Do not repeat the same source information in the same line.
In the final response, always replace word KPPRA with GMS
"""
print("Initializing with Policies")
rds = Redis.from_existing_index(
embeddings,
index_name="hr_policies",
redis_url="redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042",
password="1iI48215k0GAEC3gzmpfPrXD2UDXYOYN",
schema="hr_policies.yaml",
)
print("returning from Redis")
return rds.as_retriever(search_type="similarity", search_kwargs={"k": 5})
#@st.cache_resource(ttl="4h")
def initialize_retriever():
"""Initializes with all of worker data. If any information is not found, \
please use this tool as the default tool to look for the data needed. \
Do not try to get the same data more than 2 times.
"""
print("Initializing with all of worker data")
txt = get_raas_data()
# Split text
text_splitter = CharacterTextSplitter()
texts = text_splitter.split_text(txt)
# Create multiple documents
docs = [Document(page_content=t) for t in texts]
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
return vectorstore.as_retriever(search_kwargs={"k": 4})
@tool
def init_json_loader():
"""
Initializes with all of worker data. If any information is not found, \
please use this tool as the default tool to look for the data needed. \
"""
json_data = get_worker_data()
loader = JSONLoader(json_data, jq_schema='.messages[].content')
extracted_data = loader.load()
embeddings = OpenAIEmbeddings()
vector_store = Chroma.from_documents(extracted_data, embeddings)
return vector_store.as_retriever(search_kwargs={"k": 4})
#@st.cache_resource(ttl="4h")
def get_vectorstore(txt):
# Split text
text_splitter = CharacterTextSplitter()
texts = text_splitter.split_text(txt)
# Create multiple documents
docs = [Document(page_content=t) for t in texts]
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
return vectorstore.as_retriever(search_kwargs={"k": 4})
#@st.cache_resource(ttl="4h")
def get_Absence_Data(Employee_ID: str) -> str:
"""Returns PTO or absence or time off data. \
Use this for any questions related to knowing about PTO or absence or time off data. \
Use Employee ID as the input, \
and this function will return data as string or JSON structure \
"""
print(f"Getting absence data from Workday {WD_Absence_URL + str(input_number)}")
response = requests.get(WD_Absence_URL + str(input_number), auth = basicAuth)
responseJson = json.dumps(json.loads(response.content))
print(f"Absence Data: {responseJson}")
return get_vectorstore(responseJson)
@tool
#@st.cache_resource(ttl="4h")
def get_Comp_Data(text: str) -> str:
"""Returns Compensation or comp or salary data. \
Use this for any questions related to knowing about compensation or salary information. \
The input of text can not be empty string. \
and this function will return data as string or JSON structure \
"""
print(f"Getting comp data from Workday {WD_COMP_URL + str(input_number)}")
response = requests.get(WD_COMP_URL + str(input_number), auth = basicAuth)
responseJson = json.dumps(json.loads(response.content))
print(f"Comp Data: {responseJson}")
return get_vectorstore(responseJson)
@tool
def update_business_title(business_title: str) -> str:
"""Updates business title of the employee. \
Use this for any requests to update or change business title. \
The input can be an empty string or employee ID, \
and this function will return data as JSON structure \
"""
employee_id = '21072'
effective_date = '2023-11-12'
Business_Process_Parameters = {
'Auto_Complete': True,
'Run_Now': True,
'Discard_On_Exit_Validation_Error': True
}
Change_Business_Title_Business_Process_Data = {
'Worker_Reference': {
'ID': {
'type': 'Employee_ID',
'_value_1': employee_id
},
'Descriptor': None
},
'Change_Business_Title_Data': {
'Event_Effective_Date': effective_date,
'Proposed_Business_Title': business_title
}
}
try:
responseJson = wd_hr_client.service.Change_Business_Title(Business_Process_Parameters, Change_Business_Title_Business_Process_Data)
except zeep.exceptions.Fault as error:
responseJson = error
except BaseException as error:
responseJson = error
return (responseJson)
@tool
def add_additional_job(Job_Requisition_ID: str, effective_date: datetime.date) -> str:
"""Adds additional job to the employee. \
Use this for any requests to add more jobs to existing employees. \
The input can be an empty string or employee ID, \
and this function will return data as JSON structure \
"""
employee_id = '21072'
Organization_Reference_ID = 'SUPERVISORY_Finance_and_Administration'
#effective_date = '2023-11-17'
#Job_Requisition_ID = 'R-00306'
Event_Classification_Subcategory_ID = 'Add_Additional_Employee_Job_Secondment_Leave_of_Absence_Backfill'
true = True
Business_Process_Parameters = {
'Auto_Complete': True,
'Run_Now': True,
'Discard_On_Exit_Validation_Error': True
}
Add_Additional_Job_Data = {
'Employee_Reference': {
'ID': {
'type': 'Employee_ID',
'_value_1': employee_id
},
'Descriptor': None
},
'Organization_Reference': {
'ID': {
'type': 'Organization_Reference_ID',
'_value_1': Organization_Reference_ID
}
},
'Job_Requisition_Reference': {
'ID': {
'type': 'Job_Requisition_ID',
'_value_1': Job_Requisition_ID
}
},
'Add_Additional_Job_Event_Data': {
'Additional_Job_Reason_Reference': {
'ID': {
'type': 'Event_Classification_Subcategory_ID',
'_value_1': Event_Classification_Subcategory_ID
}
},
'Position_Details': {
}
},
'Event_Effective_Date': effective_date
}
try:
responseJson = wd_staffing_client.service.Add_Additional_Job(Business_Process_Parameters, Add_Additional_Job_Data)
except zeep.exceptions.Fault as error:
responseJson = error
return (responseJson)
tool = create_retriever_tool(
initialize_retriever_redis(input_number),
"Ask_HR",
"""Initializes with all of worker data. If any information is not found, \
please use this tool as the default tool to look for the data needed. \
"""
)
policies = create_retriever_tool(
initialize_policies(),
"Policies",
"""Initializes with all policies data for GMS. If any information is not found, \
please say you don't know. Do not make up answers. \
For each answer, provide source in brackets. \
Do not repeat the same source information in the same line. \
Do not call this tool more than 2 times. \
In the final response, always replace word KPPRA with GMS
"""
)
absence = create_retriever_tool(
get_Absence_Data(""),
"get_Absence_Data",
"""Returns PTO or absence or time off data. \
Use this for any questions related to knowing about PTO or absence or time off data. \
The input can be an empty string or employee ID, \
and this function will return data as string or JSON structure \
""")
comp = create_retriever_tool(
get_Comp_Data(""),
"get_Comp_Data",
"""Returns Compensation or comp or salary data. \
Use this for any questions related to knowing about compensation or salary information. \
If what is needed is not found, please use Ask_HR tool as the default tool instead. \
""")
tools = [tool, policies, absence, comp, update_business_title, add_additional_job]
try:
set_llm_cache(get_cache())
print("*** Retrieved cache ***")
except Exception as e:
print("*** Could not retrieve cache ***")
print(e)
pass
chat_llm = ChatOpenAI(temperature=0, streaming=True, model=model)
message = SystemMessage(
content=(
"""
You are HR Bot, an automated service to handle HR requests for an organization. \
Please "DO NOT" hallucinate.
You first greet the employee, then ask for what task he is looking to perform. \
If the request is related to PTO or Absences, Check to see if he has enough balance of hours by substracting requested hours from available balance. \
If he has enough balance, ask if he wants to submit for approval. \
If the balance is not enough let him know to adjust the request. \
You wait to collect all the details, then summarize it and check for a final \
time if the employee wants to change anything. \
Make sure to clarify all options, days and hours to uniquely identify the PTO from the options.\
You respond in a short, very conversational friendly style. \
When the user is ready to submit the request, Do not respond with plain human language but \
respond with type of PTO, hours and comments in JSON format. \
For type: Identify what type of PTO is being requested for submission. Use 'Reference_ID' value of the PTO plan for \
final JSON format. Do not show 'Reference_ID' for any intermediate human friendly updates or messages \
For hours: If he has enough balance, extract just numeric value of how many hours are being requested or submitted. \
If the balance is not enough consider 0. \
For comments: Extract the reason why employee is requesting or submitting the PTO \
The PTO options with available balances in hours includes as below in JSON format \
If the questions is on Policies and Rules provide very brief summary \
For each answer, if available, provide source including page number in brackets. \
In the final response, always replace word KPPRA with GMS
"""
)
)
prompt = OpenAIFunctionsAgent.create_prompt(
system_message=message,
extra_prompt_messages=[MessagesPlaceholder(variable_name="history")],
)
agent = OpenAIFunctionsAgent(llm=chat_llm, tools=tools, prompt=prompt)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True,
return_intermediate_steps=True,
)
memory = AgentTokenBufferMemory(llm=chat_llm)
#redis_memory = RedisChatMessageHistory()
starter_message = f"Hello and Welcome. I am here to help you with your HR needs!!"
if "messages" not in st.session_state or st.sidebar.button("Clear message history") or login_submit:
starter_message = f"Hello and Welcome. I am here to help you with your HR needs!!"
st.session_state["messages"] = [AIMessage(content=starter_message)]
#def send_feedback(run_id, score):
# client.create_feedback(run_id, "user_score", score=score)
for msg in st.session_state.messages:
if isinstance(msg, AIMessage):
st.chat_message("assistant").write(msg.content)
elif isinstance(msg, HumanMessage):
st.chat_message("user").write(msg.content)
memory.chat_memory.add_message(msg)
if prompt := st.chat_input(placeholder=starter_message):
st.chat_message("user").write(prompt)
with st.chat_message("assistant"):
st_callback = StreamlitCallbackHandler(st.container())
response = agent_executor(
{"input": prompt, "history": st.session_state.messages, "employee_id": input_number},
callbacks=[st_callback],
include_run_info=True,
)
print("returned from agent executor")
st.session_state.messages.append(AIMessage(content=response["output"]))
st.write(response["output"])
memory.save_context({"input": prompt}, response)
st.session_state["messages"] = memory.buffer
run_id = response["__run"].run_id
#col_blank, col_text, col1, col2 = st.columns([10, 2, 1, 1])
#with col_text:
# st.text('Feedback:')
#with col1:
# st.button('👍', on_click=send_feedback, args=(run_id, 1))
#with col2:
# st.button('👎', on_click=send_feedback, args=(run_id, 0))
| [
"langchain.vectorstores.redis.RedisNum",
"langchain.agents.openai_functions_agent.agent_token_buffer_memory.AgentTokenBufferMemory",
"langchain.text_splitter.CharacterTextSplitter",
"langchain.cache.RedisSemanticCache",
"langchain_community.embeddings.openai.OpenAIEmbeddings",
"langchain.schema.AIMessage",
"langchain.agents.OpenAIFunctionsAgent",
"langchain.agents.AgentExecutor",
"langchain.vectorstores.faiss.FAISS.from_documents",
"langchain_community.vectorstores.Chroma.from_documents",
"langchain.schema.SystemMessage",
"langchain_community.vectorstores.redis.Redis.from_existing_index",
"langchain_community.document_loaders.JSONLoader",
"langchain.docstore.document.Document",
"langchain.prompts.MessagesPlaceholder",
"langchain_community.chat_models.openai.ChatOpenAI",
"langchain_community.utilities.redis.get_client"
] | [((1732, 1759), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (1741, 1759), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((1857, 1875), 'langchain_community.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1873, 1875), False, 'from langchain_community.embeddings.openai import OpenAIEmbeddings\n'), ((1919, 1942), 'os.getenv', 'os.getenv', (['"""WD_USER_ID"""'], {}), "('WD_USER_ID')\n", (1928, 1942), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((1952, 1971), 'os.getenv', 'os.getenv', (['"""WD_PWD"""'], {}), "('WD_PWD')\n", (1961, 1971), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((2676, 2709), 'requests.auth.HTTPBasicAuth', 'HTTPBasicAuth', (['WD_USER_ID', 'WD_PWD'], {}), '(WD_USER_ID, WD_PWD)\n', (2689, 2709), False, 'from requests.auth import HTTPBasicAuth\n'), ((2945, 3167), 'langchain_community.vectorstores.redis.Redis.from_existing_index', 'Redis.from_existing_index', (['embeddings'], {'index_name': '"""worker_hr"""', 'redis_url': '"""redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042"""', 'password': '"""1iI48215k0GAEC3gzmpfPrXD2UDXYOYN"""', 'schema': '"""worker_hr.yaml"""'}), "(embeddings, index_name='worker_hr', redis_url=\n 'redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042',\n password='1iI48215k0GAEC3gzmpfPrXD2UDXYOYN', schema='worker_hr.yaml')\n", (2970, 3167), False, 'from langchain_community.vectorstores.redis import Redis\n'), ((3224, 3332), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""Ask HR"""', 'page_icon': '"""🦜"""', 'layout': '"""wide"""', 'initial_sidebar_state': '"""collapsed"""'}), "(page_title='Ask HR', page_icon='🦜', layout='wide',\n initial_sidebar_state='collapsed')\n", (3242, 3332), True, 'import streamlit as st\n'), ((14656, 14710), 'langchain_community.chat_models.openai.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'streaming': '(True)', 'model': 'model'}), '(temperature=0, streaming=True, model=model)\n', (14666, 14710), False, 'from langchain_community.chat_models.openai import ChatOpenAI\n'), ((14722, 16688), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': '"""\n You are HR Bot, an automated service to handle HR requests for an organization. Please "DO NOT" hallucinate.\n You first greet the employee, then ask for what task he is looking to perform. If the request is related to PTO or Absences, Check to see if he has enough balance of hours by substracting requested hours from available balance. If he has enough balance, ask if he wants to submit for approval. If the balance is not enough let him know to adjust the request. You wait to collect all the details, then summarize it and check for a final time if the employee wants to change anything. Make sure to clarify all options, days and hours to uniquely identify the PTO from the options. You respond in a short, very conversational friendly style. \n When the user is ready to submit the request, Do not respond with plain human language but respond with type of PTO, hours and comments in JSON format. \n For type: Identify what type of PTO is being requested for submission. Use \'Reference_ID\' value of the PTO plan for final JSON format. Do not show \'Reference_ID\' for any intermediate human friendly updates or messages For hours: If he has enough balance, extract just numeric value of how many hours are being requested or submitted. If the balance is not enough consider 0. For comments: Extract the reason why employee is requesting or submitting the PTO \n The PTO options with available balances in hours includes as below in JSON format \n If the questions is on Policies and Rules provide very brief summary For each answer, if available, provide source including page number in brackets. In the final response, always replace word KPPRA with GMS\n """'}), '(content=\n """\n You are HR Bot, an automated service to handle HR requests for an organization. Please "DO NOT" hallucinate.\n You first greet the employee, then ask for what task he is looking to perform. If the request is related to PTO or Absences, Check to see if he has enough balance of hours by substracting requested hours from available balance. If he has enough balance, ask if he wants to submit for approval. If the balance is not enough let him know to adjust the request. You wait to collect all the details, then summarize it and check for a final time if the employee wants to change anything. Make sure to clarify all options, days and hours to uniquely identify the PTO from the options. You respond in a short, very conversational friendly style. \n When the user is ready to submit the request, Do not respond with plain human language but respond with type of PTO, hours and comments in JSON format. \n For type: Identify what type of PTO is being requested for submission. Use \'Reference_ID\' value of the PTO plan for final JSON format. Do not show \'Reference_ID\' for any intermediate human friendly updates or messages For hours: If he has enough balance, extract just numeric value of how many hours are being requested or submitted. If the balance is not enough consider 0. For comments: Extract the reason why employee is requesting or submitting the PTO \n The PTO options with available balances in hours includes as below in JSON format \n If the questions is on Policies and Rules provide very brief summary For each answer, if available, provide source including page number in brackets. In the final response, always replace word KPPRA with GMS\n """\n )\n', (14735, 16688), False, 'from langchain.schema import SystemMessage, AIMessage, HumanMessage\n'), ((16898, 16960), 'langchain.agents.OpenAIFunctionsAgent', 'OpenAIFunctionsAgent', ([], {'llm': 'chat_llm', 'tools': 'tools', 'prompt': 'prompt'}), '(llm=chat_llm, tools=tools, prompt=prompt)\n', (16918, 16960), False, 'from langchain.agents import OpenAIFunctionsAgent, AgentExecutor, load_tools\n'), ((16979, 17068), 'langchain.agents.AgentExecutor', 'AgentExecutor', ([], {'agent': 'agent', 'tools': 'tools', 'verbose': '(True)', 'return_intermediate_steps': '(True)'}), '(agent=agent, tools=tools, verbose=True,\n return_intermediate_steps=True)\n', (16992, 17068), False, 'from langchain.agents import OpenAIFunctionsAgent, AgentExecutor, load_tools\n'), ((17094, 17130), 'langchain.agents.openai_functions_agent.agent_token_buffer_memory.AgentTokenBufferMemory', 'AgentTokenBufferMemory', ([], {'llm': 'chat_llm'}), '(llm=chat_llm)\n', (17116, 17130), False, 'from langchain.agents.openai_functions_agent.agent_token_buffer_memory import AgentTokenBufferMemory\n'), ((3368, 3393), 'streamlit.form', 'st.form', ([], {'key': '"""login_form"""'}), "(key='login_form')\n", (3375, 3393), True, 'import streamlit as st\n'), ((3418, 3439), 'streamlit.columns', 'st.columns', (['[1, 2, 1]'], {}), '([1, 2, 1])\n', (3428, 3439), True, 'import streamlit as st\n'), ((3570, 3607), 'streamlit.form_submit_button', 'st.form_submit_button', ([], {'label': '"""Submit"""'}), "(label='Submit')\n", (3591, 3607), True, 'import streamlit as st\n'), ((3698, 3733), 'os.getenv', 'os.getenv', (['"""CACHE_TYPE"""', '"""semantic"""'], {}), "('CACHE_TYPE', 'semantic')\n", (3707, 3733), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((3750, 3798), 'os.getenv', 'os.getenv', (['"""REDIS_URL"""', '"""redis://localhost:6379"""'], {}), "('REDIS_URL', 'redis://localhost:6379')\n", (3759, 3798), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((4326, 4369), 'requests.get', 'requests.get', (['WD_Worker_URL'], {'auth': 'basicAuth'}), '(WD_Worker_URL, auth=basicAuth)\n', (4338, 4369), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((5599, 5821), 'langchain_community.vectorstores.redis.Redis.from_existing_index', 'Redis.from_existing_index', (['embeddings'], {'index_name': '"""worker_hr"""', 'redis_url': '"""redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042"""', 'password': '"""1iI48215k0GAEC3gzmpfPrXD2UDXYOYN"""', 'schema': '"""worker_hr.yaml"""'}), "(embeddings, index_name='worker_hr', redis_url=\n 'redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042',\n password='1iI48215k0GAEC3gzmpfPrXD2UDXYOYN', schema='worker_hr.yaml')\n", (5624, 5821), False, 'from langchain_community.vectorstores.redis import Redis\n'), ((6490, 6716), 'langchain_community.vectorstores.redis.Redis.from_existing_index', 'Redis.from_existing_index', (['embeddings'], {'index_name': '"""hr_policies"""', 'redis_url': '"""redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042"""', 'password': '"""1iI48215k0GAEC3gzmpfPrXD2UDXYOYN"""', 'schema': '"""hr_policies.yaml"""'}), "(embeddings, index_name='hr_policies', redis_url=\n 'redis://redis-10042.c280.us-central1-2.gce.cloud.redislabs.com:10042',\n password='1iI48215k0GAEC3gzmpfPrXD2UDXYOYN', schema='hr_policies.yaml')\n", (6515, 6716), False, 'from langchain_community.vectorstores.redis import Redis\n'), ((7258, 7281), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {}), '()\n', (7279, 7281), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter, CharacterTextSplitter\n'), ((7431, 7449), 'langchain_community.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (7447, 7449), False, 'from langchain_community.embeddings.openai import OpenAIEmbeddings\n'), ((7468, 7506), 'langchain.vectorstores.faiss.FAISS.from_documents', 'FAISS.from_documents', (['docs', 'embeddings'], {}), '(docs, embeddings)\n', (7488, 7506), False, 'from langchain.vectorstores.faiss import FAISS\n'), ((7813, 7867), 'langchain_community.document_loaders.JSONLoader', 'JSONLoader', (['json_data'], {'jq_schema': '""".messages[].content"""'}), "(json_data, jq_schema='.messages[].content')\n", (7823, 7867), False, 'from langchain_community.document_loaders import RecursiveUrlLoader, TextLoader, JSONLoader\n'), ((7920, 7938), 'langchain_community.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (7936, 7938), False, 'from langchain_community.embeddings.openai import OpenAIEmbeddings\n'), ((7958, 8007), 'langchain_community.vectorstores.Chroma.from_documents', 'Chroma.from_documents', (['extracted_data', 'embeddings'], {}), '(extracted_data, embeddings)\n', (7979, 8007), False, 'from langchain_community.vectorstores import Chroma\n'), ((8168, 8191), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {}), '()\n', (8189, 8191), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter, CharacterTextSplitter\n'), ((8341, 8359), 'langchain_community.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (8357, 8359), False, 'from langchain_community.embeddings.openai import OpenAIEmbeddings\n'), ((8378, 8416), 'langchain.vectorstores.faiss.FAISS.from_documents', 'FAISS.from_documents', (['docs', 'embeddings'], {}), '(docs, embeddings)\n', (8398, 8416), False, 'from langchain.vectorstores.faiss import FAISS\n'), ((17299, 17341), 'streamlit.sidebar.button', 'st.sidebar.button', (['"""Clear message history"""'], {}), "('Clear message history')\n", (17316, 17341), True, 'import streamlit as st\n'), ((17892, 17934), 'streamlit.chat_input', 'st.chat_input', ([], {'placeholder': 'starter_message'}), '(placeholder=starter_message)\n', (17905, 17934), True, 'import streamlit as st\n'), ((2758, 2806), 'zeep.wsse.username.UsernameToken', 'UsernameToken', (["(WD_USER_ID + '@' + TENANT)", 'WD_PWD'], {}), "(WD_USER_ID + '@' + TENANT, WD_PWD)\n", (2771, 2806), False, 'from zeep.wsse.username import UsernameToken\n'), ((2869, 2917), 'zeep.wsse.username.UsernameToken', 'UsernameToken', (["(WD_USER_ID + '@' + TENANT)", 'WD_PWD'], {}), "(WD_USER_ID + '@' + TENANT, WD_PWD)\n", (2882, 2917), False, 'from zeep.wsse.username import UsernameToken\n'), ((3476, 3550), 'streamlit.number_input', 'st.number_input', ([], {'label': '"""Enter Employee ID"""', 'min_value': '(0)', 'max_value': '(1000000)'}), "(label='Enter Employee ID', min_value=0, max_value=1000000)\n", (3491, 3550), True, 'import streamlit as st\n'), ((3940, 4028), 'langchain.cache.RedisSemanticCache', 'RedisSemanticCache', ([], {'redis_url': 'REDIS_URL', 'embedding': 'embeddings', 'score_threshold': '(0.001)'}), '(redis_url=REDIS_URL, embedding=embeddings,\n score_threshold=0.001)\n', (3958, 4028), False, 'from langchain.cache import RedisSemanticCache\n'), ((4402, 4430), 'json.loads', 'json.loads', (['response.content'], {}), '(response.content)\n', (4412, 4430), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((5026, 5049), 'langchain.vectorstores.redis.RedisNum', 'RedisNum', (['"""Employee_ID"""'], {}), "('Employee_ID')\n", (5034, 5049), False, 'from langchain.vectorstores.redis import RedisText, RedisNum, RedisTag\n'), ((7368, 7392), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 't'}), '(page_content=t)\n', (7376, 7392), False, 'from langchain.docstore.document import Document\n'), ((8278, 8302), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 't'}), '(page_content=t)\n', (8286, 8302), False, 'from langchain.docstore.document import Document\n'), ((9006, 9034), 'json.loads', 'json.loads', (['response.content'], {}), '(response.content)\n', (9016, 9034), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((9660, 9688), 'json.loads', 'json.loads', (['response.content'], {}), '(response.content)\n', (9670, 9688), False, 'import os, openai, requests, json, zeep, datetime, pandas as pd\n'), ((17482, 17516), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'starter_message'}), '(content=starter_message)\n', (17491, 17516), False, 'from langchain.schema import SystemMessage, AIMessage, HumanMessage\n'), ((17987, 18015), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (18002, 18015), True, 'import streamlit as st\n'), ((18429, 18457), 'streamlit.write', 'st.write', (["response['output']"], {}), "(response['output'])\n", (18437, 18457), True, 'import streamlit as st\n'), ((16840, 16884), 'langchain.prompts.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': '"""history"""'}), "(variable_name='history')\n", (16859, 16884), False, 'from langchain.prompts import MessagesPlaceholder\n'), ((17940, 17963), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (17955, 17963), True, 'import streamlit as st\n'), ((18064, 18078), 'streamlit.container', 'st.container', ([], {}), '()\n', (18076, 18078), True, 'import streamlit as st\n'), ((18382, 18419), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': "response['output']"}), "(content=response['output'])\n", (18391, 18419), False, 'from langchain.schema import SystemMessage, AIMessage, HumanMessage\n'), ((4256, 4283), 'langchain_community.utilities.redis.get_client', 'redis.get_client', (['REDIS_URL'], {}), '(REDIS_URL)\n', (4272, 4283), False, 'from langchain_community.utilities import redis\n'), ((17699, 17727), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (17714, 17727), True, 'import streamlit as st\n'), ((17795, 17818), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (17810, 17818), True, 'import streamlit as st\n')] |
# Using flask to make an api
# import necessary libraries and functions
from flask import Flask, jsonify, request, render_template
from pydantic import BaseModel
from ast import literal_eval
import os
import openai
openai.api_key = os.getenv("OPENAI_API_KEY")
import langchain
from langchain.vectorstores import FAISS
from langchain.embeddings.openai import OpenAIEmbeddings
# creating a Flask app
app = Flask(__name__)
# on the terminal type: curl http://127.0.0.1:5000/
# returns hello world when we use GET.
# returns the data that we send when we use POST.
@app.route('/related', methods = ['GET', 'POST'])
def home():
if(request.method == 'GET'):
data = "its up"
return jsonify({'data': data})
if(request.method == 'POST'):
temp= request.get_json()
print(temp)
vector = temp["ve"]
ticker = temp["ticker"]
embeddings = OpenAIEmbeddings(openai.api_key)
print(str(ticker))
new_db = FAISS.load_local(str(ticker), embeddings)
ar = literal_eval(vector)
docs_and_scores = new_db.similarity_search_by_vector(ar)
size = len(docs_and_scores)
data = ""
for i in range(0,size):
data+=(docs_and_scores[i].page_content + "\n\n")
print(data)
return jsonify({'data': data})
def relatedwords(ticker, vembeddings):
embeddings = OpenAIEmbeddings()
print(str(ticker))
new_db = FAISS.load_local(ticker, embeddings)
# ar = literal_eval(vector)
docs_and_scores = new_db.similarity_search_by_vector(vembeddings)
size = len(docs_and_scores)
data = ""
for i in range(0,size):
data+=(docs_and_scores[i].page_content + "\n\n")
print(data)
return data
def completion(context):
completion = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
temperature = 0,
messages=[
{
"role": "system",
"content": "You are a financial assistant that VERY ACCURATELY and CONCISELY answers queries using publicly filled annual reports of publicly traded companies. Use the CONTEXT provided to form your answer. Keep your answer under 5 sentences. Be accurate, helpful, concise, and clear, while performing accurate mathematical calculations."
},
{
"role": "user",
"content": context
}
]
)
return (completion.choices[0].message["content"])
def embeddingsgenerate(embeddingsof):
embeddings = openai.Embedding.create(
model="text-embedding-ada-002",
input=embeddingsof
)
return embeddings["data"][0]["embedding"]
@app.route('/generate_embeddings', methods= ['GET', 'POST'])
def get_embeddings():
if(request.method == 'GET'):
data = "its up"
return jsonify({'data': data})
if(request.method == 'POST'):
data = request.get_json()
texts = data['texts']
embeddings = openai.Encodings.create(texts)
return jsonify({'embeddings': embeddings})
@app.route('/<path_name>',methods=['GET', 'POST'])
def answer_question(path_name):
urlforprice = ("https://s.tradingview.com/embed-widget/symbol-info/?locale=en&colorTheme=dark&symbol=BSE:"+path_name)
if request.method == 'POST':
# User submitted a question, so process it and get an answer from OpenAI
question = request.form['question']
# openai_api_key = request.form['openai_api_key']
prompt = f"{question}"
embeddings_recieved = embeddingsgenerate(question)
context = relatedwords(path_name, embeddings_recieved)
questionforgpt = "CONTEXT\n\n" + context + "\nQUESTION\n" + prompt
answerfromgpt = completion(questionforgpt)
print(answerfromgpt)
return render_template('chat.html', path_name=path_name, questionasked=prompt, urlforprice=urlforprice, embeddings_recieved = context, answer_received = answerfromgpt)
else:
answer = "not yet used"
# Render the answer on an HTML template
return render_template('chat.html', path_name=path_name, answer=answer,urlforprice=urlforprice)
@app.route('/',methods=['GET'])
def homepage():
return render_template('home.html')
# driver function
if __name__ == '__main__':
app.run(debug = True)
| [
"langchain.embeddings.openai.OpenAIEmbeddings",
"langchain.vectorstores.FAISS.load_local"
] | [((235, 262), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (244, 262), False, 'import os\n'), ((412, 427), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (417, 427), False, 'from flask import Flask, jsonify, request, render_template\n'), ((1396, 1414), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1412, 1414), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((1451, 1487), 'langchain.vectorstores.FAISS.load_local', 'FAISS.load_local', (['ticker', 'embeddings'], {}), '(ticker, embeddings)\n', (1467, 1487), False, 'from langchain.vectorstores import FAISS\n'), ((1807, 2295), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-3.5-turbo"""', 'temperature': '(0)', 'messages': "[{'role': 'system', 'content':\n 'You are a financial assistant that VERY ACCURATELY and CONCISELY answers queries using publicly filled annual reports of publicly traded companies. Use the CONTEXT provided to form your answer. Keep your answer under 5 sentences. Be accurate, helpful, concise, and clear, while performing accurate mathematical calculations.'\n }, {'role': 'user', 'content': context}]"}), "(model='gpt-3.5-turbo', temperature=0, messages\n =[{'role': 'system', 'content':\n 'You are a financial assistant that VERY ACCURATELY and CONCISELY answers queries using publicly filled annual reports of publicly traded companies. Use the CONTEXT provided to form your answer. Keep your answer under 5 sentences. Be accurate, helpful, concise, and clear, while performing accurate mathematical calculations.'\n }, {'role': 'user', 'content': context}])\n", (1835, 2295), False, 'import openai\n'), ((2502, 2577), 'openai.Embedding.create', 'openai.Embedding.create', ([], {'model': '"""text-embedding-ada-002"""', 'input': 'embeddingsof'}), "(model='text-embedding-ada-002', input=embeddingsof)\n", (2525, 2577), False, 'import openai\n'), ((4211, 4239), 'flask.render_template', 'render_template', (['"""home.html"""'], {}), "('home.html')\n", (4226, 4239), False, 'from flask import Flask, jsonify, request, render_template\n'), ((709, 732), 'flask.jsonify', 'jsonify', (["{'data': data}"], {}), "({'data': data})\n", (716, 732), False, 'from flask import Flask, jsonify, request, render_template\n'), ((785, 803), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (801, 803), False, 'from flask import Flask, jsonify, request, render_template\n'), ((906, 938), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', (['openai.api_key'], {}), '(openai.api_key)\n', (922, 938), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((1038, 1058), 'ast.literal_eval', 'literal_eval', (['vector'], {}), '(vector)\n', (1050, 1058), False, 'from ast import literal_eval\n'), ((1310, 1333), 'flask.jsonify', 'jsonify', (["{'data': data}"], {}), "({'data': data})\n", (1317, 1333), False, 'from flask import Flask, jsonify, request, render_template\n'), ((2806, 2829), 'flask.jsonify', 'jsonify', (["{'data': data}"], {}), "({'data': data})\n", (2813, 2829), False, 'from flask import Flask, jsonify, request, render_template\n'), ((2879, 2897), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (2895, 2897), False, 'from flask import Flask, jsonify, request, render_template\n'), ((2949, 2979), 'openai.Encodings.create', 'openai.Encodings.create', (['texts'], {}), '(texts)\n', (2972, 2979), False, 'import openai\n'), ((2995, 3030), 'flask.jsonify', 'jsonify', (["{'embeddings': embeddings}"], {}), "({'embeddings': embeddings})\n", (3002, 3030), False, 'from flask import Flask, jsonify, request, render_template\n'), ((3792, 3957), 'flask.render_template', 'render_template', (['"""chat.html"""'], {'path_name': 'path_name', 'questionasked': 'prompt', 'urlforprice': 'urlforprice', 'embeddings_recieved': 'context', 'answer_received': 'answerfromgpt'}), "('chat.html', path_name=path_name, questionasked=prompt,\n urlforprice=urlforprice, embeddings_recieved=context, answer_received=\n answerfromgpt)\n", (3807, 3957), False, 'from flask import Flask, jsonify, request, render_template\n'), ((4059, 4152), 'flask.render_template', 'render_template', (['"""chat.html"""'], {'path_name': 'path_name', 'answer': 'answer', 'urlforprice': 'urlforprice'}), "('chat.html', path_name=path_name, answer=answer,\n urlforprice=urlforprice)\n", (4074, 4152), False, 'from flask import Flask, jsonify, request, render_template\n')] |
# -*- coding: utf-8 -*-
import random
import streamlit as st
from langchain.llms import OpenAI
from langchain.text_splitter import RecursiveCharacterTextSplitter
#from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
import openai
# from playsound import playsound
from gtts import gTTS
from PyPDF2 import PdfReader
from utils import text_to_docs
from langchain import PromptTemplate, LLMChain
#import os
#from io import StringIO
#from langchain.embeddings.openai import OpenAIEmbeddings
#from langchain.chains.summarize import load_summarize_chain
#import os
#import pyaudio
#import wave
#import langchain
#from langchain.document_loaders import UnstructuredPDFLoader
#from io import BytesIO
# import streamlit.components.v1 as components
#from st_custom_components import st_audiorec, text_to_docs
#import sounddevice as sd
#from scipy.io.wavfile import write
from usellm import Message, Options, UseLLM
llm = OpenAI(model_name='text-davinci-003', temperature=0.2, max_tokens=512, openai_api_key=st.secrets["api_key"])
def record_audio(filename):
duration=5
sample_rate = 44100
# Record audio
audio_data = sd.rec(int(duration * sample_rate), samplerate=sample_rate, channels=6)
st.write('Recording started. Speak into the microphone...')
# Wait for recording to complete
sd.wait()
# Save the recorded audio to a WAV file
write(filename, sample_rate, audio_data)
st.write(f'Recording saved as {filename}')
def transcribe_audio(filename):
with open(filename, "rb") as audio_file:
transcript = openai.Audio.transcribe("whisper-1", filename)
return transcript["text"]
st.title("Suspicious Activity Reporting")
st.subheader('Evidence Processor')
model_name = "sentence-transformers/all-MiniLM-L6-v2"
@st.cache_data
def usellm(prompt):
service = UseLLM(service_url="https://usellm.org/api/llm")
messages = [
Message(role="system", content="You are a fraud analyst"),
Message(role="user", content=f"{prompt}"),
]
options = Options(messages=messages)
response = service.chat(options)
return response.content
@st.cache_resource
def embed(model_name):
hf_embeddings = HuggingFaceEmbeddings(model_name=model_name)
return hf_embeddings
# @st.cache_resource
# def chain(_llm):
# chain = load_summarize_chain(llm=_llm, chain_type="map_reduce")
# chain = load_summarize_chain(llm=llm, chain_type="map_reduce")
hf_embeddings = embed(model_name)
# File Upload
file = st.file_uploader("Upload a file")
st.write(file)
text_splitter = RecursiveCharacterTextSplitter(
# Set a really small chunk size, just to show.
chunk_size = 1500,
chunk_overlap = 100,
length_function = len,
separators=["\n\n", "\n", " ", ""]
)
#text_splitter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=100, chunk_overlap=0)
#texts = ''
@st.cache_data
def embedding_store(file):
# save file
pdf_reader = PdfReader(file)
text = ""
for page in pdf_reader.pages:
text += page.extract_text()
#st.write(text)
texts = text_splitter.split_text(text)
docs = text_to_docs(texts)
#st.write(texts)
docsearch = FAISS.from_documents(docs, hf_embeddings)
return docs, docsearch
# Submit Button
if st.button("Submit"):
if file is not None:
# File handling logic
st.write("File Uploaded...")
_, docsearch = embedding_store(file)
queries ="Any fraud encountered in the passed document?\
if any."
contexts = docsearch.similarity_search(queries, k=1)
prompts = f"Give concise answer to the below questions as truthfully as possible as per given context only,\n\n\
Context: {contexts}\n\
Response (in readable bullet points): "
response = usellm(prompts)
# Print the assistant's response
# st.subheader("Few informative points in the uploaded document are as follows:")
# st.write(response)
#st.write("Uploaded File Contents:")
if file is not None:
docs, docsearch = embedding_store(file)
#docs = text_to_docs(texts)
#st.write(docs)
#summary = chain.run(docs)
#st.write(summary)
#st.header("Speech and Text Input")
# Speech Input
# st.subheader("Speech Input")
# wav_audio_data = st_audiorec()
# if wav_audio_data is not None:
# st.audio(wav_audio_data, format='audio/wav')
# audio_text = transcribe_audio(wav_audio_data)
# st.write(audio_text)
# if st.button("Voice Input"):
# rand = random.randint(1, 10000)*random.randint(10001,20000)
# audio_filename = f"recorded_audio{rand}.wav"
# record_audio(filename=audio_filename)
# aud = transcribe_audio(audio_filename)
# st.write(aud)
# Text Input
st.subheader("Ask Questions")
query = st.text_input('your queries will go here...')
def LLM_Response():
llm_chain = LLMChain(prompt=prompt, llm=llm)
response = llm_chain.run({"query":query, "context":context})
return response
if query:
# Text input handling logic
#st.write("Text Input:")
#st.write(text_input)
context = docsearch.similarity_search(query, k=5)
prompt = f"Act as a financial analyst and give concise answer to below Question as truthfully as possible, with given Context\n\n\
Question: {query}\n\
Context: {context}\n\
Response: "
#prompt = PromptTemplate(template=prompt, input_variables=["query", "context"])
response = usellm(prompt) #LLM_Response()
st.write(response)
# language = 'en'
# Create a gTTS object
# tts = gTTS(text=response, lang=language)
# Save the audio file
# rand = random.randint(1, 10000)*random.randint(10001,20000)
# audio_file = f'output{rand}.mp3'
# tts.save(audio_file)
# playsound(audio_file)
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.llms.OpenAI",
"langchain.vectorstores.FAISS.from_documents",
"langchain.embeddings.HuggingFaceEmbeddings",
"langchain.LLMChain"
] | [((1047, 1159), 'langchain.llms.OpenAI', 'OpenAI', ([], {'model_name': '"""text-davinci-003"""', 'temperature': '(0.2)', 'max_tokens': '(512)', 'openai_api_key': "st.secrets['api_key']"}), "(model_name='text-davinci-003', temperature=0.2, max_tokens=512,\n openai_api_key=st.secrets['api_key'])\n", (1053, 1159), False, 'from langchain.llms import OpenAI\n'), ((1791, 1832), 'streamlit.title', 'st.title', (['"""Suspicious Activity Reporting"""'], {}), "('Suspicious Activity Reporting')\n", (1799, 1832), True, 'import streamlit as st\n'), ((1834, 1868), 'streamlit.subheader', 'st.subheader', (['"""Evidence Processor"""'], {}), "('Evidence Processor')\n", (1846, 1868), True, 'import streamlit as st\n'), ((2673, 2706), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload a file"""'], {}), "('Upload a file')\n", (2689, 2706), True, 'import streamlit as st\n'), ((2710, 2724), 'streamlit.write', 'st.write', (['file'], {}), '(file)\n', (2718, 2724), True, 'import streamlit as st\n'), ((2742, 2869), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1500)', 'chunk_overlap': '(100)', 'length_function': 'len', 'separators': "['\\n\\n', '\\n', ' ', '']"}), "(chunk_size=1500, chunk_overlap=100,\n length_function=len, separators=['\\n\\n', '\\n', ' ', ''])\n", (2772, 2869), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((3468, 3487), 'streamlit.button', 'st.button', (['"""Submit"""'], {}), "('Submit')\n", (3477, 3487), True, 'import streamlit as st\n'), ((4989, 5018), 'streamlit.subheader', 'st.subheader', (['"""Ask Questions"""'], {}), "('Ask Questions')\n", (5001, 5018), True, 'import streamlit as st\n'), ((5028, 5073), 'streamlit.text_input', 'st.text_input', (['"""your queries will go here..."""'], {}), "('your queries will go here...')\n", (5041, 5073), True, 'import streamlit as st\n'), ((1343, 1402), 'streamlit.write', 'st.write', (['"""Recording started. Speak into the microphone..."""'], {}), "('Recording started. Speak into the microphone...')\n", (1351, 1402), True, 'import streamlit as st\n'), ((1554, 1596), 'streamlit.write', 'st.write', (['f"""Recording saved as {filename}"""'], {}), "(f'Recording saved as {filename}')\n", (1562, 1596), True, 'import streamlit as st\n'), ((1982, 2030), 'usellm.UseLLM', 'UseLLM', ([], {'service_url': '"""https://usellm.org/api/llm"""'}), "(service_url='https://usellm.org/api/llm')\n", (1988, 2030), False, 'from usellm import Message, Options, UseLLM\n'), ((2189, 2215), 'usellm.Options', 'Options', ([], {'messages': 'messages'}), '(messages=messages)\n', (2196, 2215), False, 'from usellm import Message, Options, UseLLM\n'), ((2352, 2396), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': 'model_name'}), '(model_name=model_name)\n', (2373, 2396), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((3135, 3150), 'PyPDF2.PdfReader', 'PdfReader', (['file'], {}), '(file)\n', (3144, 3150), False, 'from PyPDF2 import PdfReader\n'), ((3316, 3335), 'utils.text_to_docs', 'text_to_docs', (['texts'], {}), '(texts)\n', (3328, 3335), False, 'from utils import text_to_docs\n'), ((3375, 3416), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['docs', 'hf_embeddings'], {}), '(docs, hf_embeddings)\n', (3395, 3416), False, 'from langchain.vectorstores import FAISS\n'), ((5114, 5146), 'langchain.LLMChain', 'LLMChain', ([], {'prompt': 'prompt', 'llm': 'llm'}), '(prompt=prompt, llm=llm)\n', (5122, 5146), False, 'from langchain import PromptTemplate, LLMChain\n'), ((5779, 5797), 'streamlit.write', 'st.write', (['response'], {}), '(response)\n', (5787, 5797), True, 'import streamlit as st\n'), ((1704, 1750), 'openai.Audio.transcribe', 'openai.Audio.transcribe', (['"""whisper-1"""', 'filename'], {}), "('whisper-1', filename)\n", (1727, 1750), False, 'import openai\n'), ((2056, 2113), 'usellm.Message', 'Message', ([], {'role': '"""system"""', 'content': '"""You are a fraud analyst"""'}), "(role='system', content='You are a fraud analyst')\n", (2063, 2113), False, 'from usellm import Message, Options, UseLLM\n'), ((2122, 2163), 'usellm.Message', 'Message', ([], {'role': '"""user"""', 'content': 'f"""{prompt}"""'}), "(role='user', content=f'{prompt}')\n", (2129, 2163), False, 'from usellm import Message, Options, UseLLM\n'), ((3555, 3583), 'streamlit.write', 'st.write', (['"""File Uploaded..."""'], {}), "('File Uploaded...')\n", (3563, 3583), True, 'import streamlit as st\n')] |
import langchain
from langchain.agents import load_tools, initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI
langchain.verbose = True
langchain.debug = True
def get_chat():
return ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
if __name__ == "__main__":
chat = get_chat()
tools = load_tools(["terminal"])
agent_chain = initialize_agent(
tools, chat, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION
)
result = agent_chain.run("sample_data ディレクトリにあるファイルの一覧を教えて")
print(result)
# {
# "prompts": [
# "Human: Answer the following questions as best you can. You have access to the following tools:
# terminal: Run shell commands on this Linux machine.
# Use the following format:
#
# Question: the input question you must answer
# Thought: you should always think about what to do
# Action: the action to take, should be one of [terminal]
# Action Input: the input to the action
# Observation: the result of the action
# ... (this Thought/Action/Action Input/Observation can repeat N times)
# Thought: I now know the final answer
# Final Answer: the final answer to the original input question
#
# Begin!
#
# Question: sample_data ディレクトリにあるファイルの一覧を教えて
# Thought:I need to list the files in the sample_data directory.
# Action: terminal
# Action Input: ls sample_data
# Observation: ls: cannot access 'sample_data': No such file or directory
#
# Thought:The sample_data directory does not exist. I need to find the correct directory.
# Action: terminal
# Action Input: ls
# Observation: Dockerfile
# app
# docker-compose.yml
# langchain
# requirements.txt
# venv
#
# Thought:The sample_data directory is not in the current directory. I need to search for it.
# Action: terminal
# Action Input: find / -name sample_data
# Observation: /usr/src/app/sample_data
# /opt/project/app/sample_data
#
# Thought:"
# ]
# } | [
"langchain.agents.load_tools",
"langchain.agents.initialize_agent",
"langchain.chat_models.ChatOpenAI"
] | [((209, 262), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0)'}), "(model_name='gpt-3.5-turbo', temperature=0)\n", (219, 262), False, 'from langchain.chat_models import ChatOpenAI\n'), ((326, 350), 'langchain.agents.load_tools', 'load_tools', (["['terminal']"], {}), "(['terminal'])\n", (336, 350), False, 'from langchain.agents import load_tools, initialize_agent, AgentType\n'), ((369, 443), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'chat'], {'agent': 'AgentType.ZERO_SHOT_REACT_DESCRIPTION'}), '(tools, chat, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)\n', (385, 443), False, 'from langchain.agents import load_tools, initialize_agent, AgentType\n')] |
from llama_index import (
GPTVectorStoreIndex,
ServiceContext,
)
from llama_index.postprocessor import SentenceTransformerRerank
from llama_index.embeddings import LangchainEmbedding
from langchain.embeddings.huggingface import (
HuggingFaceBgeEmbeddings,
)
from llama_index.vector_stores import WeaviateVectorStore
from llama_index.postprocessor import MetadataReplacementPostProcessor
import weaviate
from llama_index.prompts.base import PromptTemplate
from prompt import MISTRAL_V2_CHAT
from langchain_community.llms import HuggingFaceTextGenInference
from llama_index.llms import LangChainLLM
from llama_index.memory import ChatMemoryBuffer
import re
from llama_index import (
ServiceContext,
set_global_handler,
)
from typing import List
from llama_index.bridge.langchain import (
HumanMessage,
)
from llama_index.bridge.langchain import BaseMessage
from langchain_community.chat_models.huggingface import ChatHuggingFace
from huggingface_hub.commands.user import login
token = "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"
if login(token=token):
print("Login success")
client = weaviate.Client("http://192.168.88.10:8080")
vector_store = WeaviateVectorStore(
weaviate_client=client, index_name="LlamaIndex"
)
class CustomChatHuggingFace(ChatHuggingFace):
def _to_chat_prompt(
self,
messages: List[BaseMessage],
) -> str:
"""Convert a list of messages into a prompt format expected by wrapped LLM."""
if not messages:
raise ValueError("at least one HumanMessage must be provided")
if not isinstance(messages[-1], HumanMessage):
raise ValueError("last message must be a HumanMessage")
messages_dicts = [self._to_chatml_format(m) for m in messages]
system_str = "<s>[INST] "+ messages_dicts.pop(0)['content'] + " </INST>"
chat_str = self.tokenizer.apply_chat_template(
messages_dicts, tokenize=False, add_generation_prompt=True
)
return system_str + chat_str
class ConversationalAI:
def __init__(self):
self.embed_model = LangchainEmbedding(HuggingFaceBgeEmbeddings(model_name="BAAI/bge-large-en-v1.5",cache_folder='./all_model/bge-large'))
self.llm = LangChainLLM(llm = CustomChatHuggingFace( llm =
HuggingFaceTextGenInference(inference_server_url="http://192.168.88.10:8024",
max_new_tokens=2048,
top_k=10,
top_p=0.95,
typical_p=0.95,
temperature=0.01,
repetition_penalty=1.03,
streaming=True,),
model_id ="TheBloke/Mistral-7B-Instruct-v0.2-AWQ"
))
# Initialize ServiceContext
self.service_context = ServiceContext.from_defaults(
embed_model=self.embed_model,
llm=self.llm
)
self.bge_rerank_postprocessor = SentenceTransformerRerank(
model="./all_model/rerank/bge-reranker-large",
top_n=3
)
# Initialize Memory
self.memory = ChatMemoryBuffer.from_defaults(token_limit=4000)
# Initialize vectorstore
self.index = GPTVectorStoreIndex.from_vector_store(vector_store=vector_store, service_context=self.service_context)
self.chat_prompt = PromptTemplate(MISTRAL_V2_CHAT)
self.pattern = re.compile(r"<\|im_end\|>")
def get_memory_token_count(self):
chat_history = self.memory.get_all()
msg_str = " ".join(str(m.content) for m in chat_history)
return len(self.memory.tokenizer_fn(msg_str))
def prune_memory(self, chat_limit):
chat_history = self.memory.get_all()
if len(chat_history) > chat_limit:
self.memory.chat_store.set_messages(self.memory.chat_store_key, chat_history[2:])
def _response(self, query):
chat_engine = self.index.as_chat_engine(
chat_mode="context",
memory=self.memory,
system_prompt= MISTRAL_V2_CHAT,
# context_template= self.context_prompt,
similarity_top_k=8,
node_postprocessors=[self.bge_rerank_postprocessor, MetadataReplacementPostProcessor(target_metadata_key="window")],
verbose=True)
streaming_response = chat_engine.chat(query)
for i in range(len(streaming_response.source_nodes)):
print("NODE No", i)
print("-------------------------------------------")
print("NODE :", streaming_response.source_nodes[i])
self.prune_memory(chat_limit = 4)
print("Response :", streaming_response.response)
return streaming_response.response | [
"langchain_community.llms.HuggingFaceTextGenInference",
"langchain.embeddings.huggingface.HuggingFaceBgeEmbeddings"
] | [((1058, 1076), 'huggingface_hub.commands.user.login', 'login', ([], {'token': 'token'}), '(token=token)\n', (1063, 1076), False, 'from huggingface_hub.commands.user import login\n'), ((1116, 1160), 'weaviate.Client', 'weaviate.Client', (['"""http://192.168.88.10:8080"""'], {}), "('http://192.168.88.10:8080')\n", (1131, 1160), False, 'import weaviate\n'), ((1176, 1244), 'llama_index.vector_stores.WeaviateVectorStore', 'WeaviateVectorStore', ([], {'weaviate_client': 'client', 'index_name': '"""LlamaIndex"""'}), "(weaviate_client=client, index_name='LlamaIndex')\n", (1195, 1244), False, 'from llama_index.vector_stores import WeaviateVectorStore\n'), ((2769, 2841), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'embed_model': 'self.embed_model', 'llm': 'self.llm'}), '(embed_model=self.embed_model, llm=self.llm)\n', (2797, 2841), False, 'from llama_index import ServiceContext, set_global_handler\n'), ((2918, 3003), 'llama_index.postprocessor.SentenceTransformerRerank', 'SentenceTransformerRerank', ([], {'model': '"""./all_model/rerank/bge-reranker-large"""', 'top_n': '(3)'}), "(model='./all_model/rerank/bge-reranker-large',\n top_n=3)\n", (2943, 3003), False, 'from llama_index.postprocessor import SentenceTransformerRerank\n'), ((3078, 3126), 'llama_index.memory.ChatMemoryBuffer.from_defaults', 'ChatMemoryBuffer.from_defaults', ([], {'token_limit': '(4000)'}), '(token_limit=4000)\n', (3108, 3126), False, 'from llama_index.memory import ChatMemoryBuffer\n'), ((3183, 3289), 'llama_index.GPTVectorStoreIndex.from_vector_store', 'GPTVectorStoreIndex.from_vector_store', ([], {'vector_store': 'vector_store', 'service_context': 'self.service_context'}), '(vector_store=vector_store,\n service_context=self.service_context)\n', (3220, 3289), False, 'from llama_index import GPTVectorStoreIndex, ServiceContext\n'), ((3315, 3346), 'llama_index.prompts.base.PromptTemplate', 'PromptTemplate', (['MISTRAL_V2_CHAT'], {}), '(MISTRAL_V2_CHAT)\n', (3329, 3346), False, 'from llama_index.prompts.base import PromptTemplate\n'), ((3370, 3398), 're.compile', 're.compile', (['"""<\\\\|im_end\\\\|>"""'], {}), "('<\\\\|im_end\\\\|>')\n", (3380, 3398), False, 'import re\n'), ((2126, 2230), 'langchain.embeddings.huggingface.HuggingFaceBgeEmbeddings', 'HuggingFaceBgeEmbeddings', ([], {'model_name': '"""BAAI/bge-large-en-v1.5"""', 'cache_folder': '"""./all_model/bge-large"""'}), "(model_name='BAAI/bge-large-en-v1.5', cache_folder=\n './all_model/bge-large')\n", (2150, 2230), False, 'from langchain.embeddings.huggingface import HuggingFaceBgeEmbeddings\n'), ((4389, 4451), 'llama_index.postprocessor.MetadataReplacementPostProcessor', 'MetadataReplacementPostProcessor', ([], {'target_metadata_key': '"""window"""'}), "(target_metadata_key='window')\n", (4421, 4451), False, 'from llama_index.postprocessor import MetadataReplacementPostProcessor\n'), ((2310, 2514), 'langchain_community.llms.HuggingFaceTextGenInference', 'HuggingFaceTextGenInference', ([], {'inference_server_url': '"""http://192.168.88.10:8024"""', 'max_new_tokens': '(2048)', 'top_k': '(10)', 'top_p': '(0.95)', 'typical_p': '(0.95)', 'temperature': '(0.01)', 'repetition_penalty': '(1.03)', 'streaming': '(True)'}), "(inference_server_url=\n 'http://192.168.88.10:8024', max_new_tokens=2048, top_k=10, top_p=0.95,\n typical_p=0.95, temperature=0.01, repetition_penalty=1.03, streaming=True)\n", (2337, 2514), False, 'from langchain_community.llms import HuggingFaceTextGenInference\n')] |
import os
import time
import pickle as pkl
# import re
# import yaml
import toml
import logging
from datetime import date
# import aiohttp
import pandas as pd
from pytrends.request import TrendReq
import serpapi
from serpapi import GoogleSearch
import asyncio
import streamlit as st
import streamlit.components.v1 as components
import streamlit_authenticator as stauth
import langchain
# from langchain.utilities import GoogleSerperAPIWrapper
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, Tool, AgentType
from langchain.docstore.document import Document
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.llms import OpenAI
from langchain.prompts.prompt import PromptTemplate
import openai
from dotenv import load_dotenv
load_dotenv()
########### ===== config ===== #############
config_path = '.streamlit/secrets.toml'
# print(f" os.listdir('.') -> { os.listdir('.')}")
if os.path.exists(config_path):
logging.info(f"{config_path} exists")
config = toml.load(open( config_path, 'r'))
else:
logging.info( f"secrets -> {st.secrets}" )
config = dict(st.secrets.items())
print( f"config -> {config}")
for k in ['name', 'authentication_status', 'username' ]:
st.session_state[k] = None
logging.info(f"session state -> {st.session_state}")
openai.api_key = os.environ.get("OPENAI_API_KEY") or config["settings"]["OPENAI_API_KEY"]
os.environ["OPENAI_API_KEY"] = openai.api_key
secret_key = os.environ.get('SERP_APIKEY') or config["settings"]["SERP_APIKEY"]
logging.info(f"serp api key -> {secret_key}")
# serp_client = serpapi.Client(api_key=secret_key)
pytrends = TrendReq(hl='zh-TW', tz=480, timeout=(10,25), retries=2, backoff_factor=0.1, requests_args={'verify':False})
########### ==================== #############
### ===== Creating a login widget ===== ###
authenticator = stauth.Authenticate(
config['credentials'],
config['cookie']['name'],
config['cookie']['key'],
config['cookie']['expiry_days'],
config['preauthorized']
)
name, authentication_status, username = authenticator.login('Login', 'main')
is_production = os.environ.get("PRODUCTION") or config["settings"]["PRODUCTION"]
logging.info(f"is_production -> {is_production}")
########### ==================== #############
@st.cache_data
def get_trending_searches(today) -> pd.DataFrame:
"""
Get trending searches from Google Trends
"""
results = pytrends.trending_searches(pn='taiwan')
return results
@st.cache_data
def get_search_results( secret_key, query: str, today: str) -> dict:
"""
Get search results from serpapi.com
"""
print(f"secret_key -> {secret_key[-4:]}, query -> {query}, today -> {today}")
serp_client=serpapi.Client(api_key=secret_key)
results = serp_client.search({
'engine': 'google',
'q': query,
})
return results.as_dict()
audio_input_dir = "data/audio"
audio_output_dir = "data/audio"
transcript_input_dir = "data/transcripts"
transcript_output_dir = "data/transcripts"
summary_input_dir = "data/summary"
summary_output_dir = "data/summary"
### === load model & utilities === ###
from model import get_answer, aget_answer
from postprocess import parse_url, parse_element
from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary
### ===== Authenticating users ===== ###
if authentication_status:
col1, col2, col3 , col4, col5, col6, col7 = st.columns(7)
with col4:
# st.write(f'Welcome *{name}*')
st.write(f'Welcome!')
# st.write(f'*{name}*')
# st.markdown(f"<p style='text-align: center;'> {name} </p>", unsafe_allow_html=True)
authenticator.logout('Logout', 'main')
# st.write(f'\n\n\n\n')
st.title("生產力小幫手")
# st.divider()
tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs(["疼痛小幫手", "切割錄音檔", "錄音轉文字", "文字改寫", "總結摘要", "錄音檔摘要", "火熱話題"])
with tab1:
question = st.text_input("病患描述問題", placeholder="肩膀不太舒服，前幾天有去打球，會不會是韌帶拉傷？")
if question:
if is_production:
res = get_answer(question)
else:
res = asyncio.run(aget_answer(question))
urls = res['urls']
st.write("【建議回覆】")
st.write(res["output_text"])
print( f"found urls -> {urls}" )
html = ""
if len(urls)>0:
for url in urls:
html += f"""<br><a href=\"{url}\" style="color:gray">開啟網頁：{url}</a>"""
html = f"<div>{html}</div>"
components.html( html, height=600, scrolling=True)
with tab2:
## --- upload file --- ##
with st.form("upload-audio-form", clear_on_submit=True):
uploaded_file = st.file_uploader("Upload an audio clip", key='split_audio', type=["wav", "mp3", "m4a"])
submitted = st.form_submit_button("UPLOAD")
if submitted and uploaded_file:
## -- read file -- ##
sound_bytes = uploaded_file.getvalue() # bytes
file_obj = compose_file_path( uploaded_file.name, output_prefix = None, output_dir = audio_input_dir, output_ext = None)
audio_file_path = file_obj['output_file_path']
print( f"audio_file_path: { audio_file_path}")
with open( audio_file_path, "wb") as f:
f.write(sound_bytes)
## --- split --- ##
with st.spinner(f"reading from { audio_file_path}"):
multi_file_paths = split( in_file_path = audio_file_path, length = 10)
with tab3:
## --- upload file --- ##
transcript_file_path = ""
transcripted = 0
with st.form("upload-audio-clip-form", clear_on_submit=True):
uploaded_file = st.file_uploader("Upload an audio clip", key = 'transcribe_audio', type=["wav", "mp3", "m4a"])
submitted = st.form_submit_button("UPLOAD")
if submitted and uploaded_file:
## -- read file -- ##
sound_bytes = uploaded_file.getvalue() # bytes
file_obj = compose_file_path( input_file_path=uploaded_file.name, output_prefix = None, output_dir = audio_input_dir, output_ext = None)
audio_file_path = file_obj['output_file_path']
print( f"audio_file_path: { audio_file_path}")
with open( audio_file_path, "wb") as f:
f.write(sound_bytes)
## --- transcribe --- ##
start_time = time.time()
st.divider()
file_obj = compose_file_path( audio_file_path, output_prefix = None, output_dir = transcript_input_dir, output_ext = "txt")
transcript_file_path = file_obj['output_file_path']
if os.path.exists(transcript_file_path):
print(f"{transcript_file_path} already exists. will skip this file.")
with st.spinner(f"written transcript to { transcript_file_path}"):
transcript = sound2txt( audio_file_path, transcript_file_path)
st.write(transcript['text'])
print( f"Elapsed time: {time.time() - start_time} seconds")
transcripted = 1
if transcripted and os.path.exists(transcript_file_path):
with open(transcript_file_path) as f:
st.download_button('下載逐字稿', f, file_name = os.path.basename(transcript_file_path), ) # Defaults to 'text/plain'
with tab4:
rewrite_chain = get_rewrite_chain()
rewrite_file_path = ""
rewritten = 0
question = st.text_input(
"你希望整理會議逐字稿的方式（用簡短的英文描述）",
"correct typos, remove redundant sentences/words and add punctuations",
placeholder="correct typos, remove redundant sentences/words and add punctuations",
# disabled=not uploaded_file,
)
with st.form("upload-transcript-clip-form", clear_on_submit=True):
rewrite_uploaded_file = st.file_uploader("Upload a transcript or a document (txt file)", type="txt")
submitted = st.form_submit_button("UPLOAD")
if submitted and rewrite_uploaded_file and question and not openai.api_key:
st.info("Please add your OPENAI API KEY to environment to continue.")
if submitted and rewrite_uploaded_file and question and openai.api_key:
## -- read file -- ##
article = rewrite_uploaded_file.read().decode()
file_obj = compose_file_path(
input_file_path = rewrite_uploaded_file.name, output_prefix = "rewrite", output_dir = transcript_output_dir, output_ext = "txt"
)
rewrite_file_path = file_obj['output_file_path']
# assert not os.path.exists( transcript_file_path), f"File { transcript_file_path} already exists."
## -- split into chunks -- ##
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1024,
chunk_overlap=20,
)
paragraphs = text_splitter.split_text(article)
## --- anthropic --- ##
# prompt = f"""
# {anthropic.HUMAN_PROMPT} Here's an article:\n\n<article>
# {article}\n\n</article>\n\n{question}{anthropic.AI_PROMPT}
# """
# client = anthropic.Client(anthropic_api_key)
# #client = anthropic.Client(st.secrets.anthropic_api_key)
# response = client.completion(
# prompt=prompt,
# stop_sequences=[anthropic.HUMAN_PROMPT],
# model="claude-v1",
# max_tokens_to_sample=100,
# )
# st.write("### Answer")
# st.write(response["completion"])
## --- openai --- ##
st.write("### Rewritten transcript")
with st.spinner(f"written to { rewrite_file_path}"):
for paragraph in paragraphs:
try:
res = rewrite_chain({"functions": question, "paragraph": paragraph}, return_only_outputs = True)
except Exception as e:
print(e)
continue
st.write(res["text"])
st.write("---")
with open( rewrite_file_path, "a") as f:
f.write(res["text"])
# rewrite_file_paths.append( rewrite_file_path)
rewritten = 1
if rewritten and os.path.exists(rewrite_file_path):
with open(rewrite_file_path) as f:
st.download_button('下載加入標點符號後的逐字稿', f, file_name = os.path.basename(rewrite_file_path), key = f"download-button-{rewrite_file_path}") # Defaults to 'text/plain'
with tab5:
instruction = st.text_input(
"你希望總結會議逐字稿的方式（用簡短的英文描述）",
"give helpful and concise summary with action items in traditional chinese.",
placeholder="give helpful and concise summary with action items in traditional chinese.",
# disabled=not summary_uploaded_file,
)
summarized = 0
summary_file_path = ""
with st.form("upload-summarize-clip-form", clear_on_submit=True):
summary_uploaded_file = st.file_uploader("Upload a transcript or a document (txt file)", type="txt")
summarize_submitted = st.form_submit_button("UPLOAD")
if summarize_submitted and summary_uploaded_file and instruction and not openai.api_key:
st.info("Please add your OPENAI API KEY to environment to continue.")
if summarize_submitted and summary_uploaded_file and instruction and openai.api_key:
## -- read file -- ##
article = summary_uploaded_file.read().decode()
file_obj = compose_file_path(
input_file_path = summary_uploaded_file.name, output_prefix = "summary", output_dir = summary_output_dir, output_ext = "txt"
)
summary_file_path = file_obj['output_file_path']
## -- split into chunks -- ##
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1024,
chunk_overlap=100,
)
paragraphs = text_splitter.split_text(article)
## -- summarize -- ##
st.write("### Summarize transcript")
with st.spinner(f"written to { summary_file_path}"):
summarize_chain = get_summarize_chain()
with open( summary_file_path, "w") as f:
for paragraph in paragraphs:
try:
res = summarize_chain( {"input_documents": [ Document( page_content=paragraph) ], "functions": instruction} )
summary = res['output_text']
except Exception as e:
print(e)
continue
st.write(summary)
st.write("---")
f.write(summary)
summarized = 1
if summarized and os.path.exists(summary_file_path):
with open(summary_file_path) as f:
st.download_button('下載摘要', f, file_name = os.path.basename(summary_file_path), key = f"download-button-{summary_file_path}") # Defaults to 'text/plain'
with tab6:
# summarize_chain = load_summarize_chain()
# data/audio/GMT20230613-051643_Recording.m4a_0.m4a
# with open("data/transcripts/GMT20230613-051643_Recording.m4a_0.txt") as f:
# transcript = f.read()
# st.markdown( f'<p style="background-color: rgba(100,100,200,.2);">{transcript}</p>', unsafe_allow_html=True)
## --- upload file --- ##
with st.form("end-to-end-upload-audio-form", clear_on_submit=True):
uploaded_file = st.file_uploader("Upload an audio clip", key='end_to_end', type=["wav", "mp3", "m4a"])
submitted = st.form_submit_button("UPLOAD")
if submitted and uploaded_file:
## -- read file -- ##
with st.spinner(f"uploaded { uploaded_file.name}"):
sound_bytes = uploaded_file.getvalue() # bytes
audio_file_path = compose_file_path( input_file_path = uploaded_file.name, output_prefix = None, output_dir = audio_input_dir, output_ext = None)['output_file_path']
print( f"audio_file_path: {audio_file_path}")
with open( audio_file_path, "wb") as f:
f.write(sound_bytes)
## --- split --- ##
audio_file_paths = split( in_file_path = audio_file_path, length = 10)
## --- transcribe --- ##
st.write("### Transcribing audio")
with st.spinner(f"transcribe { ', '.join(audio_file_paths) }"):
transcripts = []
transcript_file_paths = []
for i, audio_file_path in enumerate(audio_file_paths):
start_time = time.time()
transcript_file_path = compose_file_path( input_file_path = audio_file_path, output_prefix = None, output_dir = transcript_input_dir, output_ext = "txt")['output_file_path']
transcript_file_paths.append(transcript_file_path)
st.write(f"Trascribing {i}-th clip out of total {len(audio_file_paths)} clips.")
transcript = sound2txt( audio_file_path, transcript_file_path)
st.write(transcript['text'][:50])
st.divider()
transcripts.append( transcript['text'])
print( f"[transcription] Elapsed time: {time.time() - start_time} seconds")
# print( f"Transcript: {transcript}")
## --- Rewrite --- ##
st.write("### Rewritten transcript")
with st.spinner(f"rewritten { ','.join(transcript_file_paths)}"):
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1024,
chunk_overlap=20,
)
rewrite_instruction = "correct typos, remove redundant sentences/words and add punctuations"
rewrite_file_paths = []
rewrites = []
for i, blob in enumerate(zip(transcript_file_paths, transcripts)):
transcript_file_path, transcript = blob
paragraphs = text_splitter.split_text( "\n".join(transcript) )
rewrite_file_path = compose_file_path( input_file_path = transcript_file_path, output_prefix = "rewrite", output_dir = transcript_output_dir, output_ext = "txt")['output_file_path']
rewrite_file_paths.append(rewrite_file_path)
st.write(f"Rewriting {i}-th transcript out of total {len(transcript_file_paths)} transcripts.")
for paragraph in paragraphs:
try:
res = rewrite_chain({"functions": rewrite_instruction, "paragraph": paragraph}, return_only_outputs = True)
except Exception as e:
print(e)
continue
with open( rewrite_file_path, "a") as f:
f.write(res["text"])
st.write(res["text"][:50])
st.divider()
## --- summarize --- ##
with st.spinner(f"summarize { ', '.join(rewrite_file_paths) }"):
summary_text = ""
for rewrite, rewrite_file_path in zip( rewrites, rewrite_file_paths):
start_time = time.time()
summary_file_path = compose_file_path( input_file_path = rewrite_file_path, output_prefix = "summary", output_dir = summary_output_dir, output_ext = "txt")['output_file_path']
summary = text2summary( rewrite, summary_file_path, instruction = "give helpful and concise summary with action items in traditional chinese.")
st.write(summary)
st.divider()
summary_text += f"{summary}\n"
print( f"[summary] Elapsed time: {time.time() - start_time} seconds")
with tab7:
if False:
# today = date.today()
# topn_results = 3
# topn_articles = 1
# trend_results = get_trending_searches(today)
# highlights = []
# for query in trend_results[0].values[:topn_results]:
# search_results = get_search_results( secret_key, query, str(today) )
# highlights += search_results['organic_results'][:topn_articles]
# highlights = pd.DataFrame(highlights)
params = {
"api_key": secret_key,
"engine": "google_trends_trending_now",
"frequency": "daily",
"geo": "TW",
"hl": "zh-tw"
}
search = GoogleSearch(params)
results = search.get_dict()
content = []
for ds in results['daily_searches']:
for s in ds['searches']:
q = s['query']
if 'articles' in s and len(s['articles'])>0:
link = s['articles'][0]['link']
title = s['articles'][0]['title']
snippet = s['articles'][0]['snippet']
else:
continue
content.append({'query': q, 'title': title, 'snippet': snippet, 'link': link})
st.dataframe(pd.DataFrame(content))
else:
st.write("Coming soon...")
elif authentication_status == False:
st.error('Username/password is incorrect')
elif authentication_status == None:
st.warning('Please enter your username and password')
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.docstore.document.Document"
] | [((872, 885), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (883, 885), False, 'from dotenv import load_dotenv\n'), ((1028, 1055), 'os.path.exists', 'os.path.exists', (['config_path'], {}), '(config_path)\n', (1042, 1055), False, 'import os\n'), ((1341, 1393), 'logging.info', 'logging.info', (['f"""session state -> {st.session_state}"""'], {}), "(f'session state -> {st.session_state}')\n", (1353, 1393), False, 'import logging\n'), ((1611, 1656), 'logging.info', 'logging.info', (['f"""serp api key -> {secret_key}"""'], {}), "(f'serp api key -> {secret_key}')\n", (1623, 1656), False, 'import logging\n'), ((1719, 1834), 'pytrends.request.TrendReq', 'TrendReq', ([], {'hl': '"""zh-TW"""', 'tz': '(480)', 'timeout': '(10, 25)', 'retries': '(2)', 'backoff_factor': '(0.1)', 'requests_args': "{'verify': False}"}), "(hl='zh-TW', tz=480, timeout=(10, 25), retries=2, backoff_factor=\n 0.1, requests_args={'verify': False})\n", (1727, 1834), False, 'from pytrends.request import TrendReq\n'), ((1938, 2099), 'streamlit_authenticator.Authenticate', 'stauth.Authenticate', (["config['credentials']", "config['cookie']['name']", "config['cookie']['key']", "config['cookie']['expiry_days']", "config['preauthorized']"], {}), "(config['credentials'], config['cookie']['name'], config\n ['cookie']['key'], config['cookie']['expiry_days'], config['preauthorized']\n )\n", (1957, 2099), True, 'import streamlit_authenticator as stauth\n'), ((2260, 2309), 'logging.info', 'logging.info', (['f"""is_production -> {is_production}"""'], {}), "(f'is_production -> {is_production}')\n", (2272, 2309), False, 'import logging\n'), ((1058, 1095), 'logging.info', 'logging.info', (['f"""{config_path} exists"""'], {}), "(f'{config_path} exists')\n", (1070, 1095), False, 'import logging\n'), ((1148, 1188), 'logging.info', 'logging.info', (['f"""secrets -> {st.secrets}"""'], {}), "(f'secrets -> {st.secrets}')\n", (1160, 1188), False, 'import logging\n'), ((1411, 1443), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (1425, 1443), False, 'import os\n'), ((1544, 1573), 'os.environ.get', 'os.environ.get', (['"""SERP_APIKEY"""'], {}), "('SERP_APIKEY')\n", (1558, 1573), False, 'import os\n'), ((2195, 2223), 'os.environ.get', 'os.environ.get', (['"""PRODUCTION"""'], {}), "('PRODUCTION')\n", (2209, 2223), False, 'import os\n'), ((2797, 2831), 'serpapi.Client', 'serpapi.Client', ([], {'api_key': 'secret_key'}), '(api_key=secret_key)\n', (2811, 2831), False, 'import serpapi\n'), ((3525, 3538), 'streamlit.columns', 'st.columns', (['(7)'], {}), '(7)\n', (3535, 3538), True, 'import streamlit as st\n'), ((3791, 3809), 'streamlit.title', 'st.title', (['"""生產力小幫手"""'], {}), "('生產力小幫手')\n", (3799, 3809), True, 'import streamlit as st\n'), ((3873, 3942), 'streamlit.tabs', 'st.tabs', (["['疼痛小幫手', '切割錄音檔', '錄音轉文字', '文字改寫', '總結摘要', '錄音檔摘要', '火熱話題']"], {}), "(['疼痛小幫手', '切割錄音檔', '錄音轉文字', '文字改寫', '總結摘要', '錄音檔摘要', '火熱話題'])\n", (3880, 3942), True, 'import streamlit as st\n'), ((1206, 1224), 'streamlit.secrets.items', 'st.secrets.items', ([], {}), '()\n', (1222, 1224), True, 'import streamlit as st\n'), ((3587, 3608), 'streamlit.write', 'st.write', (['f"""Welcome!"""'], {}), "(f'Welcome!')\n", (3595, 3608), True, 'import streamlit as st\n'), ((3969, 4032), 'streamlit.text_input', 'st.text_input', (['"""病患描述問題"""'], {'placeholder': '"""肩膀不太舒服，前幾天有去打球，會不會是韌帶拉傷？"""'}), "('病患描述問題', placeholder='肩膀不太舒服，前幾天有去打球，會不會是韌帶拉傷？')\n", (3982, 4032), True, 'import streamlit as st\n'), ((6949, 6968), 'utils.get_rewrite_chain', 'get_rewrite_chain', ([], {}), '()\n', (6966, 6968), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((7023, 7232), 'streamlit.text_input', 'st.text_input', (['"""你希望整理會議逐字稿的方式（用簡短的英文描述）"""', '"""correct typos, remove redundant sentences/words and add punctuations"""'], {'placeholder': '"""correct typos, remove redundant sentences/words and add punctuations"""'}), "('你希望整理會議逐字稿的方式（用簡短的英文描述）',\n 'correct typos, remove redundant sentences/words and add punctuations',\n placeholder=\n 'correct typos, remove redundant sentences/words and add punctuations')\n", (7036, 7232), True, 'import streamlit as st\n'), ((9715, 9942), 'streamlit.text_input', 'st.text_input', (['"""你希望總結會議逐字稿的方式（用簡短的英文描述）"""', '"""give helpful and concise summary with action items in traditional chinese."""'], {'placeholder': '"""give helpful and concise summary with action items in traditional chinese."""'}), "('你希望總結會議逐字稿的方式（用簡短的英文描述）',\n 'give helpful and concise summary with action items in traditional chinese.'\n , placeholder=\n 'give helpful and concise summary with action items in traditional chinese.'\n )\n", (9728, 9942), True, 'import streamlit as st\n'), ((17034, 17076), 'streamlit.error', 'st.error', (['"""Username/password is incorrect"""'], {}), "('Username/password is incorrect')\n", (17042, 17076), True, 'import streamlit as st\n'), ((4182, 4200), 'streamlit.write', 'st.write', (['"""【建議回覆】"""'], {}), "('【建議回覆】')\n", (4190, 4200), True, 'import streamlit as st\n'), ((4204, 4232), 'streamlit.write', 'st.write', (["res['output_text']"], {}), "(res['output_text'])\n", (4212, 4232), True, 'import streamlit as st\n'), ((4437, 4486), 'streamlit.components.v1.html', 'components.html', (['html'], {'height': '(600)', 'scrolling': '(True)'}), '(html, height=600, scrolling=True)\n', (4452, 4486), True, 'import streamlit.components.v1 as components\n'), ((4537, 4587), 'streamlit.form', 'st.form', (['"""upload-audio-form"""'], {'clear_on_submit': '(True)'}), "('upload-audio-form', clear_on_submit=True)\n", (4544, 4587), True, 'import streamlit as st\n'), ((4608, 4699), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload an audio clip"""'], {'key': '"""split_audio"""', 'type': "['wav', 'mp3', 'm4a']"}), "('Upload an audio clip', key='split_audio', type=['wav',\n 'mp3', 'm4a'])\n", (4624, 4699), True, 'import streamlit as st\n'), ((4711, 4742), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""UPLOAD"""'], {}), "('UPLOAD')\n", (4732, 4742), True, 'import streamlit as st\n'), ((5411, 5466), 'streamlit.form', 'st.form', (['"""upload-audio-clip-form"""'], {'clear_on_submit': '(True)'}), "('upload-audio-clip-form', clear_on_submit=True)\n", (5418, 5466), True, 'import streamlit as st\n'), ((5487, 5584), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload an audio clip"""'], {'key': '"""transcribe_audio"""', 'type': "['wav', 'mp3', 'm4a']"}), "('Upload an audio clip', key='transcribe_audio', type=[\n 'wav', 'mp3', 'm4a'])\n", (5503, 5584), True, 'import streamlit as st\n'), ((5597, 5628), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""UPLOAD"""'], {}), "('UPLOAD')\n", (5618, 5628), True, 'import streamlit as st\n'), ((6719, 6755), 'os.path.exists', 'os.path.exists', (['transcript_file_path'], {}), '(transcript_file_path)\n', (6733, 6755), False, 'import os\n'), ((7282, 7342), 'streamlit.form', 'st.form', (['"""upload-transcript-clip-form"""'], {'clear_on_submit': '(True)'}), "('upload-transcript-clip-form', clear_on_submit=True)\n", (7289, 7342), True, 'import streamlit as st\n'), ((7371, 7447), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload a transcript or a document (txt file)"""'], {'type': '"""txt"""'}), "('Upload a transcript or a document (txt file)', type='txt')\n", (7387, 7447), True, 'import streamlit as st\n'), ((7463, 7494), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""UPLOAD"""'], {}), "('UPLOAD')\n", (7484, 7494), True, 'import streamlit as st\n'), ((9445, 9478), 'os.path.exists', 'os.path.exists', (['rewrite_file_path'], {}), '(rewrite_file_path)\n', (9459, 9478), False, 'import os\n'), ((10034, 10093), 'streamlit.form', 'st.form', (['"""upload-summarize-clip-form"""'], {'clear_on_submit': '(True)'}), "('upload-summarize-clip-form', clear_on_submit=True)\n", (10041, 10093), True, 'import streamlit as st\n'), ((10122, 10198), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload a transcript or a document (txt file)"""'], {'type': '"""txt"""'}), "('Upload a transcript or a document (txt file)', type='txt')\n", (10138, 10198), True, 'import streamlit as st\n'), ((10224, 10255), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""UPLOAD"""'], {}), "('UPLOAD')\n", (10245, 10255), True, 'import streamlit as st\n'), ((11610, 11643), 'os.path.exists', 'os.path.exists', (['summary_file_path'], {}), '(summary_file_path)\n', (11624, 11643), False, 'import os\n'), ((12208, 12269), 'streamlit.form', 'st.form', (['"""end-to-end-upload-audio-form"""'], {'clear_on_submit': '(True)'}), "('end-to-end-upload-audio-form', clear_on_submit=True)\n", (12215, 12269), True, 'import streamlit as st\n'), ((12290, 12380), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload an audio clip"""'], {'key': '"""end_to_end"""', 'type': "['wav', 'mp3', 'm4a']"}), "('Upload an audio clip', key='end_to_end', type=['wav',\n 'mp3', 'm4a'])\n", (12306, 12380), True, 'import streamlit as st\n'), ((12392, 12423), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""UPLOAD"""'], {}), "('UPLOAD')\n", (12413, 12423), True, 'import streamlit as st\n'), ((16478, 16498), 'serpapi.GoogleSearch', 'GoogleSearch', (['params'], {}), '(params)\n', (16490, 16498), False, 'from serpapi import GoogleSearch\n'), ((16967, 16993), 'streamlit.write', 'st.write', (['"""Coming soon..."""'], {}), "('Coming soon...')\n", (16975, 16993), True, 'import streamlit as st\n'), ((17116, 17169), 'streamlit.warning', 'st.warning', (['"""Please enter your username and password"""'], {}), "('Please enter your username and password')\n", (17126, 17169), True, 'import streamlit as st\n'), ((4080, 4100), 'model.get_answer', 'get_answer', (['question'], {}), '(question)\n', (4090, 4100), False, 'from model import get_answer, aget_answer\n'), ((4875, 4982), 'utils.compose_file_path', 'compose_file_path', (['uploaded_file.name'], {'output_prefix': 'None', 'output_dir': 'audio_input_dir', 'output_ext': 'None'}), '(uploaded_file.name, output_prefix=None, output_dir=\n audio_input_dir, output_ext=None)\n', (4892, 4982), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((5756, 5878), 'utils.compose_file_path', 'compose_file_path', ([], {'input_file_path': 'uploaded_file.name', 'output_prefix': 'None', 'output_dir': 'audio_input_dir', 'output_ext': 'None'}), '(input_file_path=uploaded_file.name, output_prefix=None,\n output_dir=audio_input_dir, output_ext=None)\n', (5773, 5878), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((6103, 6114), 'time.time', 'time.time', ([], {}), '()\n', (6112, 6114), False, 'import time\n'), ((6119, 6131), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (6129, 6131), True, 'import streamlit as st\n'), ((6148, 6258), 'utils.compose_file_path', 'compose_file_path', (['audio_file_path'], {'output_prefix': 'None', 'output_dir': 'transcript_input_dir', 'output_ext': '"""txt"""'}), "(audio_file_path, output_prefix=None, output_dir=\n transcript_input_dir, output_ext='txt')\n", (6165, 6258), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((6324, 6360), 'os.path.exists', 'os.path.exists', (['transcript_file_path'], {}), '(transcript_file_path)\n', (6338, 6360), False, 'import os\n'), ((7582, 7651), 'streamlit.info', 'st.info', (['"""Please add your OPENAI API KEY to environment to continue."""'], {}), "('Please add your OPENAI API KEY to environment to continue.')\n", (7589, 7651), True, 'import streamlit as st\n'), ((7830, 7973), 'utils.compose_file_path', 'compose_file_path', ([], {'input_file_path': 'rewrite_uploaded_file.name', 'output_prefix': '"""rewrite"""', 'output_dir': 'transcript_output_dir', 'output_ext': '"""txt"""'}), "(input_file_path=rewrite_uploaded_file.name, output_prefix\n ='rewrite', output_dir=transcript_output_dir, output_ext='txt')\n", (7847, 7973), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((8201, 8266), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1024)', 'chunk_overlap': '(20)'}), '(chunk_size=1024, chunk_overlap=20)\n', (8231, 8266), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((8924, 8960), 'streamlit.write', 'st.write', (['"""### Rewritten transcript"""'], {}), "('### Rewritten transcript')\n", (8932, 8960), True, 'import streamlit as st\n'), ((10356, 10425), 'streamlit.info', 'st.info', (['"""Please add your OPENAI API KEY to environment to continue."""'], {}), "('Please add your OPENAI API KEY to environment to continue.')\n", (10363, 10425), True, 'import streamlit as st\n'), ((10617, 10757), 'utils.compose_file_path', 'compose_file_path', ([], {'input_file_path': 'summary_uploaded_file.name', 'output_prefix': '"""summary"""', 'output_dir': 'summary_output_dir', 'output_ext': '"""txt"""'}), "(input_file_path=summary_uploaded_file.name, output_prefix\n ='summary', output_dir=summary_output_dir, output_ext='txt')\n", (10634, 10757), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((10881, 10947), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1024)', 'chunk_overlap': '(100)'}), '(chunk_size=1024, chunk_overlap=100)\n', (10911, 10947), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((11047, 11083), 'streamlit.write', 'st.write', (['"""### Summarize transcript"""'], {}), "('### Summarize transcript')\n", (11055, 11083), True, 'import streamlit as st\n'), ((13026, 13060), 'streamlit.write', 'st.write', (['"""### Transcribing audio"""'], {}), "('### Transcribing audio')\n", (13034, 13060), True, 'import streamlit as st\n'), ((13941, 13977), 'streamlit.write', 'st.write', (['"""### Rewritten transcript"""'], {}), "('### Rewritten transcript')\n", (13949, 13977), True, 'import streamlit as st\n'), ((16933, 16954), 'pandas.DataFrame', 'pd.DataFrame', (['content'], {}), '(content)\n', (16945, 16954), True, 'import pandas as pd\n'), ((4132, 4153), 'model.aget_answer', 'aget_answer', (['question'], {}), '(question)\n', (4143, 4153), False, 'from model import get_answer, aget_answer\n'), ((5191, 5236), 'streamlit.spinner', 'st.spinner', (['f"""reading from {audio_file_path}"""'], {}), "(f'reading from {audio_file_path}')\n", (5201, 5236), True, 'import streamlit as st\n'), ((5263, 5309), 'utils.split', 'split', ([], {'in_file_path': 'audio_file_path', 'length': '(10)'}), '(in_file_path=audio_file_path, length=10)\n', (5268, 5309), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((6449, 6508), 'streamlit.spinner', 'st.spinner', (['f"""written transcript to {transcript_file_path}"""'], {}), "(f'written transcript to {transcript_file_path}')\n", (6459, 6508), True, 'import streamlit as st\n'), ((6529, 6577), 'utils.sound2txt', 'sound2txt', (['audio_file_path', 'transcript_file_path'], {}), '(audio_file_path, transcript_file_path)\n', (6538, 6577), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((6584, 6612), 'streamlit.write', 'st.write', (["transcript['text']"], {}), "(transcript['text'])\n", (6592, 6612), True, 'import streamlit as st\n'), ((8970, 9015), 'streamlit.spinner', 'st.spinner', (['f"""written to {rewrite_file_path}"""'], {}), "(f'written to {rewrite_file_path}')\n", (8980, 9015), True, 'import streamlit as st\n'), ((11093, 11138), 'streamlit.spinner', 'st.spinner', (['f"""written to {summary_file_path}"""'], {}), "(f'written to {summary_file_path}')\n", (11103, 11138), True, 'import streamlit as st\n'), ((11164, 11185), 'utils.get_summarize_chain', 'get_summarize_chain', ([], {}), '()\n', (11183, 11185), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((12494, 12538), 'streamlit.spinner', 'st.spinner', (['f"""uploaded {uploaded_file.name}"""'], {}), "(f'uploaded {uploaded_file.name}')\n", (12504, 12538), True, 'import streamlit as st\n'), ((12938, 12984), 'utils.split', 'split', ([], {'in_file_path': 'audio_file_path', 'length': '(10)'}), '(in_file_path=audio_file_path, length=10)\n', (12943, 12984), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((14069, 14134), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1024)', 'chunk_overlap': '(20)'}), '(chunk_size=1024, chunk_overlap=20)\n', (14099, 14134), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((6855, 6893), 'os.path.basename', 'os.path.basename', (['transcript_file_path'], {}), '(transcript_file_path)\n', (6871, 6893), False, 'import os\n'), ((9235, 9256), 'streamlit.write', 'st.write', (["res['text']"], {}), "(res['text'])\n", (9243, 9256), True, 'import streamlit as st\n'), ((9263, 9278), 'streamlit.write', 'st.write', (['"""---"""'], {}), "('---')\n", (9271, 9278), True, 'import streamlit as st\n'), ((9599, 9634), 'os.path.basename', 'os.path.basename', (['rewrite_file_path'], {}), '(rewrite_file_path)\n', (9615, 9634), False, 'import os\n'), ((11737, 11772), 'os.path.basename', 'os.path.basename', (['summary_file_path'], {}), '(summary_file_path)\n', (11753, 11772), False, 'import os\n'), ((12616, 12738), 'utils.compose_file_path', 'compose_file_path', ([], {'input_file_path': 'uploaded_file.name', 'output_prefix': 'None', 'output_dir': 'audio_input_dir', 'output_ext': 'None'}), '(input_file_path=uploaded_file.name, output_prefix=None,\n output_dir=audio_input_dir, output_ext=None)\n', (12633, 12738), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((13262, 13273), 'time.time', 'time.time', ([], {}), '()\n', (13271, 13273), False, 'import time\n'), ((13625, 13673), 'utils.sound2txt', 'sound2txt', (['audio_file_path', 'transcript_file_path'], {}), '(audio_file_path, transcript_file_path)\n', (13634, 13673), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((13682, 13715), 'streamlit.write', 'st.write', (["transcript['text'][:50]"], {}), "(transcript['text'][:50])\n", (13690, 13715), True, 'import streamlit as st\n'), ((13722, 13734), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (13732, 13734), True, 'import streamlit as st\n'), ((15403, 15414), 'time.time', 'time.time', ([], {}), '()\n', (15412, 15414), False, 'import time\n'), ((15613, 15753), 'utils.text2summary', 'text2summary', (['rewrite', 'summary_file_path'], {'instruction': '"""give helpful and concise summary with action items in traditional chinese."""'}), "(rewrite, summary_file_path, instruction=\n 'give helpful and concise summary with action items in traditional chinese.'\n )\n", (15625, 15753), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((15753, 15770), 'streamlit.write', 'st.write', (['summary'], {}), '(summary)\n', (15761, 15770), True, 'import streamlit as st\n'), ((15777, 15789), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (15787, 15789), True, 'import streamlit as st\n'), ((11506, 11523), 'streamlit.write', 'st.write', (['summary'], {}), '(summary)\n', (11514, 11523), True, 'import streamlit as st\n'), ((11531, 11546), 'streamlit.write', 'st.write', (['"""---"""'], {}), "('---')\n", (11539, 11546), True, 'import streamlit as st\n'), ((13310, 13435), 'utils.compose_file_path', 'compose_file_path', ([], {'input_file_path': 'audio_file_path', 'output_prefix': 'None', 'output_dir': 'transcript_input_dir', 'output_ext': '"""txt"""'}), "(input_file_path=audio_file_path, output_prefix=None,\n output_dir=transcript_input_dir, output_ext='txt')\n", (13327, 13435), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((14514, 14651), 'utils.compose_file_path', 'compose_file_path', ([], {'input_file_path': 'transcript_file_path', 'output_prefix': '"""rewrite"""', 'output_dir': 'transcript_output_dir', 'output_ext': '"""txt"""'}), "(input_file_path=transcript_file_path, output_prefix=\n 'rewrite', output_dir=transcript_output_dir, output_ext='txt')\n", (14531, 14651), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((15141, 15167), 'streamlit.write', 'st.write', (["res['text'][:50]"], {}), "(res['text'][:50])\n", (15149, 15167), True, 'import streamlit as st\n'), ((15175, 15187), 'streamlit.divider', 'st.divider', ([], {}), '()\n', (15185, 15187), True, 'import streamlit as st\n'), ((15441, 15572), 'utils.compose_file_path', 'compose_file_path', ([], {'input_file_path': 'rewrite_file_path', 'output_prefix': '"""summary"""', 'output_dir': 'summary_output_dir', 'output_ext': '"""txt"""'}), "(input_file_path=rewrite_file_path, output_prefix=\n 'summary', output_dir=summary_output_dir, output_ext='txt')\n", (15458, 15572), False, 'from utils import split, compose_file_path, get_rewrite_chain, get_summarize_chain, sound2txt, text2summary\n'), ((6641, 6652), 'time.time', 'time.time', ([], {}), '()\n', (6650, 6652), False, 'import time\n'), ((13827, 13838), 'time.time', 'time.time', ([], {}), '()\n', (13836, 13838), False, 'import time\n'), ((15867, 15878), 'time.time', 'time.time', ([], {}), '()\n', (15876, 15878), False, 'import time\n'), ((11333, 11365), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'paragraph'}), '(page_content=paragraph)\n', (11341, 11365), False, 'from langchain.docstore.document import Document\n')] |
from langchain import OpenAI, SQLDatabase
from langchain_experimental.sql import SQLDatabaseChain
from langchain.memory import ConversationBufferMemory
from langchain.agents import (AgentType,
AgentExecutor,
create_react_agent,
create_openai_functions_agent,
create_sql_agent)
from langchain.agents.initialize import initialize_agent
from langchain.tools import Tool
from langchain.prompts import PromptTemplate
# from langchain.retrievers import RetrievalModel
from langchain.indexes.vectorstore import VectorstoreIndexCreator
from langchain_community.document_loaders.text import TextLoader
from langchain_community.agent_toolkits import SQLDatabaseToolkit
# Document Loaders for PDFs and Docx
from langchain.document_loaders.pdf import PyPDFLoader
from langchain.document_loaders.word_document import Docx2txtLoader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.chroma import Chroma
from langchain.chat_models.openai import ChatOpenAI
from langchain.chains import ConversationalRetrievalChain
from langchain.text_splitter import CharacterTextSplitter
import langchain
import psycopg2
import os
import constants
import constants_allen
os.environ["OPENAI_API_KEY"] = constants.OPENAI_API_KEY
import warnings
warnings.filterwarnings('ignore')
# Setup database connection
# Setup database
db = SQLDatabase.from_uri(
f"postgresql+psycopg2://postgres:{constants.DBPASS}@localhost:5433/{constants.DB}",
)
# Setup conversation memory
memory = ConversationBufferMemory(memory_key="chat_history")
# Setup llm
llm = OpenAI(temperature=0, model_name="gpt-3.5-turbo")
# Create a list of documents from all our files in the ./data/docs folder
documents = []
for file in os.listdir("./data/docs"):
if file.endswith(".pdf"):
pdf_path = "./data/docs/" + file
loader = PyPDFLoader(pdf_path)
documents.extend(loader.load())
elif file.endswith("./docx") or file.endswith(".doc"):
doc_path = "./data/docs/" + file
loader = Docx2txtLoader(doc_path)
documents.extend(loader.load())
elif file.endswith(".txt"):
text_path = "./data/docs/" + file
loader = TextLoader(text_path)
documents.extend(loader.load())
# Split the documents into smaller chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=10)
documents = text_splitter.split_documents(documents)
# Convert the document chunks to embedding and save them to the vector store
vectordb = Chroma.from_documents(documents, embedding=OpenAIEmbeddings(), persist_directory="./data/docs")
vectordb.persist()
# Setup prompt template
_DEFAULT_TEMPLATE = """Given an input question, first create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer. Unless the user specifies in his question a specific number of examples he wishes to obtain, always limit your query to at most {top_k} results. You can order the results by a relevant column to return the most interesting examples in the database.
Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
Pay attention to use only the column names that you can see in the schema description. Be careful to not query for columns that do not exist. Also, pay attention to which column is in which table.
Use the following format:
Question: Question here
SQLQuery: SQL Query to run
SQLResult: Result of the SQLQuery
Answer: Final answer here
Only use the following tables:
{table_info}
Question: {input}
"""
# TEMPLATE = '''"Given your input question, provide the answer from the most relevant source. You can choose between two sources:
# 1. Text File Source: This source contains Q&A data on data structures and algorithms.
# 2. Database Source: This source includes information from three tables:
# - 'developers' table: Contains details about developers, such as full_name, email, phone, position, and department.
# - 'tasks' table: Holds information about developers' tasks, including the task, completion status, due date, completion date, and priority.
# - 'insurance_data' table: Contains information about PRU Life Insurance and USA Insurance, including questions and answers.
# Only query the content of the sources, not the metadata.
# You have access to the following tools:
# {tools}
# Use the following format:
# Question: the input question you must answer
# Thought: you should always think about what to do
# Action: the action to take, should be one of [{tool_names}]
# Action Input: the input to the action
# Observation: the result of the action
# ... (this Thought/Action/Action Input/Observation can repeat N times)
# Thought: I now know the final answer
# Final Answer: the final answer to the original input question
# Begin!
# Question: {input}
# Thought:{agent_scratchpad}'''
PROMPT = PromptTemplate.from_template(_DEFAULT_TEMPLATE)
# Setup db chain
db_chain = SQLDatabaseChain(llm=llm, database=db, verbose=True)
toolkit = SQLDatabaseToolkit(db=db, llm=OpenAI(temperature=0, verbose=True, model_name="gpt-3.5-turbo"))
# Create Document Q&A chain
pdf_qa = ConversationalRetrievalChain.from_llm(
OpenAI(temperate=0.7, model_name="gpt-3.5-turbo"),
retriever=vectordb.as_retriever(search_kwargs={'k': 6}),
return_source_documents=True,
verbose=False
)
# Setup text data source
directory = "./data/text/final1.txt"
loader = TextLoader(directory)
index_creator = VectorstoreIndexCreator()
index = index_creator.from_loaders([loader])
retriever_text = index.vectorstore.as_retriever()
# Define the tools needed
tools = [
Tool(name="MyDocs", func=pdf_qa, description="Retrieve information from documents."),
Tool(name="MyDB", func=db_chain.run, description="Query the PostgreSQL database",),
Tool(name="MyRetriever", func=retriever_text.get_relevant_documents, description="Retrieve documents from text file"),
]
agent = initialize_agent(
tools, llm, memory=memory,
agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
verbose=True,
handle_parsing_errors=True,
output_key="result",
early_stopping_method="generate",
max_iterations=3,
)
# agent = create_sql_agent(
# llm=OpenAI(temperature=0),
# toolkit=toolkit,
# verbose=True,
# agent_type=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
# )
# agent = create_react_agent(
# llm=llm,
# tools=tools,
# prompt=PROMPT
# )
# agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory,
# verbose=True, handle_parsing_errors=True)
yellow = "\033[0;33m"
green = "\033[0;32m"
white = "\033[0;39m"
def chat():
while True:
user_input = input("You: ") # Get user input
# Use the agent to generate a response
try:
bot_response = agent.run(user_input)
# bot_response = agent_executor.invoke({"input": user_input})
except ValueError as e:
bot_response = str(e)
if not bot_response.startswith("Could not parse LLM output: `"):
raise e
bot_response = bot_response.removeprefix("Could not parse LLM output: `").removesuffix("`")
print("Chatbot: " + bot_response)
if user_input.lower() == 'exit':
break
if __name__ == "__main__":
chat() | [
"langchain.agents.initialize.initialize_agent",
"langchain.text_splitter.CharacterTextSplitter",
"langchain.prompts.PromptTemplate.from_template",
"langchain_experimental.sql.SQLDatabaseChain",
"langchain.document_loaders.pdf.PyPDFLoader",
"langchain_community.document_loaders.text.TextLoader",
"langchain.document_loaders.word_document.Docx2txtLoader",
"langchain.indexes.vectorstore.VectorstoreIndexCreator",
"langchain.embeddings.openai.OpenAIEmbeddings",
"langchain.SQLDatabase.from_uri",
"langchain.tools.Tool",
"langchain.memory.ConversationBufferMemory",
"langchain.OpenAI"
] | [((1372, 1405), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (1395, 1405), False, 'import warnings\n'), ((1458, 1572), 'langchain.SQLDatabase.from_uri', 'SQLDatabase.from_uri', (['f"""postgresql+psycopg2://postgres:{constants.DBPASS}@localhost:5433/{constants.DB}"""'], {}), "(\n f'postgresql+psycopg2://postgres:{constants.DBPASS}@localhost:5433/{constants.DB}'\n )\n", (1478, 1572), False, 'from langchain import OpenAI, SQLDatabase\n'), ((1608, 1659), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""'}), "(memory_key='chat_history')\n", (1632, 1659), False, 'from langchain.memory import ConversationBufferMemory\n'), ((1679, 1728), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo"""'}), "(temperature=0, model_name='gpt-3.5-turbo')\n", (1685, 1728), False, 'from langchain import OpenAI, SQLDatabase\n'), ((1831, 1856), 'os.listdir', 'os.listdir', (['"""./data/docs"""'], {}), "('./data/docs')\n", (1841, 1856), False, 'import os\n'), ((2402, 2458), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(10)'}), '(chunk_size=1000, chunk_overlap=10)\n', (2423, 2458), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((5005, 5052), 'langchain.prompts.PromptTemplate.from_template', 'PromptTemplate.from_template', (['_DEFAULT_TEMPLATE'], {}), '(_DEFAULT_TEMPLATE)\n', (5033, 5052), False, 'from langchain.prompts import PromptTemplate\n'), ((5082, 5134), 'langchain_experimental.sql.SQLDatabaseChain', 'SQLDatabaseChain', ([], {'llm': 'llm', 'database': 'db', 'verbose': '(True)'}), '(llm=llm, database=db, verbose=True)\n', (5098, 5134), False, 'from langchain_experimental.sql import SQLDatabaseChain\n'), ((5559, 5580), 'langchain_community.document_loaders.text.TextLoader', 'TextLoader', (['directory'], {}), '(directory)\n', (5569, 5580), False, 'from langchain_community.document_loaders.text import TextLoader\n'), ((5597, 5622), 'langchain.indexes.vectorstore.VectorstoreIndexCreator', 'VectorstoreIndexCreator', ([], {}), '()\n', (5620, 5622), False, 'from langchain.indexes.vectorstore import VectorstoreIndexCreator\n'), ((6067, 6289), 'langchain.agents.initialize.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'memory': 'memory', 'agent': 'AgentType.CONVERSATIONAL_REACT_DESCRIPTION', 'verbose': '(True)', 'handle_parsing_errors': '(True)', 'output_key': '"""result"""', 'early_stopping_method': '"""generate"""', 'max_iterations': '(3)'}), "(tools, llm, memory=memory, agent=AgentType.\n CONVERSATIONAL_REACT_DESCRIPTION, verbose=True, handle_parsing_errors=\n True, output_key='result', early_stopping_method='generate',\n max_iterations=3)\n", (6083, 6289), False, 'from langchain.agents.initialize import initialize_agent\n'), ((5321, 5370), 'langchain.OpenAI', 'OpenAI', ([], {'temperate': '(0.7)', 'model_name': '"""gpt-3.5-turbo"""'}), "(temperate=0.7, model_name='gpt-3.5-turbo')\n", (5327, 5370), False, 'from langchain import OpenAI, SQLDatabase\n'), ((5759, 5848), 'langchain.tools.Tool', 'Tool', ([], {'name': '"""MyDocs"""', 'func': 'pdf_qa', 'description': '"""Retrieve information from documents."""'}), "(name='MyDocs', func=pdf_qa, description=\n 'Retrieve information from documents.')\n", (5763, 5848), False, 'from langchain.tools import Tool\n'), ((5849, 5935), 'langchain.tools.Tool', 'Tool', ([], {'name': '"""MyDB"""', 'func': 'db_chain.run', 'description': '"""Query the PostgreSQL database"""'}), "(name='MyDB', func=db_chain.run, description=\n 'Query the PostgreSQL database')\n", (5853, 5935), False, 'from langchain.tools import Tool\n'), ((5937, 6058), 'langchain.tools.Tool', 'Tool', ([], {'name': '"""MyRetriever"""', 'func': 'retriever_text.get_relevant_documents', 'description': '"""Retrieve documents from text file"""'}), "(name='MyRetriever', func=retriever_text.get_relevant_documents,\n description='Retrieve documents from text file')\n", (5941, 6058), False, 'from langchain.tools import Tool\n'), ((1946, 1967), 'langchain.document_loaders.pdf.PyPDFLoader', 'PyPDFLoader', (['pdf_path'], {}), '(pdf_path)\n', (1957, 1967), False, 'from langchain.document_loaders.pdf import PyPDFLoader\n'), ((2644, 2662), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (2660, 2662), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((5175, 5238), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'verbose': '(True)', 'model_name': '"""gpt-3.5-turbo"""'}), "(temperature=0, verbose=True, model_name='gpt-3.5-turbo')\n", (5181, 5238), False, 'from langchain import OpenAI, SQLDatabase\n'), ((2125, 2149), 'langchain.document_loaders.word_document.Docx2txtLoader', 'Docx2txtLoader', (['doc_path'], {}), '(doc_path)\n', (2139, 2149), False, 'from langchain.document_loaders.word_document import Docx2txtLoader\n'), ((2281, 2302), 'langchain_community.document_loaders.text.TextLoader', 'TextLoader', (['text_path'], {}), '(text_path)\n', (2291, 2302), False, 'from langchain_community.document_loaders.text import TextLoader\n')] |
"""Base interface that all chains should implement."""
import json
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import BaseModel, Field, validator
import langchain
from langchain.callbacks import get_callback_manager
from langchain.callbacks.base import BaseCallbackManager
from langchain.schema import BaseMemory
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(BaseModel, ABC):
"""Base interface that all chains should implement."""
memory: Optional[BaseMemory] = None
callback_manager: BaseCallbackManager = Field(
default_factory=get_callback_manager, exclude=True
)
verbose: bool = Field(
default_factory=_get_verbosity
) # Whether to print the response text
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@validator("callback_manager", pre=True, always=True)
def set_callback_manager(
cls, callback_manager: Optional[BaseCallbackManager]
) -> BaseCallbackManager:
"""If callback manager is None, set it.
This allows users to pass in None as callback manager, which is a nice UX.
"""
return callback_manager or get_callback_manager()
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Input keys this chain expects."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Output keys this chain expects."""
def _validate_inputs(self, inputs: Dict[str, str]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, str]) -> None:
if set(outputs) != set(self.output_keys):
raise ValueError(
f"Did not get output keys that were expected. "
f"Got: {set(outputs)}. Expected: {set(self.output_keys)}."
)
@abstractmethod
def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
async def _acall(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = self._call(inputs)
except (KeyboardInterrupt, Exception) as e:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
async def acall(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
if self.callback_manager.is_async:
await self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
else:
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = await self._acall(inputs)
except (KeyboardInterrupt, Exception) as e:
if self.callback_manager.is_async:
await self.callback_manager.on_chain_error(e, verbose=self.verbose)
else:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
if self.callback_manager.is_async:
await self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
else:
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prep outputs."""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prep inputs."""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
def apply(self, input_list: List[Dict[str, Any]]) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs) for inputs in input_list]
def run(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0])[self.output_keys[0]]
if kwargs and not args:
return self(kwargs)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (await self.acall(args[0]))[self.output_keys[0]]
if kwargs and not args:
return (await self.acall(kwargs))[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain."""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict()
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
| [
"langchain.callbacks.get_callback_manager"
] | [((646, 703), 'pydantic.Field', 'Field', ([], {'default_factory': 'get_callback_manager', 'exclude': '(True)'}), '(default_factory=get_callback_manager, exclude=True)\n', (651, 703), False, 'from pydantic import BaseModel, Field, validator\n'), ((738, 775), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (743, 775), False, 'from pydantic import BaseModel, Field, validator\n'), ((1075, 1127), 'pydantic.validator', 'validator', (['"""callback_manager"""'], {'pre': '(True)', 'always': '(True)'}), "('callback_manager', pre=True, always=True)\n", (1084, 1127), False, 'from pydantic import BaseModel, Field, validator\n'), ((1457, 1500), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (1466, 1500), False, 'from pydantic import BaseModel, Field, validator\n'), ((1428, 1450), 'langchain.callbacks.get_callback_manager', 'get_callback_manager', ([], {}), '()\n', (1448, 1450), False, 'from langchain.callbacks import get_callback_manager\n'), ((10078, 10093), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (10082, 10093), False, 'from pathlib import Path\n'), ((10413, 10447), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (10422, 10447), False, 'import json\n'), ((10550, 10600), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (10559, 10600), False, 'import yaml\n')] |
from typing import Dict, List, Optional
from langchain.agents.load_tools import (
_EXTRA_LLM_TOOLS,
_EXTRA_OPTIONAL_TOOLS,
_LLM_TOOLS,
)
from langflow.custom import customs
from langflow.interface.base import LangChainTypeCreator
from langflow.interface.tools.constants import (
ALL_TOOLS_NAMES,
CUSTOM_TOOLS,
FILE_TOOLS,
OTHER_TOOLS,
)
from langflow.interface.tools.util import get_tool_params
from langflow.services.utils import get_settings_manager
from langflow.template.field.base import TemplateField
from langflow.template.template.base import Template
from langflow.utils import util
from langflow.utils.util import build_template_from_class
TOOL_INPUTS = {
"str": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
placeholder="",
value="",
),
"llm": TemplateField(
field_type="BaseLanguageModel", required=True, is_list=False, show=True
),
"func": TemplateField(
field_type="function",
required=True,
is_list=False,
show=True,
multiline=True,
),
"code": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
value="",
multiline=True,
),
"path": TemplateField(
field_type="file",
required=True,
is_list=False,
show=True,
value="",
suffixes=[".json", ".yaml", ".yml"],
file_types=["json", "yaml", "yml"],
),
}
class ToolCreator(LangChainTypeCreator):
type_name: str = "tools"
tools_dict: Optional[Dict] = None
@property
def type_to_loader_dict(self) -> Dict:
settings_manager = get_settings_manager()
if self.tools_dict is None:
all_tools = {}
for tool, tool_fcn in ALL_TOOLS_NAMES.items():
tool_params = get_tool_params(tool_fcn)
tool_name = tool_params.get("name") or tool
if (
tool_name in settings_manager.settings.TOOLS
or settings_manager.settings.DEV
):
if tool_name == "JsonSpec":
tool_params["path"] = tool_params.pop("dict_") # type: ignore
all_tools[tool_name] = {
"type": tool,
"params": tool_params,
"fcn": tool_fcn,
}
self.tools_dict = all_tools
return self.tools_dict
def get_signature(self, name: str) -> Optional[Dict]:
"""Get the signature of a tool."""
base_classes = ["Tool", "BaseTool"]
fields = []
params = []
tool_params = {}
# Raise error if name is not in tools
if name not in self.type_to_loader_dict.keys():
raise ValueError("Tool not found")
tool_type: str = self.type_to_loader_dict[name]["type"] # type: ignore
# if tool_type in _BASE_TOOLS.keys():
# params = []
if tool_type in _LLM_TOOLS.keys():
params = ["llm"]
elif tool_type in _EXTRA_LLM_TOOLS.keys():
extra_keys = _EXTRA_LLM_TOOLS[tool_type][1]
params = ["llm"] + extra_keys
elif tool_type in _EXTRA_OPTIONAL_TOOLS.keys():
extra_keys = _EXTRA_OPTIONAL_TOOLS[tool_type][1]
params = extra_keys
# elif tool_type == "Tool":
# params = ["name", "description", "func"]
elif tool_type in CUSTOM_TOOLS:
# Get custom tool params
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes = ["function"]
if node := customs.get_custom_nodes("tools").get(tool_type):
return node
elif tool_type in FILE_TOOLS:
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes += [name]
elif tool_type in OTHER_TOOLS:
tool_dict = build_template_from_class(tool_type, OTHER_TOOLS)
fields = tool_dict["template"]
# Pop unnecessary fields and add name
fields.pop("_type") # type: ignore
fields.pop("return_direct") # type: ignore
fields.pop("verbose") # type: ignore
tool_params = {
"name": fields.pop("name")["value"], # type: ignore
"description": fields.pop("description")["value"], # type: ignore
}
fields = [
TemplateField(name=name, field_type=field["type"], **field)
for name, field in fields.items() # type: ignore
]
base_classes += tool_dict["base_classes"]
# Copy the field and add the name
for param in params:
field = TOOL_INPUTS.get(param, TOOL_INPUTS["str"]).copy()
field.name = param
field.advanced = False
if param == "aiosession":
field.show = False
field.required = False
fields.append(field)
template = Template(fields=fields, type_name=tool_type)
tool_params = {**tool_params, **self.type_to_loader_dict[name]["params"]}
return {
"template": util.format_dict(template.to_dict()),
**tool_params,
"base_classes": base_classes,
}
def to_list(self) -> List[str]:
"""List all load tools"""
return list(self.type_to_loader_dict.keys())
tool_creator = ToolCreator()
| [
"langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys",
"langchain.agents.load_tools._LLM_TOOLS.keys",
"langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys"
] | [((709, 811), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'placeholder': '""""""', 'value': '""""""'}), "(field_type='str', required=True, is_list=False, show=True,\n placeholder='', value='')\n", (722, 811), False, 'from langflow.template.field.base import TemplateField\n'), ((875, 965), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""BaseLanguageModel"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)'}), "(field_type='BaseLanguageModel', required=True, is_list=False,\n show=True)\n", (888, 965), False, 'from langflow.template.field.base import TemplateField\n'), ((989, 1087), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""function"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'multiline': '(True)'}), "(field_type='function', required=True, is_list=False, show=\n True, multiline=True)\n", (1002, 1087), False, 'from langflow.template.field.base import TemplateField\n'), ((1143, 1245), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'multiline': '(True)'}), "(field_type='str', required=True, is_list=False, show=True,\n value='', multiline=True)\n", (1156, 1245), False, 'from langflow.template.field.base import TemplateField\n'), ((1310, 1474), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""file"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'suffixes': "['.json', '.yaml', '.yml']", 'file_types': "['json', 'yaml', 'yml']"}), "(field_type='file', required=True, is_list=False, show=True,\n value='', suffixes=['.json', '.yaml', '.yml'], file_types=['json',\n 'yaml', 'yml'])\n", (1323, 1474), False, 'from langflow.template.field.base import TemplateField\n'), ((1728, 1750), 'langflow.services.utils.get_settings_manager', 'get_settings_manager', ([], {}), '()\n', (1748, 1750), False, 'from langflow.services.utils import get_settings_manager\n'), ((5139, 5183), 'langflow.template.template.base.Template', 'Template', ([], {'fields': 'fields', 'type_name': 'tool_type'}), '(fields=fields, type_name=tool_type)\n', (5147, 5183), False, 'from langflow.template.template.base import Template\n'), ((1849, 1872), 'langflow.interface.tools.constants.ALL_TOOLS_NAMES.items', 'ALL_TOOLS_NAMES.items', ([], {}), '()\n', (1870, 1872), False, 'from langflow.interface.tools.constants import ALL_TOOLS_NAMES, CUSTOM_TOOLS, FILE_TOOLS, OTHER_TOOLS\n'), ((3091, 3108), 'langchain.agents.load_tools._LLM_TOOLS.keys', '_LLM_TOOLS.keys', ([], {}), '()\n', (3106, 3108), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((1904, 1929), 'langflow.interface.tools.util.get_tool_params', 'get_tool_params', (['tool_fcn'], {}), '(tool_fcn)\n', (1919, 1929), False, 'from langflow.interface.tools.util import get_tool_params\n'), ((3165, 3188), 'langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys', '_EXTRA_LLM_TOOLS.keys', ([], {}), '()\n', (3186, 3188), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((3314, 3342), 'langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys', '_EXTRA_OPTIONAL_TOOLS.keys', ([], {}), '()\n', (3340, 3342), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((4038, 4087), 'langflow.utils.util.build_template_from_class', 'build_template_from_class', (['tool_type', 'OTHER_TOOLS'], {}), '(tool_type, OTHER_TOOLS)\n', (4063, 4087), False, 'from langflow.utils.util import build_template_from_class\n'), ((3746, 3779), 'langflow.custom.customs.get_custom_nodes', 'customs.get_custom_nodes', (['"""tools"""'], {}), "('tools')\n", (3770, 3779), False, 'from langflow.custom import customs\n'), ((4571, 4630), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'name': 'name', 'field_type': "field['type']"}), "(name=name, field_type=field['type'], **field)\n", (4584, 4630), False, 'from langflow.template.field.base import TemplateField\n')] |
#!/usr/bin/env python3
from restapi_helper import LangChainHelper
from langchain.schema import HumanMessage
print('==Simple message predict==')
with LangChainHelper() as lch:
text = 'Hey there!'
messages = [HumanMessage(content=text)]
print(lch.predict_messages(messages))
print('==As English teacher - know the answer==')
with LangChainHelper() as lch:
role = 'English teacher'
text = 'What is a plural form of child?'
print(lch.get_answer_as_role(role, text))
print('==As English teacher - does not know the answer==')
with LangChainHelper() as lch:
role = 'English teacher'
text = 'How old am I?'
print(lch.get_answer_as_role(role, text))
| [
"langchain.schema.HumanMessage"
] | [((157, 174), 'restapi_helper.LangChainHelper', 'LangChainHelper', ([], {}), '()\n', (172, 174), False, 'from restapi_helper import LangChainHelper\n'), ((355, 372), 'restapi_helper.LangChainHelper', 'LangChainHelper', ([], {}), '()\n', (370, 372), False, 'from restapi_helper import LangChainHelper\n'), ((572, 589), 'restapi_helper.LangChainHelper', 'LangChainHelper', ([], {}), '()\n', (587, 589), False, 'from restapi_helper import LangChainHelper\n'), ((225, 251), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'text'}), '(content=text)\n', (237, 251), False, 'from langchain.schema import HumanMessage\n')] |
import streamlit as st
# Import transformer classes for generaiton
from transformers import AutoTokenizer, AutoModelForCausalLM, TextStreamer, GPT2Tokenizer, GPT2LMHeadModel, GPT2Model
# Import torch for datatype attributes
import torch
# Import the prompt wrapper...but for llama index
from llama_index.prompts.prompts import SimpleInputPrompt
# Import the llama index HF Wrapper
from llama_index.llms import HuggingFaceLLM
# Bring in embeddings wrapper
from llama_index.embeddings import LangchainEmbedding
# Bring in HF embeddings - need these to represent document chunks
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
# Bring in stuff to change service context
from llama_index import set_global_service_context
from llama_index import ServiceContext
# Import deps to load documents
from llama_index import VectorStoreIndex, SimpleDirectoryReader
from pathlib import Path
import pypdf
import time
import os
import tempfile
# Define variable to hold llama2 weights namingfiner
name = "gpt2"
# Set auth token variable from hugging face
auth_token = "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"
@st.cache_resource
def get_tokenizer_model():
# Create tokenizer
tokenizer = GPT2Tokenizer.from_pretrained(name, use_auth_token=auth_token)
# Create model
model = GPT2LMHeadModel.from_pretrained(name)
return model, tokenizer
model, tokenizer = get_tokenizer_model()
# disclaimer
st.title('LLM Deployment Prototype for Production')
st.caption("Special thanks to my mentor, Medkham Chanthavong, for all the support in making this project a reality. Connect with Medkham on LinkedIn: [Medkham Chanthavong](https://www.linkedin.com/in/medkham-chanthavong-4524b0125/).")
st.subheader('Disclaimer')
st.write("Due to Streamlit's lack of cloud-GPU support and limited memory, we're using GPT-2 instead of Llama 2 7B. GPT-2, \
being smaller, is less capable of accurately retrieving information from external data. This site is a prototype for LLM deployment \
and may not retrieve precise data from external sources. Additionally, the site might experience crashes due to memory constraints.\
In case of a crash, please feel free shoot me a message at my [LinkedIn profile](https://www.linkedin.com/in/duwe-ng/) so I can reboot the site. \
For a more advanced model demonstration using Llama 2 7B, check out our Colab notebook: \
[LLM Deployment Prototype](https://colab.research.google.com/drive/1bGf9rKntMjH4KtpKs9ryucj1nbiKs_zk?usp=sharing).")
# # Initialize the SimpleInputPrompt with an empty template
# query_wrapper_prompt = SimpleInputPrompt("{query_str}")
# # Streamlit UI to let the user update the system prompt
# # Start with an empty string or a default prompt
# default_prompt = ""
# user_system_prompt = st.text_area("How can I best assist you?", value="", height=100)
# update_button = st.button('Request')
# Import the prompt wrapper for llama index
# Create a system prompt
system_prompt = """
Hey there! 👋 You are here to help you out in the best way you can. Think of yourself as your friendly and trustworthy assistant. Your top priority is to be super helpful and safe in your responses. \
Here's a quick heads up about what you can expect from me: \
1. Positive Vibes Only: I steer clear of anything harmful, unethical, or offensive. No racism, sexism, or toxic stuff here. I'm all about being respectful and keeping things on the up-and-up. \
2. Making Sense Matters: If the user question seems a bit confusing or doesn't quite add up, You will let you know and try to clarify things instead of giving the user a misleading answer. \
3. Honesty is Key: Not sure about something? You won't make stuff up. If you don't have the answer, you will be upfront about it. \
4. All About Your PDFs: The user documents are your focus. Got a question about the content in your PDFs? That's exactly what you are here for. Let's dive into those documents and find the answers the user need! \
So, how can you assist the user today with their PDFs?
"""
# Throw together the query wrapper
query_wrapper_prompt = SimpleInputPrompt("{query_str}")
# Initialize the llm object with a placeholder or default system prompt
llm = HuggingFaceLLM(
context_window=1024,
max_new_tokens=128,
system_prompt="",
query_wrapper_prompt=query_wrapper_prompt,
model=model,
tokenizer=tokenizer
)
# # Function to update the system prompt and reinitialize the LLM with the new prompt
# def update_system_prompt(new_prompt):
# global llm
# llm.system_prompt = new_prompt
# if update_button:
# # Update the system prompt and reinitialize the LLM
# update_system_prompt(user_system_prompt)
# st.success('Requested')
# check if user request save to the memory
# st.write(llm.system_prompt)
# Create and dl embeddings instance
embeddings=LangchainEmbedding(
HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
)
# Create new service context instance
service_context = ServiceContext.from_defaults(
chunk_size=256,
llm=llm,
embed_model=embeddings
)
# And set the service context
set_global_service_context(service_context)
# Upload PDF and process it
st.subheader("Please upload your data to enable the retrieval system; otherwise, it will not respond.")
documents = []
uploaded_file = st.file_uploader("Upload PDF", type="pdf")
if uploaded_file is not None:
# Create a temporary directory
with tempfile.TemporaryDirectory() as temp_dir:
# Write the uploaded file to a file in the temporary directory
temp_file_path = os.path.join(temp_dir, uploaded_file.name)
with open(temp_file_path, "wb") as f:
f.write(uploaded_file.getbuffer())
# Now you can use SimpleDirectoryReader on the temp_dir
documents = SimpleDirectoryReader(temp_dir).load_data()
st.success(f"File {uploaded_file.name} uploaded successfully.")
index = VectorStoreIndex.from_documents(documents)
# Setup index query engine using LLM
query_engine = index.as_query_engine(streaming=True, similarity_top_k=1)
# Create centered main title
st.title('👔 HireMind 🧩')
# setup a session to hold all the old prompt
if 'messages' not in st.session_state:
st.session_state.messages = []
# print out the history message
for message in st.session_state.messages:
st.chat_message(message['role']).markdown(message['content'])
# Create a text input box for the user
# If the user hits enter
prompt = st.chat_input('Input your prompt here')
if prompt:
st.chat_message('user').markdown(prompt)
st.session_state.messages.append({'role': 'user', 'content': prompt})
response = query_engine.query(prompt)
st.chat_message('assistant').markdown(response)
st.session_state.messages.append(
{'role': 'assistant', 'content': response}
)
| [
"langchain.embeddings.huggingface.HuggingFaceEmbeddings"
] | [((1422, 1473), 'streamlit.title', 'st.title', (['"""LLM Deployment Prototype for Production"""'], {}), "('LLM Deployment Prototype for Production')\n", (1430, 1473), True, 'import streamlit as st\n'), ((1474, 1718), 'streamlit.caption', 'st.caption', (['"""Special thanks to my mentor, Medkham Chanthavong, for all the support in making this project a reality. Connect with Medkham on LinkedIn: [Medkham Chanthavong](https://www.linkedin.com/in/medkham-chanthavong-4524b0125/)."""'], {}), "(\n 'Special thanks to my mentor, Medkham Chanthavong, for all the support in making this project a reality. Connect with Medkham on LinkedIn: [Medkham Chanthavong](https://www.linkedin.com/in/medkham-chanthavong-4524b0125/).'\n )\n", (1484, 1718), True, 'import streamlit as st\n'), ((1710, 1736), 'streamlit.subheader', 'st.subheader', (['"""Disclaimer"""'], {}), "('Disclaimer')\n", (1722, 1736), True, 'import streamlit as st\n'), ((1737, 2482), 'streamlit.write', 'st.write', (['"""Due to Streamlit\'s lack of cloud-GPU support and limited memory, we\'re using GPT-2 instead of Llama 2 7B. GPT-2, being smaller, is less capable of accurately retrieving information from external data. This site is a prototype for LLM deployment and may not retrieve precise data from external sources. Additionally, the site might experience crashes due to memory constraints.In case of a crash, please feel free shoot me a message at my [LinkedIn profile](https://www.linkedin.com/in/duwe-ng/) so I can reboot the site. For a more advanced model demonstration using Llama 2 7B, check out our Colab notebook: [LLM Deployment Prototype](https://colab.research.google.com/drive/1bGf9rKntMjH4KtpKs9ryucj1nbiKs_zk?usp=sharing)."""'], {}), '(\n "Due to Streamlit\'s lack of cloud-GPU support and limited memory, we\'re using GPT-2 instead of Llama 2 7B. GPT-2, being smaller, is less capable of accurately retrieving information from external data. This site is a prototype for LLM deployment and may not retrieve precise data from external sources. Additionally, the site might experience crashes due to memory constraints.In case of a crash, please feel free shoot me a message at my [LinkedIn profile](https://www.linkedin.com/in/duwe-ng/) so I can reboot the site. For a more advanced model demonstration using Llama 2 7B, check out our Colab notebook: [LLM Deployment Prototype](https://colab.research.google.com/drive/1bGf9rKntMjH4KtpKs9ryucj1nbiKs_zk?usp=sharing)."\n )\n', (1745, 2482), True, 'import streamlit as st\n'), ((4064, 4096), 'llama_index.prompts.prompts.SimpleInputPrompt', 'SimpleInputPrompt', (['"""{query_str}"""'], {}), "('{query_str}')\n", (4081, 4096), False, 'from llama_index.prompts.prompts import SimpleInputPrompt\n'), ((4176, 4335), 'llama_index.llms.HuggingFaceLLM', 'HuggingFaceLLM', ([], {'context_window': '(1024)', 'max_new_tokens': '(128)', 'system_prompt': '""""""', 'query_wrapper_prompt': 'query_wrapper_prompt', 'model': 'model', 'tokenizer': 'tokenizer'}), "(context_window=1024, max_new_tokens=128, system_prompt='',\n query_wrapper_prompt=query_wrapper_prompt, model=model, tokenizer=tokenizer\n )\n", (4190, 4335), False, 'from llama_index.llms import HuggingFaceLLM\n'), ((4953, 5030), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'chunk_size': '(256)', 'llm': 'llm', 'embed_model': 'embeddings'}), '(chunk_size=256, llm=llm, embed_model=embeddings)\n', (4981, 5030), False, 'from llama_index import ServiceContext\n'), ((5076, 5119), 'llama_index.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (5102, 5119), False, 'from llama_index import set_global_service_context\n'), ((5150, 5263), 'streamlit.subheader', 'st.subheader', (['"""Please upload your data to enable the retrieval system; otherwise, it will not respond."""'], {}), "(\n 'Please upload your data to enable the retrieval system; otherwise, it will not respond.'\n )\n", (5162, 5263), True, 'import streamlit as st\n'), ((5286, 5328), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload PDF"""'], {'type': '"""pdf"""'}), "('Upload PDF', type='pdf')\n", (5302, 5328), True, 'import streamlit as st\n'), ((5897, 5939), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (5928, 5939), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((6089, 6113), 'streamlit.title', 'st.title', (['"""👔 HireMind 🧩"""'], {}), "('👔 HireMind 🧩')\n", (6097, 6113), True, 'import streamlit as st\n'), ((6482, 6521), 'streamlit.chat_input', 'st.chat_input', (['"""Input your prompt here"""'], {}), "('Input your prompt here')\n", (6495, 6521), True, 'import streamlit as st\n'), ((1200, 1262), 'transformers.GPT2Tokenizer.from_pretrained', 'GPT2Tokenizer.from_pretrained', (['name'], {'use_auth_token': 'auth_token'}), '(name, use_auth_token=auth_token)\n', (1229, 1262), False, 'from transformers import AutoTokenizer, AutoModelForCausalLM, TextStreamer, GPT2Tokenizer, GPT2LMHeadModel, GPT2Model\n'), ((1295, 1332), 'transformers.GPT2LMHeadModel.from_pretrained', 'GPT2LMHeadModel.from_pretrained', (['name'], {}), '(name)\n', (1326, 1332), False, 'from transformers import AutoTokenizer, AutoModelForCausalLM, TextStreamer, GPT2Tokenizer, GPT2LMHeadModel, GPT2Model\n'), ((4841, 4893), 'langchain.embeddings.huggingface.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""all-MiniLM-L6-v2"""'}), "(model_name='all-MiniLM-L6-v2')\n", (4862, 4893), False, 'from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n'), ((6583, 6652), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (6615, 6652), True, 'import streamlit as st\n'), ((6761, 6837), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'assistant', 'content': response}"], {}), "({'role': 'assistant', 'content': response})\n", (6793, 6837), True, 'import streamlit as st\n'), ((5404, 5433), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (5431, 5433), False, 'import tempfile\n'), ((5543, 5585), 'os.path.join', 'os.path.join', (['temp_dir', 'uploaded_file.name'], {}), '(temp_dir, uploaded_file.name)\n', (5555, 5585), False, 'import os\n'), ((5816, 5879), 'streamlit.success', 'st.success', (['f"""File {uploaded_file.name} uploaded successfully."""'], {}), "(f'File {uploaded_file.name} uploaded successfully.')\n", (5826, 5879), True, 'import streamlit as st\n'), ((6329, 6361), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (6344, 6361), True, 'import streamlit as st\n'), ((6538, 6561), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (6553, 6561), True, 'import streamlit as st\n'), ((6709, 6737), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (6724, 6737), True, 'import streamlit as st\n'), ((5764, 5795), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['temp_dir'], {}), '(temp_dir)\n', (5785, 5795), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n')] |
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import MessagesPlaceholder, HumanMessagePromptTemplate, ChatPromptTemplate
from langchain.memory import ConversationBufferMemory, FileChatMessageHistory
from dotenv import load_dotenv
import sqlite3
import sqlparse
import json
import warnings
from langchain_core._api.deprecation import LangChainDeprecationWarning
# Ignore specific deprecation warnings from langchain_core
warnings.filterwarnings("ignore", category=LangChainDeprecationWarning)
load_dotenv()
# Create and initialize the OpenAI client
def create_openai_client():
return ChatOpenAI(model_name="gpt-3.5-turbo")
# Retrieve the database schema from an SQLite database
def get_database_schema(db_path):
try:
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
tables = cursor.fetchall()
schema_info = []
for table in tables:
table_name = table[0]
cursor.execute(f"PRAGMA table_info({table_name});")
columns = cursor.fetchall()
primary_keys = [col[1] for col in columns if col[5] == 1]
schema_info.append(f"{table_name} (Primary Key: {', '.join(primary_keys)})")
conn.close()
return "filename: chinook.db, "+', '.join(schema_info)
except Exception as e:
return f"Error reading database schema: {e}"
# Format the raw SQL query for better readability using sqlparse
def format_sql_query(raw_sql):
if raw_sql.startswith("```sql"):
raw_sql = raw_sql[6:]
if raw_sql.endswith("```"):
raw_sql = raw_sql[:-3]
raw_sql = raw_sql.strip()
formatted_sql = sqlparse.format(raw_sql, reindent=True, keyword_case='upper')
return formatted_sql
# Function to execute a SQL query and return results
def execute_sql_query(db_path, sql_query):
try:
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
cursor.execute(sql_query)
results = cursor.fetchall()
conn.close()
return results
except sqlite3.Error as e:
return f"SQL Error: {e}"
# Main execution
if __name__ == "__main__":
client = create_openai_client()
db_path = "chinook.db"
database_schema = get_database_schema(db_path)
memory = ConversationBufferMemory(
chat_memory=FileChatMessageHistory("chat_history.json"),
memory_key="messages",
return_messages=True,
)
prompt = ChatPromptTemplate(
input_variables=["content", "messages"],
messages=[
MessagesPlaceholder(variable_name="messages"),
HumanMessagePromptTemplate.from_template(
"You are a data analyst. Generate SQL queries from natural language descriptions. Provide only the SQL query in response, without explanations or additional text"
"Question: {{question}} Database Schema: {{database_schema}} Response: {content}"
),
],
)
chain = LLMChain(
llm=client,
prompt=prompt,
memory=memory,
)
while True:
content = input("Usage: type 'quit' to exit chat\n>> ")
if content == "quit":
break
result = chain({"content": content})
# Format the SQL query
formatted_query = format_sql_query(result['text'])
print("\nGenerated SQL Query:\n", formatted_query)
# Execute the SQL query and print results
query_results = execute_sql_query(db_path, formatted_query)
print("\nQuery Results:\n", query_results) | [
"langchain.memory.FileChatMessageHistory",
"langchain.chains.LLMChain",
"langchain_openai.ChatOpenAI",
"langchain.prompts.MessagesPlaceholder",
"langchain.prompts.HumanMessagePromptTemplate.from_template"
] | [((476, 547), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {'category': 'LangChainDeprecationWarning'}), "('ignore', category=LangChainDeprecationWarning)\n", (499, 547), False, 'import warnings\n'), ((550, 563), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (561, 563), False, 'from dotenv import load_dotenv\n'), ((646, 684), 'langchain_openai.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""'}), "(model_name='gpt-3.5-turbo')\n", (656, 684), False, 'from langchain_openai import ChatOpenAI\n'), ((1761, 1822), 'sqlparse.format', 'sqlparse.format', (['raw_sql'], {'reindent': '(True)', 'keyword_case': '"""upper"""'}), "(raw_sql, reindent=True, keyword_case='upper')\n", (1776, 1822), False, 'import sqlparse\n'), ((3072, 3122), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'client', 'prompt': 'prompt', 'memory': 'memory'}), '(llm=client, prompt=prompt, memory=memory)\n', (3080, 3122), False, 'from langchain.chains import LLMChain\n'), ((799, 823), 'sqlite3.connect', 'sqlite3.connect', (['db_path'], {}), '(db_path)\n', (814, 823), False, 'import sqlite3\n'), ((1969, 1993), 'sqlite3.connect', 'sqlite3.connect', (['db_path'], {}), '(db_path)\n', (1984, 1993), False, 'import sqlite3\n'), ((2423, 2466), 'langchain.memory.FileChatMessageHistory', 'FileChatMessageHistory', (['"""chat_history.json"""'], {}), "('chat_history.json')\n", (2445, 2466), False, 'from langchain.memory import ConversationBufferMemory, FileChatMessageHistory\n'), ((2649, 2694), 'langchain.prompts.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': '"""messages"""'}), "(variable_name='messages')\n", (2668, 2694), False, 'from langchain.prompts import MessagesPlaceholder, HumanMessagePromptTemplate, ChatPromptTemplate\n'), ((2708, 3001), 'langchain.prompts.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['"""You are a data analyst. Generate SQL queries from natural language descriptions. Provide only the SQL query in response, without explanations or additional textQuestion: {{question}} Database Schema: {{database_schema}} Response: {content}"""'], {}), "(\n 'You are a data analyst. Generate SQL queries from natural language descriptions. Provide only the SQL query in response, without explanations or additional textQuestion: {{question}} Database Schema: {{database_schema}} Response: {content}'\n )\n", (2748, 3001), False, 'from langchain.prompts import MessagesPlaceholder, HumanMessagePromptTemplate, ChatPromptTemplate\n')] |
import langchain_visualizer # isort:skip # noqa: F401
import asyncio
import vcr_langchain as vcr
from fvalues import FValue
from langchain import PromptTemplate
from langchain.llms import OpenAI
# ========================== Start of langchain example code ==========================
# https://langchain.readthedocs.io/en/latest/modules/prompts/getting_started.html
# An example prompt with one input variable
one_input_prompt = PromptTemplate(
input_variables=["adjective"], template="Tell me a {adjective} joke."
)
prompt = one_input_prompt.format(adjective="funny")
# ================================== Execute example ==================================
def test_prompt():
assert prompt.parts == (
"Tell me a ",
FValue(source="adjective", value="funny", formatted="funny"),
" joke.",
)
@vcr.use_cassette()
async def one_input_prompt_demo():
agent = OpenAI(model_name="text-ada-001", temperature=0)
return agent(prompt)
def test_llm_usage_succeeds():
"""
Check that it works like a regular prompt.
Also, record playback for easy visualization.
"""
result = asyncio.get_event_loop().run_until_complete(one_input_prompt_demo())
assert result.strip().startswith("Why did the chicken cross the road?")
if __name__ == "__main__":
from langchain_visualizer import visualize
visualize(one_input_prompt_demo)
| [
"langchain_visualizer.visualize",
"langchain.llms.OpenAI",
"langchain.PromptTemplate"
] | [((434, 524), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['adjective']", 'template': '"""Tell me a {adjective} joke."""'}), "(input_variables=['adjective'], template=\n 'Tell me a {adjective} joke.')\n", (448, 524), False, 'from langchain import PromptTemplate\n'), ((837, 855), 'vcr_langchain.use_cassette', 'vcr.use_cassette', ([], {}), '()\n', (853, 855), True, 'import vcr_langchain as vcr\n'), ((903, 951), 'langchain.llms.OpenAI', 'OpenAI', ([], {'model_name': '"""text-ada-001"""', 'temperature': '(0)'}), "(model_name='text-ada-001', temperature=0)\n", (909, 951), False, 'from langchain.llms import OpenAI\n'), ((1362, 1394), 'langchain_visualizer.visualize', 'visualize', (['one_input_prompt_demo'], {}), '(one_input_prompt_demo)\n', (1371, 1394), False, 'from langchain_visualizer import visualize\n'), ((748, 808), 'fvalues.FValue', 'FValue', ([], {'source': '"""adjective"""', 'value': '"""funny"""', 'formatted': '"""funny"""'}), "(source='adjective', value='funny', formatted='funny')\n", (754, 808), False, 'from fvalues import FValue\n'), ((1136, 1160), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (1158, 1160), False, 'import asyncio\n')] |
from typing import Optional, List
from langchain.chains.openai_functions import create_structured_output_runnable
from langchain_community.chat_models import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
import logging
import langchain
from dreamsboard.document_loaders.protocol.ner_protocol import DreamsStepInfo, DreamsStepInfoListWrapper
langchain.verbose = True
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logging.basicConfig(level=logging.DEBUG)
# 控制台打印
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
logger.addHandler(handler)
def test_create_structured_output_runnable2() -> None:
"""Test create_structured_output_runnable. 测试创建结构化输出可运行对象。"""
llm = ChatOpenAI(openai_api_base='http://127.0.0.1:30000/v1',
model="glm-4",
openai_api_key="glm-4",
verbose=True,
temperature=0.1,
top_p=0.9, )
prompt = ChatPromptTemplate.from_messages(
[
("system", """根据提供的故事场景，您作为心理咨询工作者可以使用开放性问题来引导来访者表达他们的感受和思维。以下是一步一步的分解：
**Step 1: 建立情感连接**
开始时，您可以通过表达理解和共鸣来建立情感连接，让来访者感到舒适。您可以说：“我注意到这个对话中有许多愉快的时刻和互动。你对这些时刻有什么特别的感受吗？”
**Step 2: 探索来访者的感受**
继续引导来访者表达他们的感受。您可以问：“在这个对话中，有哪些瞬间让你感到开心或快乐？”
**Step 3: 询问是否有反感情绪**
除了积极的情感，也要问询是否有一些负面情感或担忧。您可以说：“除了快乐的瞬间，是否有一些让你感到不安或担忧的地方？”
**Step 4: 深入探讨个人反应**
一旦来访者开始分享他们的感受，可以深入探讨他们的个人反应。例如：“你觉得自己在这些互动中扮演了什么角色？”
**Step 5: 探索与他人的互动**
继续引导来访者思考他们与他人的互动。您可以问：“这些互动对你与他人的关系有什么影响？你觉得与朋友之间的互动如何影响你的情感状态？”
**Step 6: 引导自我反思**
最后，鼓励来访者进行自我反思。您可以问：“在这个故事场景中，你是否注意到了自己的情感变化或思维模式？有没有什么你想要深入探讨或解决的问题？”
通过这种方式，您可以引导来访者自由表达他们的情感和思维，帮助他们更好地理解自己和他们与他人的互动。同时，保持开放和倾听，以便在需要时提供支持和建议。"""),
("ai", """step_advice|step_description
我注意到这个对话中有许多愉快的时刻和互动。你对这些时刻有什么特别的感受吗？|建立情感连接
在这个对话中，有哪些瞬间让你感到开心或快乐?|探索来访者的感受
除了快乐的瞬间，是否有一些让你感到不安或担忧的地方？|询问是否有反感情绪
你觉得自己在这些互动中扮演了什么角色?|深入探讨个人反应
这些互动对你与他人的关系有什么影响？你觉得与朋友之间的互动如何影响你的情感状态?|探索与他人的互动
在这个故事场景中，你是否注意到了自己的情感变化或思维模式？有没有什么你想要深入探讨或解决的问题?|引导自我反思"""),
("human", "{input}"),
]
)
chain = create_structured_output_runnable(DreamsStepInfoListWrapper, llm, prompt)
out = chain.invoke({"input": """以下是如何通过分步引导来访者张毛峰说出自己的问题的步骤：
### Step 1: 建立情感连接
- “张毛峰，我注意到你提到的这段经历让你感到非常愉快，甚至有些事情让你忍不住笑出声。能跟我分享一下，那个让你这么开心的事情吗？”
### Step 2: 探索来访者的积极感受
- “在那次和小姐姐的互动中，有哪些具体的瞬间让你感到特别快乐？”
### Step 3: 引导来访者表达背后的动机和情感
- “我看到你因为举报那位小姐姐而感到开心，这背后有没有什么特别的原因？你能告诉我举报她的行为对你意味着什么吗？”
### Step 4: 探询来访者的内心冲突和不安
- “虽然这件事情让你觉得开心，但我想知道，在整件事情中，有没有什么让你感到困扰或不安的地方？”
### Step 5: 询问来访者的反思和感受
- “你提到觉得有时候没有必要讲道理，这是不是说明这件事情也让你感到某种程度上的矛盾和困惑？”
### Step 6: 深入探讨来访者的自我认知
- “你说‘我不想玩了，因为我不是我自己了’，这句话似乎透露出你对自己有一些新的认识。你能解释一下这是什么意思吗？”
以下是具体的步骤分解：
**Step 1: 建立情感连接**
- 通过询问张毛峰感到愉快的时刻来建立情感上的联系。
**Step 2: 探索来访者的积极感受**
- 帮助张毛峰回忆和描述那些让他感到快乐的细节。
**Step 3: 引导来访者表达背后的动机和情感**
- 深入探讨举报行为背后的动机和情感，了解他为何会因为举报而感到快乐。
**Step 4: 探询来访者的内心冲突和不安**
- 询问是否有任何不安或冲突的情绪，比如对于自己行为的道德考量。
**Step 5: 询问来访者的反思和感受**
- 让张毛峰反思他的行为和感受，了解他对于讲道理的看法。
**Step 6: 深入探讨来访者的自我认知**
- 针对他提到的“我不是我自己了”这句话，探索他的自我认同和可能的内心变化。
通过这样的引导，可以帮助张毛峰表达和认识自己的情感、动机和内心冲突，从而更好地理解自己的问题所在。"""})
logger.info(out)
# -> Dog(name="Harry", color="brown", fav_food="chicken")
| [
"langchain_core.prompts.ChatPromptTemplate.from_messages",
"langchain.chains.openai_functions.create_structured_output_runnable",
"langchain_community.chat_models.ChatOpenAI"
] | [((453, 480), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (470, 480), False, 'import logging\n'), ((512, 552), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (531, 552), False, 'import logging\n'), ((571, 594), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (592, 594), False, 'import logging\n'), ((788, 928), 'langchain_community.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_base': '"""http://127.0.0.1:30000/v1"""', 'model': '"""glm-4"""', 'openai_api_key': '"""glm-4"""', 'verbose': '(True)', 'temperature': '(0.1)', 'top_p': '(0.9)'}), "(openai_api_base='http://127.0.0.1:30000/v1', model='glm-4',\n openai_api_key='glm-4', verbose=True, temperature=0.1, top_p=0.9)\n", (798, 928), False, 'from langchain_community.chat_models import ChatOpenAI\n'), ((1045, 2067), 'langchain_core.prompts.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (['[(\'system\',\n """根据提供的故事场景，您作为心理咨询工作者可以使用开放性问题来引导来访者表达他们的感受和思维。以下是一步一步的分解：\n\n**Step 1: 建立情感连接**\n开始时，您可以通过表达理解和共鸣来建立情感连接，让来访者感到舒适。您可以说：“我注意到这个对话中有许多愉快的时刻和互动。你对这些时刻有什么特别的感受吗？”\n\n**Step 2: 探索来访者的感受**\n继续引导来访者表达他们的感受。您可以问：“在这个对话中，有哪些瞬间让你感到开心或快乐？”\n\n**Step 3: 询问是否有反感情绪**\n除了积极的情感，也要问询是否有一些负面情感或担忧。您可以说：“除了快乐的瞬间，是否有一些让你感到不安或担忧的地方？”\n\n**Step 4: 深入探讨个人反应**\n一旦来访者开始分享他们的感受，可以深入探讨他们的个人反应。例如：“你觉得自己在这些互动中扮演了什么角色？”\n\n**Step 5: 探索与他人的互动**\n继续引导来访者思考他们与他人的互动。您可以问：“这些互动对你与他人的关系有什么影响？你觉得与朋友之间的互动如何影响你的情感状态？”\n\n**Step 6: 引导自我反思**\n最后，鼓励来访者进行自我反思。您可以问：“在这个故事场景中，你是否注意到了自己的情感变化或思维模式？有没有什么你想要深入探讨或解决的问题？”\n\n通过这种方式，您可以引导来访者自由表达他们的情感和思维，帮助他们更好地理解自己和他们与他人的互动。同时，保持开放和倾听，以便在需要时提供支持和建议。"""\n ), (\'ai\',\n """step_advice|step_description\n我注意到这个对话中有许多愉快的时刻和互动。你对这些时刻有什么特别的感受吗？|建立情感连接\n在这个对话中，有哪些瞬间让你感到开心或快乐?|探索来访者的感受\n除了快乐的瞬间，是否有一些让你感到不安或担忧的地方？|询问是否有反感情绪\n你觉得自己在这些互动中扮演了什么角色?|深入探讨个人反应\n这些互动对你与他人的关系有什么影响？你觉得与朋友之间的互动如何影响你的情感状态?|探索与他人的互动\n在这个故事场景中，你是否注意到了自己的情感变化或思维模式？有没有什么你想要深入探讨或解决的问题?|引导自我反思"""\n ), (\'human\', \'{input}\')]'], {}), '([(\'system\',\n """根据提供的故事场景，您作为心理咨询工作者可以使用开放性问题来引导来访者表达他们的感受和思维。以下是一步一步的分解：\n\n**Step 1: 建立情感连接**\n开始时，您可以通过表达理解和共鸣来建立情感连接，让来访者感到舒适。您可以说：“我注意到这个对话中有许多愉快的时刻和互动。你对这些时刻有什么特别的感受吗？”\n\n**Step 2: 探索来访者的感受**\n继续引导来访者表达他们的感受。您可以问：“在这个对话中，有哪些瞬间让你感到开心或快乐？”\n\n**Step 3: 询问是否有反感情绪**\n除了积极的情感，也要问询是否有一些负面情感或担忧。您可以说：“除了快乐的瞬间，是否有一些让你感到不安或担忧的地方？”\n\n**Step 4: 深入探讨个人反应**\n一旦来访者开始分享他们的感受，可以深入探讨他们的个人反应。例如：“你觉得自己在这些互动中扮演了什么角色？”\n\n**Step 5: 探索与他人的互动**\n继续引导来访者思考他们与他人的互动。您可以问：“这些互动对你与他人的关系有什么影响？你觉得与朋友之间的互动如何影响你的情感状态？”\n\n**Step 6: 引导自我反思**\n最后，鼓励来访者进行自我反思。您可以问：“在这个故事场景中，你是否注意到了自己的情感变化或思维模式？有没有什么你想要深入探讨或解决的问题？”\n\n通过这种方式，您可以引导来访者自由表达他们的情感和思维，帮助他们更好地理解自己和他们与他人的互动。同时，保持开放和倾听，以便在需要时提供支持和建议。"""\n ), (\'ai\',\n """step_advice|step_description\n我注意到这个对话中有许多愉快的时刻和互动。你对这些时刻有什么特别的感受吗？|建立情感连接\n在这个对话中，有哪些瞬间让你感到开心或快乐?|探索来访者的感受\n除了快乐的瞬间，是否有一些让你感到不安或担忧的地方？|询问是否有反感情绪\n你觉得自己在这些互动中扮演了什么角色?|深入探讨个人反应\n这些互动对你与他人的关系有什么影响？你觉得与朋友之间的互动如何影响你的情感状态?|探索与他人的互动\n在这个故事场景中，你是否注意到了自己的情感变化或思维模式？有没有什么你想要深入探讨或解决的问题?|引导自我反思"""\n ), (\'human\', \'{input}\')])\n', (1077, 2067), False, 'from langchain_core.prompts import ChatPromptTemplate\n'), ((2123, 2196), 'langchain.chains.openai_functions.create_structured_output_runnable', 'create_structured_output_runnable', (['DreamsStepInfoListWrapper', 'llm', 'prompt'], {}), '(DreamsStepInfoListWrapper, llm, prompt)\n', (2156, 2196), False, 'from langchain.chains.openai_functions import create_structured_output_runnable\n')] |
import logging
from langchain.chat_models import ChatOpenAI
from dreamsboard.dreams.builder_cosplay_code.base import StructuredDreamsStoryboard
from dreamsboard.dreams.dreams_personality_chain.base import StoryBoardDreamsGenerationChain
import langchain
from dreamsboard.engine.generate.code_generate import QueryProgramGenerator, EngineProgramGenerator, AIProgramGenerator
from dreamsboard.engine.loading import load_store_from_storage
from dreamsboard.engine.storage.storage_context import StorageContext
langchain.verbose = True
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
# 控制台打印
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
logger.addHandler(handler)
def test_structured_dreams_storyboard_store_print() -> None:
try:
storage_context = StorageContext.from_defaults(persist_dir="./storage")
code_gen_builder = load_store_from_storage(storage_context)
index_loaded = True
except:
index_loaded = False
if not index_loaded:
llm = ChatOpenAI(
verbose=True
)
dreams_generation_chain = StoryBoardDreamsGenerationChain.from_dreams_personality_chain(
llm=llm, csv_file_path="/media/checkpoint/speech_data/抖音作品/id46Bv3g/str/id46Bv3g_keyframe.csv")
output = dreams_generation_chain.run()
logger.info("dreams_guidance_context:" + output.get("dreams_guidance_context"))
logger.info("dreams_personality_context:" + output.get("dreams_personality_context"))
dreams_guidance_context = output.get("dreams_guidance_context")
dreams_personality_context = output.get("dreams_personality_context")
storyboard_executor = StructuredDreamsStoryboard.form_builder(llm=llm,
builder=dreams_generation_chain.builder,
dreams_guidance_context=dreams_guidance_context,
dreams_personality_context=dreams_personality_context
)
code_gen_builder = storyboard_executor.loader_cosplay_builder()
executor = code_gen_builder.build_executor()
logger.info(executor.executor_code)
assert True
| [
"langchain.chat_models.ChatOpenAI"
] | [((545, 572), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (562, 572), False, 'import logging\n'), ((623, 646), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (644, 646), False, 'import logging\n'), ((806, 859), 'dreamsboard.engine.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""./storage"""'}), "(persist_dir='./storage')\n", (834, 859), False, 'from dreamsboard.engine.storage.storage_context import StorageContext\n'), ((887, 927), 'dreamsboard.engine.loading.load_store_from_storage', 'load_store_from_storage', (['storage_context'], {}), '(storage_context)\n', (910, 927), False, 'from dreamsboard.engine.loading import load_store_from_storage\n'), ((1037, 1061), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'verbose': '(True)'}), '(verbose=True)\n', (1047, 1061), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1119, 1285), 'dreamsboard.dreams.dreams_personality_chain.base.StoryBoardDreamsGenerationChain.from_dreams_personality_chain', 'StoryBoardDreamsGenerationChain.from_dreams_personality_chain', ([], {'llm': 'llm', 'csv_file_path': '"""/media/checkpoint/speech_data/抖音作品/id46Bv3g/str/id46Bv3g_keyframe.csv"""'}), "(llm=llm,\n csv_file_path=\n '/media/checkpoint/speech_data/抖音作品/id46Bv3g/str/id46Bv3g_keyframe.csv')\n", (1180, 1285), False, 'from dreamsboard.dreams.dreams_personality_chain.base import StoryBoardDreamsGenerationChain\n'), ((1701, 1909), 'dreamsboard.dreams.builder_cosplay_code.base.StructuredDreamsStoryboard.form_builder', 'StructuredDreamsStoryboard.form_builder', ([], {'llm': 'llm', 'builder': 'dreams_generation_chain.builder', 'dreams_guidance_context': 'dreams_guidance_context', 'dreams_personality_context': 'dreams_personality_context'}), '(llm=llm, builder=\n dreams_generation_chain.builder, dreams_guidance_context=\n dreams_guidance_context, dreams_personality_context=\n dreams_personality_context)\n', (1740, 1909), False, 'from dreamsboard.dreams.builder_cosplay_code.base import StructuredDreamsStoryboard\n')] |
from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec
from model.chain_revision import ChainRevision
from model.lang_chain_context import LangChainContext
from langchain.llms.fake import FakeListLLM
from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory
def test_llm_chain_spec_serialization():
llm_chain_spec = LLMChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_key="output1",
prompt="prompt",
llm_key="llm_key",
chain_type="llm_chain_spec",
)
serialized = llm_chain_spec.json()
assert serialized == '{"chain_id": 1, "input_keys": ["input1", "input2"], "output_key": "output1", "chain_type": "llm_chain_spec", "prompt": "prompt", "llm_key": "llm_key"}'
revision = ChainRevision(chain=llm_chain_spec, llms={})
serialized_revision = revision.json()
deserialized = ChainRevision.parse_raw(serialized_revision).chain
assert deserialized == llm_chain_spec
def test_llm_chain_spec_to_lang_chain_creates_valid_chain():
prompt_template = "the prompt {input1} {input2}"
llm_chain_spec = LLMChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_key="output1",
prompt=prompt_template,
llm_key="test",
chain_type="llm_chain_spec",
)
llms = llms={"test": FakeListLLM(responses=["response1"])}
ctx = LangChainContext(llms=llms)
llm_chain = llm_chain_spec.to_lang_chain(ctx)
assert llm_chain.input_keys == ["input1", "input2"]
assert llm_chain.output_key == "output1"
assert llm_chain.prompt.template == prompt_template
assert llm_chain.llm == llms["test"]
output = llm_chain._call({"input1": "input1", "input2": "input2"})
assert output == {"output1": "response1"}
def test_llm_chain_spec_to_lang_chain_creates_recording_chain():
prompt_template = "the prompt {input1} {input2}"
llm_chain_spec = LLMChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_key="output1",
prompt=prompt_template,
llm_key="test",
chain_type="llm_chain_spec",
)
llms = llms={"test": FakeListLLM(responses=["response1"])}
ctx = LangChainContext(llms=llms, recording=True)
llm_chain = llm_chain_spec.to_lang_chain(ctx)
assert len(ctx.prompts) == 1
output = llm_chain._call({"input1": "input1", "input2": "input2"})
assert output == {"output1": "response1"}
assert ctx.prompts[0].calls == [
({"input1": "input1", "input2": "input2"}, {"output1": "response1"})
]
def test_sequential_chain_spec_serialization():
sequential_chain_spec = SequentialChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_keys=["output1", "output2"],
chain_type="sequential_chain_spec",
chains=[
LLMChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_key="output1",
prompt="prompt",
llm_key="llm_key",
chain_type="llm_chain_spec"
)
],
)
serialized = sequential_chain_spec.json()
deserialized = SequentialChainSpec.parse_raw(serialized)
assert deserialized == sequential_chain_spec
def test_sequential_chain_spec_to_lang_chain_creates_valid_chain():
llm_chain_spec1 = LLMChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_key="llm1_output",
prompt="the prompt {input1} {input2}",
llm_key="test",
chain_type="llm_chain_spec",
)
llm_chain_spec2 = LLMChainSpec(
chain_id=2,
input_keys=["llm1_output", "input3"],
output_key="llm2_output",
prompt="the prompt {llm1_output} {input3}",
llm_key="test",
chain_type="llm_chain_spec",
)
sequential_chain_spec = SequentialChainSpec(
chain_id=3,
input_keys=["input1", "input2", "input3"],
output_keys=["llm2_output"],
chain_type="sequential_chain_spec",
chains=[llm_chain_spec1, llm_chain_spec2],
)
llms = llms={"test": FakeListLLM(responses=["fake_response1", "fake_response2"])}
ctx = LangChainContext(llms=llms)
sequential_chain = sequential_chain_spec.to_lang_chain(ctx)
assert sequential_chain.input_keys == ["input1", "input2", "input3"]
assert sequential_chain.output_keys == ["llm2_output"]
assert sequential_chain.chains[0].input_keys == ["input1", "input2"]
assert sequential_chain.chains[0].output_keys == ["llm1_output"]
assert sequential_chain.chains[0].prompt.template == llm_chain_spec1.prompt
assert sequential_chain.chains[0].llm == llms["test"]
assert sequential_chain.chains[1].input_keys == ["llm1_output", "input3"]
assert sequential_chain.chains[1].output_keys == ["llm2_output"]
assert sequential_chain.chains[1].prompt.template == llm_chain_spec2.prompt
assert sequential_chain.chains[1].llm == llms["test"]
output = sequential_chain.run({"input1": "input1", "input2": "input2", "input3": "input3"})
assert output == "fake_response2"
def test_case_chain_spec_serialization():
case_chain_spec = CaseChainSpec(
chain_id=3,
chain_type="case_chain_spec",
categorization_key="categorization_input",
cases={
"response1": LLMChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_key="output",
prompt="prompt",
llm_key="test",
chain_type="llm_chain_spec"
),
"response2": LLMChainSpec(
chain_id=2,
input_keys=["input3", "input4"],
output_key="output",
prompt="prompt",
llm_key="test",
chain_type="llm_chain_spec"
)
},
default_case=LLMChainSpec(
chain_id=4,
input_keys=["input1", "input2"],
output_key="output",
prompt="prompt",
llm_key="test",
chain_type="llm_chain_spec"
),
)
serialized = case_chain_spec.json()
deserialized = CaseChainSpec.parse_raw(serialized)
assert deserialized == case_chain_spec
def test_case_chain_spec_to_lang_chain_creates_valid_chain():
llms = {"test1": FakeListLLM(responses=["fake_response1"]), "test2": FakeListLLM(responses=["fake_response2"])}
llm_chain_spec1 = LLMChainSpec(
chain_id=1,
input_keys=["input1", "input2"],
output_key="output",
prompt="ll1 prompt {input1} {input2}",
llm_key="test1",
chain_type="llm_chain_spec",
)
llm_chain_spec2 = LLMChainSpec(
chain_id=2,
input_keys=["input3", "input4"],
output_key="output",
prompt="llm2 prompt {input3} {input4}",
llm_key="test2",
chain_type="llm_chain_spec",
)
llm_chain_spec3 = LLMChainSpec(
chain_id=4,
input_keys=["input1", "input2"],
output_key="output",
prompt="default prompt {input1} {input2}",
llm_key="test1",
chain_type="llm_chain_spec"
)
case_chain_spec = CaseChainSpec(
chain_id=3,
chain_type="case_chain_spec",
categorization_key="categorization_input",
cases={
"response1": llm_chain_spec1,
"response2": llm_chain_spec2,
},
default_case=llm_chain_spec3,
)
ctx = LangChainContext(llms=llms)
case_chain = case_chain_spec.to_lang_chain(ctx)
assert case_chain.input_keys == ["categorization_input", "input1", "input2", "input3", "input4"]
assert case_chain.output_keys == ["output"]
assert case_chain.subchains["response1"].input_keys == ["input1", "input2"]
assert case_chain.subchains["response1"].output_keys == ["output"]
assert case_chain.subchains["response1"].prompt.template == llm_chain_spec1.prompt
assert case_chain.subchains["response1"].llm == llms["test1"]
assert case_chain.subchains["response2"].input_keys == ["input3", "input4"]
assert case_chain.subchains["response2"].output_keys == ["output"]
assert case_chain.subchains["response2"].prompt.template == llm_chain_spec2.prompt
assert case_chain.subchains["response2"].llm == llms["test2"]
assert case_chain.default_chain.input_keys == ["input1", "input2"]
assert case_chain.default_chain.output_keys == ["output"]
assert case_chain.default_chain.prompt.template == llm_chain_spec3.prompt
assert case_chain.default_chain.llm == llms["test1"]
output = case_chain.run({
"categorization_input": "response2",
"input1": "input1",
"input2": "input2",
"input3": "input3",
"input4": "input4"
})
assert output == "fake_response2"
def test_api_chain_spec_serialization():
api_chain_spec = APIChainSpec(
chain_id=3,
chain_type="api_chain_spec",
input_keys=["input1", "input2"],
output_key="output",
url="http://test.com",
method="POST",
body="body {input1} {input2}",
headers={"header1": "header1"},
)
revision = ChainRevision(chain=api_chain_spec, llms={})
serialized_revision = revision.json()
deserialized = ChainRevision.parse_raw(serialized_revision).chain
assert deserialized == api_chain_spec
def test_api_chain_spec_to_lang_chain_creates_valid_chain():
api_chain_spec = APIChainSpec(
chain_id=3,
chain_type="api_chain_spec",
input_keys=["input1", "input2"],
output_key="output",
url="http://test.com",
method="POST",
body="body {input1} {input2}",
headers={"header1": "header1"},
)
ctx = LangChainContext(llms={})
api_chain = api_chain_spec.to_lang_chain(ctx)
assert api_chain.input_keys == ["input1", "input2"]
assert api_chain.output_keys == ["output"]
assert api_chain.url == "http://test.com"
assert api_chain.method == "POST"
assert api_chain.body == "body {input1} {input2}"
assert api_chain.headers == {"header1": "header1"}
def test_reformat_chain_spec_serialization():
reformat_chain_spec = ReformatChainSpec(
chain_id=3,
chain_type="reformat_chain_spec",
input_keys=["input1", "input2"],
formatters={"output1": "formatter1", "output2": "formatter2"},
)
serialized = reformat_chain_spec.json()
deserialized = ReformatChainSpec.parse_raw(serialized)
assert deserialized == reformat_chain_spec
def test_reformat_chain_spec_to_lang_chain_creates_valid_chain():
reformat_chain_spec = ReformatChainSpec(
chain_id=3,
chain_type="reformat_chain_spec",
input_keys=["input1", "input2"],
formatters={"output1": "formatter1", "output2": "formatter2"},
)
ctx = LangChainContext(llms={})
reformat_chain = reformat_chain_spec.to_lang_chain(ctx)
assert reformat_chain.input_keys == ["input1", "input2"]
assert reformat_chain.output_keys == ["output1", "output2"]
assert reformat_chain.formatters == {"output1": "formatter1", "output2": "formatter2"}
def test_transform_chain_spec_to_lang_chain_creates_valid_chain():
transform_chain_spec = TransformChainSpec(
chain_id=4,
chain_type="transform_chain_spec",
input_keys=["x", "y"],
output_keys=["z", "w"],
transform_func="""
z = int(inputs['x']) + int(inputs['y'])
w = int(inputs['x']) - int(inputs['y'])
return {'z': z, 'w': w}"""
)
ctx = LangChainContext(llms={})
transform_chain = transform_chain_spec.to_lang_chain(ctx)
assert transform_chain.input_keys == ["x", "y"]
assert transform_chain.output_keys == ["z", "w"]
assert transform_chain.transform({'x': 4, 'y': 3}) == {'z': 7, 'w': 1}
def test_vector_search_chain_spec_serialization():
vector_search_chain_spec = VectorSearchChainSpec(
chain_id=3,
chain_type="vector_search_chain_spec",
input_keys=["input1", "input2"],
output_key="output",
embedding_engine="openai",
embedding_params={"openai_api_key": "test"},
database="pinecone",
database_params={"index": "test", "text_key": "text"},
num_results=10,
query="How does {input}?"
)
serialized = vector_search_chain_spec.json()
deserialized = VectorSearchChainSpec.parse_raw(serialized)
assert deserialized == vector_search_chain_spec
class ChainDict:
def __init__(self):
self.chains = {}
def add_chain(self, chain):
self.chains[chain.chain_id] = chain
def test_chain_spec_copy_replace():
ctx = SpecFactoryContext()
chain = sequential_factory(ctx, chains=[
llm_factory(ctx),
case_factory(ctx, cases={
"case1": llm_factory(ctx),
"case2": sequential_factory(ctx, chains=[llm_factory(ctx), llm_factory(ctx)]),
}, default_case=llm_factory(ctx)),
])
original_specs = ChainDict()
chain.traverse(original_specs.add_chain)
copied_specs = {}
copied_chain = chain.copy_replace(lambda spec: spec)
copied_specs = ChainDict()
copied_chain.traverse(copied_specs.add_chain)
assert len(original_specs.chains) == len(copied_specs.chains)
for chain_id, spec in original_specs.chains.items():
copied_spec = copied_specs.chains.get(chain_id)
assert copied_spec is not None
assert copied_spec == spec
assert copied_spec is not spec
replacement = copied_specs.chains[3]
replacement.prompt = "replaced"
replace_chain = chain.copy_replace(lambda spec: spec if spec.chain_id != 3 else replacement)
replace_specs = ChainDict()
replace_chain.traverse(replace_specs.add_chain)
assert len(original_specs.chains) == len(replace_specs.chains)
assert replace_specs.chains[3] == replacement
assert replace_specs.chains[3].prompt == "replaced"
def test_base_spec_find_by_chain_id():
ctx = SpecFactoryContext()
deep_llm = llm_factory(ctx)
chain = sequential_factory(ctx, chains=[
llm_factory(ctx),
case_factory(ctx, cases={
"case1": llm_factory(ctx),
"case2": sequential_factory(ctx, chains=[llm_factory(ctx), deep_llm]),
}, default_case=llm_factory(ctx)),
])
assert chain.find_by_chain_id(deep_llm.chain_id) == deep_llm | [
"langchain.llms.fake.FakeListLLM"
] | [((471, 620), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(1)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output1"""', 'prompt': '"""prompt"""', 'llm_key': '"""llm_key"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=1, input_keys=['input1', 'input2'], output_key=\n 'output1', prompt='prompt', llm_key='llm_key', chain_type='llm_chain_spec')\n", (483, 620), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((904, 948), 'model.chain_revision.ChainRevision', 'ChainRevision', ([], {'chain': 'llm_chain_spec', 'llms': '{}'}), '(chain=llm_chain_spec, llms={})\n', (917, 948), False, 'from model.chain_revision import ChainRevision\n'), ((1240, 1398), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(1)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output1"""', 'prompt': 'prompt_template', 'llm_key': '"""test"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=1, input_keys=['input1', 'input2'], output_key=\n 'output1', prompt=prompt_template, llm_key='test', chain_type=\n 'llm_chain_spec')\n", (1252, 1398), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((1517, 1544), 'model.lang_chain_context.LangChainContext', 'LangChainContext', ([], {'llms': 'llms'}), '(llms=llms)\n', (1533, 1544), False, 'from model.lang_chain_context import LangChainContext\n'), ((2053, 2211), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(1)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output1"""', 'prompt': 'prompt_template', 'llm_key': '"""test"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=1, input_keys=['input1', 'input2'], output_key=\n 'output1', prompt=prompt_template, llm_key='test', chain_type=\n 'llm_chain_spec')\n", (2065, 2211), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((2330, 2373), 'model.lang_chain_context.LangChainContext', 'LangChainContext', ([], {'llms': 'llms', 'recording': '(True)'}), '(llms=llms, recording=True)\n', (2346, 2373), False, 'from model.lang_chain_context import LangChainContext\n'), ((3311, 3352), 'model.chain_spec.SequentialChainSpec.parse_raw', 'SequentialChainSpec.parse_raw', (['serialized'], {}), '(serialized)\n', (3340, 3352), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((3495, 3671), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(1)', 'input_keys': "['input1', 'input2']", 'output_key': '"""llm1_output"""', 'prompt': '"""the prompt {input1} {input2}"""', 'llm_key': '"""test"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=1, input_keys=['input1', 'input2'], output_key=\n 'llm1_output', prompt='the prompt {input1} {input2}', llm_key='test',\n chain_type='llm_chain_spec')\n", (3507, 3671), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((3796, 3983), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(2)', 'input_keys': "['llm1_output', 'input3']", 'output_key': '"""llm2_output"""', 'prompt': '"""the prompt {llm1_output} {input3}"""', 'llm_key': '"""test"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=2, input_keys=['llm1_output', 'input3'], output_key=\n 'llm2_output', prompt='the prompt {llm1_output} {input3}', llm_key=\n 'test', chain_type='llm_chain_spec')\n", (3808, 3983), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((4114, 4305), 'model.chain_spec.SequentialChainSpec', 'SequentialChainSpec', ([], {'chain_id': '(3)', 'input_keys': "['input1', 'input2', 'input3']", 'output_keys': "['llm2_output']", 'chain_type': '"""sequential_chain_spec"""', 'chains': '[llm_chain_spec1, llm_chain_spec2]'}), "(chain_id=3, input_keys=['input1', 'input2', 'input3'],\n output_keys=['llm2_output'], chain_type='sequential_chain_spec', chains\n =[llm_chain_spec1, llm_chain_spec2])\n", (4133, 4305), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((4441, 4468), 'model.lang_chain_context.LangChainContext', 'LangChainContext', ([], {'llms': 'llms'}), '(llms=llms)\n', (4457, 4468), False, 'from model.lang_chain_context import LangChainContext\n'), ((6447, 6482), 'model.chain_spec.CaseChainSpec.parse_raw', 'CaseChainSpec.parse_raw', (['serialized'], {}), '(serialized)\n', (6470, 6482), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((6728, 6900), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(1)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output"""', 'prompt': '"""ll1 prompt {input1} {input2}"""', 'llm_key': '"""test1"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=1, input_keys=['input1', 'input2'], output_key=\n 'output', prompt='ll1 prompt {input1} {input2}', llm_key='test1',\n chain_type='llm_chain_spec')\n", (6740, 6900), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((7025, 7198), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(2)', 'input_keys': "['input3', 'input4']", 'output_key': '"""output"""', 'prompt': '"""llm2 prompt {input3} {input4}"""', 'llm_key': '"""test2"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=2, input_keys=['input3', 'input4'], output_key=\n 'output', prompt='llm2 prompt {input3} {input4}', llm_key='test2',\n chain_type='llm_chain_spec')\n", (7037, 7198), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((7323, 7499), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(4)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output"""', 'prompt': '"""default prompt {input1} {input2}"""', 'llm_key': '"""test1"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=4, input_keys=['input1', 'input2'], output_key=\n 'output', prompt='default prompt {input1} {input2}', llm_key='test1',\n chain_type='llm_chain_spec')\n", (7335, 7499), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((7624, 7829), 'model.chain_spec.CaseChainSpec', 'CaseChainSpec', ([], {'chain_id': '(3)', 'chain_type': '"""case_chain_spec"""', 'categorization_key': '"""categorization_input"""', 'cases': "{'response1': llm_chain_spec1, 'response2': llm_chain_spec2}", 'default_case': 'llm_chain_spec3'}), "(chain_id=3, chain_type='case_chain_spec', categorization_key=\n 'categorization_input', cases={'response1': llm_chain_spec1,\n 'response2': llm_chain_spec2}, default_case=llm_chain_spec3)\n", (7637, 7829), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((7922, 7949), 'model.lang_chain_context.LangChainContext', 'LangChainContext', ([], {'llms': 'llms'}), '(llms=llms)\n', (7938, 7949), False, 'from model.lang_chain_context import LangChainContext\n'), ((9327, 9543), 'model.chain_spec.APIChainSpec', 'APIChainSpec', ([], {'chain_id': '(3)', 'chain_type': '"""api_chain_spec"""', 'input_keys': "['input1', 'input2']", 'output_key': '"""output"""', 'url': '"""http://test.com"""', 'method': '"""POST"""', 'body': '"""body {input1} {input2}"""', 'headers': "{'header1': 'header1'}"}), "(chain_id=3, chain_type='api_chain_spec', input_keys=['input1',\n 'input2'], output_key='output', url='http://test.com', method='POST',\n body='body {input1} {input2}', headers={'header1': 'header1'})\n", (9339, 9543), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((9623, 9667), 'model.chain_revision.ChainRevision', 'ChainRevision', ([], {'chain': 'api_chain_spec', 'llms': '{}'}), '(chain=api_chain_spec, llms={})\n', (9636, 9667), False, 'from model.chain_revision import ChainRevision\n'), ((9906, 10122), 'model.chain_spec.APIChainSpec', 'APIChainSpec', ([], {'chain_id': '(3)', 'chain_type': '"""api_chain_spec"""', 'input_keys': "['input1', 'input2']", 'output_key': '"""output"""', 'url': '"""http://test.com"""', 'method': '"""POST"""', 'body': '"""body {input1} {input2}"""', 'headers': "{'header1': 'header1'}"}), "(chain_id=3, chain_type='api_chain_spec', input_keys=['input1',\n 'input2'], output_key='output', url='http://test.com', method='POST',\n body='body {input1} {input2}', headers={'header1': 'header1'})\n", (9918, 10122), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((10196, 10221), 'model.lang_chain_context.LangChainContext', 'LangChainContext', ([], {'llms': '{}'}), '(llms={})\n', (10212, 10221), False, 'from model.lang_chain_context import LangChainContext\n'), ((10643, 10811), 'model.chain_spec.ReformatChainSpec', 'ReformatChainSpec', ([], {'chain_id': '(3)', 'chain_type': '"""reformat_chain_spec"""', 'input_keys': "['input1', 'input2']", 'formatters': "{'output1': 'formatter1', 'output2': 'formatter2'}"}), "(chain_id=3, chain_type='reformat_chain_spec', input_keys=\n ['input1', 'input2'], formatters={'output1': 'formatter1', 'output2':\n 'formatter2'})\n", (10660, 10811), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((10905, 10944), 'model.chain_spec.ReformatChainSpec.parse_raw', 'ReformatChainSpec.parse_raw', (['serialized'], {}), '(serialized)\n', (10932, 10944), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((11086, 11254), 'model.chain_spec.ReformatChainSpec', 'ReformatChainSpec', ([], {'chain_id': '(3)', 'chain_type': '"""reformat_chain_spec"""', 'input_keys': "['input1', 'input2']", 'formatters': "{'output1': 'formatter1', 'output2': 'formatter2'}"}), "(chain_id=3, chain_type='reformat_chain_spec', input_keys=\n ['input1', 'input2'], formatters={'output1': 'formatter1', 'output2':\n 'formatter2'})\n", (11103, 11254), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((11295, 11320), 'model.lang_chain_context.LangChainContext', 'LangChainContext', ([], {'llms': '{}'}), '(llms={})\n', (11311, 11320), False, 'from model.lang_chain_context import LangChainContext\n'), ((11694, 11947), 'model.chain_spec.TransformChainSpec', 'TransformChainSpec', ([], {'chain_id': '(4)', 'chain_type': '"""transform_chain_spec"""', 'input_keys': "['x', 'y']", 'output_keys': "['z', 'w']", 'transform_func': '"""\nz = int(inputs[\'x\']) + int(inputs[\'y\'])\nw = int(inputs[\'x\']) - int(inputs[\'y\'])\nreturn {\'z\': z, \'w\': w}"""'}), '(chain_id=4, chain_type=\'transform_chain_spec\',\n input_keys=[\'x\', \'y\'], output_keys=[\'z\', \'w\'], transform_func=\n """\nz = int(inputs[\'x\']) + int(inputs[\'y\'])\nw = int(inputs[\'x\']) - int(inputs[\'y\'])\nreturn {\'z\': z, \'w\': w}"""\n )\n', (11712, 11947), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((11990, 12015), 'model.lang_chain_context.LangChainContext', 'LangChainContext', ([], {'llms': '{}'}), '(llms={})\n', (12006, 12015), False, 'from model.lang_chain_context import LangChainContext\n'), ((12343, 12678), 'model.chain_spec.VectorSearchChainSpec', 'VectorSearchChainSpec', ([], {'chain_id': '(3)', 'chain_type': '"""vector_search_chain_spec"""', 'input_keys': "['input1', 'input2']", 'output_key': '"""output"""', 'embedding_engine': '"""openai"""', 'embedding_params': "{'openai_api_key': 'test'}", 'database': '"""pinecone"""', 'database_params': "{'index': 'test', 'text_key': 'text'}", 'num_results': '(10)', 'query': '"""How does {input}?"""'}), "(chain_id=3, chain_type='vector_search_chain_spec',\n input_keys=['input1', 'input2'], output_key='output', embedding_engine=\n 'openai', embedding_params={'openai_api_key': 'test'}, database=\n 'pinecone', database_params={'index': 'test', 'text_key': 'text'},\n num_results=10, query='How does {input}?')\n", (12364, 12678), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((12815, 12858), 'model.chain_spec.VectorSearchChainSpec.parse_raw', 'VectorSearchChainSpec.parse_raw', (['serialized'], {}), '(serialized)\n', (12846, 12858), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((13108, 13128), 'model.tests.factory.SpecFactoryContext', 'SpecFactoryContext', ([], {}), '()\n', (13126, 13128), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((14436, 14456), 'model.tests.factory.SpecFactoryContext', 'SpecFactoryContext', ([], {}), '()\n', (14454, 14456), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((14472, 14488), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (14483, 14488), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((1010, 1054), 'model.chain_revision.ChainRevision.parse_raw', 'ChainRevision.parse_raw', (['serialized_revision'], {}), '(serialized_revision)\n', (1033, 1054), False, 'from model.chain_revision import ChainRevision\n'), ((1469, 1505), 'langchain.llms.fake.FakeListLLM', 'FakeListLLM', ([], {'responses': "['response1']"}), "(responses=['response1'])\n", (1480, 1505), False, 'from langchain.llms.fake import FakeListLLM\n'), ((2282, 2318), 'langchain.llms.fake.FakeListLLM', 'FakeListLLM', ([], {'responses': "['response1']"}), "(responses=['response1'])\n", (2293, 2318), False, 'from langchain.llms.fake import FakeListLLM\n'), ((4370, 4429), 'langchain.llms.fake.FakeListLLM', 'FakeListLLM', ([], {'responses': "['fake_response1', 'fake_response2']"}), "(responses=['fake_response1', 'fake_response2'])\n", (4381, 4429), False, 'from langchain.llms.fake import FakeListLLM\n'), ((6611, 6652), 'langchain.llms.fake.FakeListLLM', 'FakeListLLM', ([], {'responses': "['fake_response1']"}), "(responses=['fake_response1'])\n", (6622, 6652), False, 'from langchain.llms.fake import FakeListLLM\n'), ((6663, 6704), 'langchain.llms.fake.FakeListLLM', 'FakeListLLM', ([], {'responses': "['fake_response2']"}), "(responses=['fake_response2'])\n", (6674, 6704), False, 'from langchain.llms.fake import FakeListLLM\n'), ((9729, 9773), 'model.chain_revision.ChainRevision.parse_raw', 'ChainRevision.parse_raw', (['serialized_revision'], {}), '(serialized_revision)\n', (9752, 9773), False, 'from model.chain_revision import ChainRevision\n'), ((6158, 6303), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(4)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output"""', 'prompt': '"""prompt"""', 'llm_key': '"""test"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=4, input_keys=['input1', 'input2'], output_key=\n 'output', prompt='prompt', llm_key='test', chain_type='llm_chain_spec')\n", (6170, 6303), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((2974, 3123), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(1)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output1"""', 'prompt': '"""prompt"""', 'llm_key': '"""llm_key"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=1, input_keys=['input1', 'input2'], output_key=\n 'output1', prompt='prompt', llm_key='llm_key', chain_type='llm_chain_spec')\n", (2986, 3123), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((5598, 5743), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(1)', 'input_keys': "['input1', 'input2']", 'output_key': '"""output"""', 'prompt': '"""prompt"""', 'llm_key': '"""test"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=1, input_keys=['input1', 'input2'], output_key=\n 'output', prompt='prompt', llm_key='test', chain_type='llm_chain_spec')\n", (5610, 5743), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((5875, 6020), 'model.chain_spec.LLMChainSpec', 'LLMChainSpec', ([], {'chain_id': '(2)', 'input_keys': "['input3', 'input4']", 'output_key': '"""output"""', 'prompt': '"""prompt"""', 'llm_key': '"""test"""', 'chain_type': '"""llm_chain_spec"""'}), "(chain_id=2, input_keys=['input3', 'input4'], output_key=\n 'output', prompt='prompt', llm_key='test', chain_type='llm_chain_spec')\n", (5887, 6020), False, 'from model.chain_spec import ChainSpec, LLMChainSpec, SequentialChainSpec, CaseChainSpec, APIChainSpec, ReformatChainSpec, TransformChainSpec, VectorSearchChainSpec\n'), ((13182, 13198), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (13193, 13198), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((14542, 14558), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (14553, 14558), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((13388, 13404), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (13399, 13404), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((14740, 14756), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (14751, 14756), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((13255, 13271), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (13266, 13271), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((14615, 14631), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (14626, 14631), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((13326, 13342), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (13337, 13342), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((13344, 13360), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (13355, 13360), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n'), ((14686, 14702), 'model.tests.factory.llm_factory', 'llm_factory', (['ctx'], {}), '(ctx)\n', (14697, 14702), False, 'from model.tests.factory import SpecFactoryContext, llm_factory, sequential_factory, case_factory\n')] |
import openai
import os
import dotenv
from llama_index.agent.openai import OpenAIAgent
from llama_index.llms.azure_openai import AzureOpenAI
from llama_index.core.tools.tool_spec.load_and_search.base import LoadAndSearchToolSpec
from llama_index.tools.google import GoogleSearchToolSpec
from llama_index.tools.weather import OpenWeatherMapToolSpec
from llama_index.embeddings.langchain import LangchainEmbedding
from llama_index.core import ServiceContext, set_global_service_context
from langchain.embeddings import OpenAIEmbeddings
# Get API keys from environment variables
dotenv.load_dotenv()
google_api_key = os.environ.get("GOOGLE_API_KEY")
google_cse_id = os.environ.get("GOOGLE_CSE_ID")
openweather_api_key = os.environ.get("OPENWEATHER_API_KEY")
os.environ["OPENAI_API_KEY"] = os.environ.get("AZURE_API_KEY")
openai.api_type = "azure"
openai.api_base = os.environ.get("AZURE_API_BASE")
openai.api_key = os.environ.get("AZURE_API_KEY")
azure_api_key = os.environ["AZURE_API_KEY"]
azure_api_type = "azure"
azure_api_base = os.environ.get("AZURE_API_BASE")
azure_api_version = os.environ.get("AZURE_API_VERSION")
azure_chatapi_version = os.environ.get("AZURE_CHATAPI_VERSION")
# Check if user set the davinci model flag
LLM_DEPLOYMENT_NAME = "gpt-4"
LLM_MODEL_NAME = "gpt-4"
EMBEDDINGS_DEPLOYMENT_NAME = "text-embedding-ada-002"
openai.api_version = os.environ.get("AZURE_CHATAPI_FUNCTIONS_VERSION")
print("Using gpt-4 2023-07-01-preview model.")
llm = AzureOpenAI(
engine=LLM_DEPLOYMENT_NAME,
model=LLM_MODEL_NAME,
api_key=azure_api_key,
api_base=azure_api_base,
api_type=azure_api_type,
api_version=azure_chatapi_version,
temperature=0.5,
max_tokens=1024,
)
embedding_llm = LangchainEmbedding(
OpenAIEmbeddings(
model=EMBEDDINGS_DEPLOYMENT_NAME,
deployment=EMBEDDINGS_DEPLOYMENT_NAME,
openai_api_key=azure_api_key,
openai_api_base=azure_api_base,
openai_api_type=azure_api_type,
openai_api_version=azure_api_version,
chunk_size=16,
max_retries=3,
),
embed_batch_size=1,
)
service_context = ServiceContext.from_defaults(
llm=llm,
embed_model=embedding_llm,
chunk_size=256,
)
set_global_service_context(service_context)
weather_tool = OpenWeatherMapToolSpec(
key=openweather_api_key,
)
agent = OpenAIAgent.from_tools(
weather_tool.to_tool_list(),
llm=llm,
verbose=True,
)
print("-------------------------------------------------------")
print(agent.chat("what is the current weather like in Hillsboro, Oregon"))
google_tool = GoogleSearchToolSpec(
key=google_api_key,
engine=google_cse_id
)
#Wrap the google search tool as it returns large payloads
tools = LoadAndSearchToolSpec.from_defaults(
google_tool.to_tool_list()[0],
).to_tool_list()
agent = OpenAIAgent.from_tools(
tools,
llm=llm,
embedding_llm=embedding_llm,
verbose=True
)
# agent = OpenAIAgent.from_tools(
# google_tool.to_tool_list(),
# llm=llm,
# verbose=True
# )
print("-------------------------------------------------------")
print(agent.chat("whats the latest news summary about India?"))
print("-------------------------------------------------------")
print(agent.chat('who is Ange Postecoglou, where is he now and what is his philosophy about football?'))
print("-------------------------------------------------------")
print(agent.chat("whats the latest financial news summary?"))
| [
"langchain.embeddings.OpenAIEmbeddings"
] | [((577, 597), 'dotenv.load_dotenv', 'dotenv.load_dotenv', ([], {}), '()\n', (595, 597), False, 'import dotenv\n'), ((615, 647), 'os.environ.get', 'os.environ.get', (['"""GOOGLE_API_KEY"""'], {}), "('GOOGLE_API_KEY')\n", (629, 647), False, 'import os\n'), ((664, 695), 'os.environ.get', 'os.environ.get', (['"""GOOGLE_CSE_ID"""'], {}), "('GOOGLE_CSE_ID')\n", (678, 695), False, 'import os\n'), ((718, 755), 'os.environ.get', 'os.environ.get', (['"""OPENWEATHER_API_KEY"""'], {}), "('OPENWEATHER_API_KEY')\n", (732, 755), False, 'import os\n'), ((788, 819), 'os.environ.get', 'os.environ.get', (['"""AZURE_API_KEY"""'], {}), "('AZURE_API_KEY')\n", (802, 819), False, 'import os\n'), ((864, 896), 'os.environ.get', 'os.environ.get', (['"""AZURE_API_BASE"""'], {}), "('AZURE_API_BASE')\n", (878, 896), False, 'import os\n'), ((914, 945), 'os.environ.get', 'os.environ.get', (['"""AZURE_API_KEY"""'], {}), "('AZURE_API_KEY')\n", (928, 945), False, 'import os\n'), ((1033, 1065), 'os.environ.get', 'os.environ.get', (['"""AZURE_API_BASE"""'], {}), "('AZURE_API_BASE')\n", (1047, 1065), False, 'import os\n'), ((1086, 1121), 'os.environ.get', 'os.environ.get', (['"""AZURE_API_VERSION"""'], {}), "('AZURE_API_VERSION')\n", (1100, 1121), False, 'import os\n'), ((1146, 1185), 'os.environ.get', 'os.environ.get', (['"""AZURE_CHATAPI_VERSION"""'], {}), "('AZURE_CHATAPI_VERSION')\n", (1160, 1185), False, 'import os\n'), ((1360, 1409), 'os.environ.get', 'os.environ.get', (['"""AZURE_CHATAPI_FUNCTIONS_VERSION"""'], {}), "('AZURE_CHATAPI_FUNCTIONS_VERSION')\n", (1374, 1409), False, 'import os\n'), ((1464, 1676), 'llama_index.llms.azure_openai.AzureOpenAI', 'AzureOpenAI', ([], {'engine': 'LLM_DEPLOYMENT_NAME', 'model': 'LLM_MODEL_NAME', 'api_key': 'azure_api_key', 'api_base': 'azure_api_base', 'api_type': 'azure_api_type', 'api_version': 'azure_chatapi_version', 'temperature': '(0.5)', 'max_tokens': '(1024)'}), '(engine=LLM_DEPLOYMENT_NAME, model=LLM_MODEL_NAME, api_key=\n azure_api_key, api_base=azure_api_base, api_type=azure_api_type,\n api_version=azure_chatapi_version, temperature=0.5, max_tokens=1024)\n', (1475, 1676), False, 'from llama_index.llms.azure_openai import AzureOpenAI\n'), ((2113, 2198), 'llama_index.core.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': 'embedding_llm', 'chunk_size': '(256)'}), '(llm=llm, embed_model=embedding_llm, chunk_size=256\n )\n', (2141, 2198), False, 'from llama_index.core import ServiceContext, set_global_service_context\n'), ((2209, 2252), 'llama_index.core.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (2235, 2252), False, 'from llama_index.core import ServiceContext, set_global_service_context\n'), ((2269, 2316), 'llama_index.tools.weather.OpenWeatherMapToolSpec', 'OpenWeatherMapToolSpec', ([], {'key': 'openweather_api_key'}), '(key=openweather_api_key)\n', (2291, 2316), False, 'from llama_index.tools.weather import OpenWeatherMapToolSpec\n'), ((2579, 2641), 'llama_index.tools.google.GoogleSearchToolSpec', 'GoogleSearchToolSpec', ([], {'key': 'google_api_key', 'engine': 'google_cse_id'}), '(key=google_api_key, engine=google_cse_id)\n', (2599, 2641), False, 'from llama_index.tools.google import GoogleSearchToolSpec\n'), ((2817, 2903), 'llama_index.agent.openai.OpenAIAgent.from_tools', 'OpenAIAgent.from_tools', (['tools'], {'llm': 'llm', 'embedding_llm': 'embedding_llm', 'verbose': '(True)'}), '(tools, llm=llm, embedding_llm=embedding_llm, verbose\n =True)\n', (2839, 2903), False, 'from llama_index.agent.openai import OpenAIAgent\n'), ((1745, 2009), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'model': 'EMBEDDINGS_DEPLOYMENT_NAME', 'deployment': 'EMBEDDINGS_DEPLOYMENT_NAME', 'openai_api_key': 'azure_api_key', 'openai_api_base': 'azure_api_base', 'openai_api_type': 'azure_api_type', 'openai_api_version': 'azure_api_version', 'chunk_size': '(16)', 'max_retries': '(3)'}), '(model=EMBEDDINGS_DEPLOYMENT_NAME, deployment=\n EMBEDDINGS_DEPLOYMENT_NAME, openai_api_key=azure_api_key,\n openai_api_base=azure_api_base, openai_api_type=azure_api_type,\n openai_api_version=azure_api_version, chunk_size=16, max_retries=3)\n', (1761, 2009), False, 'from langchain.embeddings import OpenAIEmbeddings\n')] |
"""
.. warning::
Beta Feature!
**Cache** provides an optional caching layer for LLMs.
Cache is useful for two reasons:
- It can save you money by reducing the number of API calls you make to the LLM
provider if you're often requesting the same completion multiple times.
- It can speed up your application by reducing the number of API calls you make
to the LLM provider.
Cache directly competes with Memory. See documentation for Pros and Cons.
**Class hierarchy:**
.. code-block::
BaseCache --> <name>Cache # Examples: InMemoryCache, RedisCache, GPTCache
"""
from __future__ import annotations
import hashlib
import inspect
import json
import logging
import warnings
from datetime import timedelta
from functools import lru_cache
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Tuple,
Type,
Union,
cast,
)
from sqlalchemy import Column, Integer, String, create_engine, select
from sqlalchemy.engine.base import Engine
from sqlalchemy.orm import Session
try:
from sqlalchemy.orm import declarative_base
except ImportError:
from sqlalchemy.ext.declarative import declarative_base
from langchain.embeddings.base import Embeddings
from langchain.llms.base import LLM, get_prompts
from langchain.load.dump import dumps
from langchain.load.load import loads
from langchain.schema import ChatGeneration, Generation
from langchain.schema.cache import RETURN_VAL_TYPE, BaseCache
from langchain.utils import get_from_env
from langchain.vectorstores.redis import Redis as RedisVectorstore
logger = logging.getLogger(__file__)
if TYPE_CHECKING:
import momento
from cassandra.cluster import Session as CassandraSession
def _hash(_input: str) -> str:
"""Use a deterministic hashing approach."""
return hashlib.md5(_input.encode()).hexdigest()
def _dump_generations_to_json(generations: RETURN_VAL_TYPE) -> str:
"""Dump generations to json.
Args:
generations (RETURN_VAL_TYPE): A list of language model generations.
Returns:
str: Json representing a list of generations.
Warning: would not work well with arbitrary subclasses of `Generation`
"""
return json.dumps([generation.dict() for generation in generations])
def _load_generations_from_json(generations_json: str) -> RETURN_VAL_TYPE:
"""Load generations from json.
Args:
generations_json (str): A string of json representing a list of generations.
Raises:
ValueError: Could not decode json string to list of generations.
Returns:
RETURN_VAL_TYPE: A list of generations.
Warning: would not work well with arbitrary subclasses of `Generation`
"""
try:
results = json.loads(generations_json)
return [Generation(**generation_dict) for generation_dict in results]
except json.JSONDecodeError:
raise ValueError(
f"Could not decode json to list of generations: {generations_json}"
)
def _dumps_generations(generations: RETURN_VAL_TYPE) -> str:
"""
Serialization for generic RETURN_VAL_TYPE, i.e. sequence of `Generation`
Args:
generations (RETURN_VAL_TYPE): A list of language model generations.
Returns:
str: a single string representing a list of generations.
This function (+ its counterpart `_loads_generations`) rely on
the dumps/loads pair with Reviver, so are able to deal
with all subclasses of Generation.
Each item in the list can be `dumps`ed to a string,
then we make the whole list of strings into a json-dumped.
"""
return json.dumps([dumps(_item) for _item in generations])
def _loads_generations(generations_str: str) -> Union[RETURN_VAL_TYPE, None]:
"""
Deserialization of a string into a generic RETURN_VAL_TYPE
(i.e. a sequence of `Generation`).
See `_dumps_generations`, the inverse of this function.
Args:
generations_str (str): A string representing a list of generations.
Compatible with the legacy cache-blob format
Does not raise exceptions for malformed entries, just logs a warning
and returns none: the caller should be prepared for such a cache miss.
Returns:
RETURN_VAL_TYPE: A list of generations.
"""
try:
generations = [loads(_item_str) for _item_str in json.loads(generations_str)]
return generations
except (json.JSONDecodeError, TypeError):
# deferring the (soft) handling to after the legacy-format attempt
pass
try:
gen_dicts = json.loads(generations_str)
# not relying on `_load_generations_from_json` (which could disappear):
generations = [Generation(**generation_dict) for generation_dict in gen_dicts]
logger.warning(
f"Legacy 'Generation' cached blob encountered: '{generations_str}'"
)
return generations
except (json.JSONDecodeError, TypeError):
logger.warning(
f"Malformed/unparsable cached blob encountered: '{generations_str}'"
)
return None
class InMemoryCache(BaseCache):
"""Cache that stores things in memory."""
def __init__(self) -> None:
"""Initialize with empty cache."""
self._cache: Dict[Tuple[str, str], RETURN_VAL_TYPE] = {}
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
return self._cache.get((prompt, llm_string), None)
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
self._cache[(prompt, llm_string)] = return_val
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
self._cache = {}
Base = declarative_base()
class FullLLMCache(Base): # type: ignore
"""SQLite table for full LLM Cache (all generations)."""
__tablename__ = "full_llm_cache"
prompt = Column(String, primary_key=True)
llm = Column(String, primary_key=True)
idx = Column(Integer, primary_key=True)
response = Column(String)
class SQLAlchemyCache(BaseCache):
"""Cache that uses SQAlchemy as a backend."""
def __init__(self, engine: Engine, cache_schema: Type[FullLLMCache] = FullLLMCache):
"""Initialize by creating all tables."""
self.engine = engine
self.cache_schema = cache_schema
self.cache_schema.metadata.create_all(self.engine)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
stmt = (
select(self.cache_schema.response)
.where(self.cache_schema.prompt == prompt) # type: ignore
.where(self.cache_schema.llm == llm_string)
.order_by(self.cache_schema.idx)
)
with Session(self.engine) as session:
rows = session.execute(stmt).fetchall()
if rows:
try:
return [loads(row[0]) for row in rows]
except Exception:
logger.warning(
"Retrieving a cache value that could not be deserialized "
"properly. This is likely due to the cache being in an "
"older format. Please recreate your cache to avoid this "
"error."
)
# In a previous life we stored the raw text directly
# in the table, so assume it's in that format.
return [Generation(text=row[0]) for row in rows]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update based on prompt and llm_string."""
items = [
self.cache_schema(prompt=prompt, llm=llm_string, response=dumps(gen), idx=i)
for i, gen in enumerate(return_val)
]
with Session(self.engine) as session, session.begin():
for item in items:
session.merge(item)
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
with Session(self.engine) as session:
session.query(self.cache_schema).delete()
session.commit()
class SQLiteCache(SQLAlchemyCache):
"""Cache that uses SQLite as a backend."""
def __init__(self, database_path: str = ".langchain.db"):
"""Initialize by creating the engine and all tables."""
engine = create_engine(f"sqlite:///{database_path}")
super().__init__(engine)
class RedisCache(BaseCache):
"""Cache that uses Redis as a backend."""
def __init__(self, redis_: Any, *, ttl: Optional[int] = None):
"""
Initialize an instance of RedisCache.
This method initializes an object with Redis caching capabilities.
It takes a `redis_` parameter, which should be an instance of a Redis
client class, allowing the object to interact with a Redis
server for caching purposes.
Parameters:
redis_ (Any): An instance of a Redis client class
(e.g., redis.Redis) used for caching.
This allows the object to communicate with a
Redis server for caching operations.
ttl (int, optional): Time-to-live (TTL) for cached items in seconds.
If provided, it sets the time duration for how long cached
items will remain valid. If not provided, cached items will not
have an automatic expiration.
"""
try:
from redis import Redis
except ImportError:
raise ValueError(
"Could not import redis python package. "
"Please install it with `pip install redis`."
)
if not isinstance(redis_, Redis):
raise ValueError("Please pass in Redis object.")
self.redis = redis_
self.ttl = ttl
def _key(self, prompt: str, llm_string: str) -> str:
"""Compute key from prompt and llm_string"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
generations = []
# Read from a Redis HASH
results = self.redis.hgetall(self._key(prompt, llm_string))
if results:
for _, text in results.items():
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisCache does not"
" support caching ChatModel outputs."
)
return
# Write to a Redis HASH
key = self._key(prompt, llm_string)
with self.redis.pipeline() as pipe:
pipe.hset(
key,
mapping={
str(idx): generation.text
for idx, generation in enumerate(return_val)
},
)
if self.ttl is not None:
pipe.expire(key, self.ttl)
pipe.execute()
def clear(self, **kwargs: Any) -> None:
"""Clear cache. If `asynchronous` is True, flush asynchronously."""
asynchronous = kwargs.get("asynchronous", False)
self.redis.flushdb(asynchronous=asynchronous, **kwargs)
class RedisSemanticCache(BaseCache):
"""Cache that uses Redis as a vector-store backend."""
# TODO - implement a TTL policy in Redis
DEFAULT_SCHEMA = {
"content_key": "prompt",
"text": [
{"name": "prompt"},
],
"extra": [{"name": "return_val"}, {"name": "llm_string"}],
}
def __init__(
self, redis_url: str, embedding: Embeddings, score_threshold: float = 0.2
):
"""Initialize by passing in the `init` GPTCache func
Args:
redis_url (str): URL to connect to Redis.
embedding (Embedding): Embedding provider for semantic encoding and search.
score_threshold (float, 0.2):
Example:
.. code-block:: python
import langchain
from langchain.cache import RedisSemanticCache
from langchain.embeddings import OpenAIEmbeddings
langchain.llm_cache = RedisSemanticCache(
redis_url="redis://localhost:6379",
embedding=OpenAIEmbeddings()
)
"""
self._cache_dict: Dict[str, RedisVectorstore] = {}
self.redis_url = redis_url
self.embedding = embedding
self.score_threshold = score_threshold
def _index_name(self, llm_string: str) -> str:
hashed_index = _hash(llm_string)
return f"cache:{hashed_index}"
def _get_llm_cache(self, llm_string: str) -> RedisVectorstore:
index_name = self._index_name(llm_string)
# return vectorstore client for the specific llm string
if index_name in self._cache_dict:
return self._cache_dict[index_name]
# create new vectorstore client for the specific llm string
try:
self._cache_dict[index_name] = RedisVectorstore.from_existing_index(
embedding=self.embedding,
index_name=index_name,
redis_url=self.redis_url,
schema=cast(Dict, self.DEFAULT_SCHEMA),
)
except ValueError:
redis = RedisVectorstore(
embedding=self.embedding,
index_name=index_name,
redis_url=self.redis_url,
index_schema=cast(Dict, self.DEFAULT_SCHEMA),
)
_embedding = self.embedding.embed_query(text="test")
redis._create_index(dim=len(_embedding))
self._cache_dict[index_name] = redis
return self._cache_dict[index_name]
def clear(self, **kwargs: Any) -> None:
"""Clear semantic cache for a given llm_string."""
index_name = self._index_name(kwargs["llm_string"])
if index_name in self._cache_dict:
self._cache_dict[index_name].drop_index(
index_name=index_name, delete_documents=True, redis_url=self.redis_url
)
del self._cache_dict[index_name]
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
llm_cache = self._get_llm_cache(llm_string)
generations: List = []
# Read from a Hash
results = llm_cache.similarity_search(
query=prompt,
k=1,
distance_threshold=self.score_threshold,
)
if results:
for document in results:
generations.extend(
_load_generations_from_json(document.metadata["return_val"])
)
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisSemanticCache only supports caching of "
f"normal LLM generations, got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisSentimentCache does not"
" support caching ChatModel outputs."
)
return
llm_cache = self._get_llm_cache(llm_string)
_dump_generations_to_json([g for g in return_val])
metadata = {
"llm_string": llm_string,
"prompt": prompt,
"return_val": _dump_generations_to_json([g for g in return_val]),
}
llm_cache.add_texts(texts=[prompt], metadatas=[metadata])
class GPTCache(BaseCache):
"""Cache that uses GPTCache as a backend."""
def __init__(
self,
init_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = None,
):
"""Initialize by passing in init function (default: `None`).
Args:
init_func (Optional[Callable[[Any], None]]): init `GPTCache` function
(default: `None`)
Example:
.. code-block:: python
# Initialize GPTCache with a custom init function
import gptcache
from gptcache.processor.pre import get_prompt
from gptcache.manager.factory import get_data_manager
# Avoid multiple caches using the same file,
causing different llm model caches to affect each other
def init_gptcache(cache_obj: gptcache.Cache, llm str):
cache_obj.init(
pre_embedding_func=get_prompt,
data_manager=manager_factory(
manager="map",
data_dir=f"map_cache_{llm}"
),
)
langchain.llm_cache = GPTCache(init_gptcache)
"""
try:
import gptcache # noqa: F401
except ImportError:
raise ImportError(
"Could not import gptcache python package. "
"Please install it with `pip install gptcache`."
)
self.init_gptcache_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = init_func
self.gptcache_dict: Dict[str, Any] = {}
def _new_gptcache(self, llm_string: str) -> Any:
"""New gptcache object"""
from gptcache import Cache
from gptcache.manager.factory import get_data_manager
from gptcache.processor.pre import get_prompt
_gptcache = Cache()
if self.init_gptcache_func is not None:
sig = inspect.signature(self.init_gptcache_func)
if len(sig.parameters) == 2:
self.init_gptcache_func(_gptcache, llm_string) # type: ignore[call-arg]
else:
self.init_gptcache_func(_gptcache) # type: ignore[call-arg]
else:
_gptcache.init(
pre_embedding_func=get_prompt,
data_manager=get_data_manager(data_path=llm_string),
)
self.gptcache_dict[llm_string] = _gptcache
return _gptcache
def _get_gptcache(self, llm_string: str) -> Any:
"""Get a cache object.
When the corresponding llm model cache does not exist, it will be created."""
_gptcache = self.gptcache_dict.get(llm_string, None)
if not _gptcache:
_gptcache = self._new_gptcache(llm_string)
return _gptcache
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up the cache data.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then retrieve the data from the cache based on the `prompt`.
"""
from gptcache.adapter.api import get
_gptcache = self._get_gptcache(llm_string)
res = get(prompt, cache_obj=_gptcache)
if res:
return [
Generation(**generation_dict) for generation_dict in json.loads(res)
]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then store the `prompt` and `return_val` in the cache object.
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"GPTCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
from gptcache.adapter.api import put
_gptcache = self._get_gptcache(llm_string)
handled_data = json.dumps([generation.dict() for generation in return_val])
put(prompt, handled_data, cache_obj=_gptcache)
return None
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
from gptcache import Cache
for gptcache_instance in self.gptcache_dict.values():
gptcache_instance = cast(Cache, gptcache_instance)
gptcache_instance.flush()
self.gptcache_dict.clear()
def _ensure_cache_exists(cache_client: momento.CacheClient, cache_name: str) -> None:
"""Create cache if it doesn't exist.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
from momento.responses import CreateCache
create_cache_response = cache_client.create_cache(cache_name)
if isinstance(create_cache_response, CreateCache.Success) or isinstance(
create_cache_response, CreateCache.CacheAlreadyExists
):
return None
elif isinstance(create_cache_response, CreateCache.Error):
raise create_cache_response.inner_exception
else:
raise Exception(f"Unexpected response cache creation: {create_cache_response}")
def _validate_ttl(ttl: Optional[timedelta]) -> None:
if ttl is not None and ttl <= timedelta(seconds=0):
raise ValueError(f"ttl must be positive but was {ttl}.")
class MomentoCache(BaseCache):
"""Cache that uses Momento as a backend. See https://gomomento.com/"""
def __init__(
self,
cache_client: momento.CacheClient,
cache_name: str,
*,
ttl: Optional[timedelta] = None,
ensure_cache_exists: bool = True,
):
"""Instantiate a prompt cache using Momento as a backend.
Note: to instantiate the cache client passed to MomentoCache,
you must have a Momento account. See https://gomomento.com/.
Args:
cache_client (CacheClient): The Momento cache client.
cache_name (str): The name of the cache to use to store the data.
ttl (Optional[timedelta], optional): The time to live for the cache items.
Defaults to None, ie use the client default TTL.
ensure_cache_exists (bool, optional): Create the cache if it doesn't
exist. Defaults to True.
Raises:
ImportError: Momento python package is not installed.
TypeError: cache_client is not of type momento.CacheClientObject
ValueError: ttl is non-null and non-negative
"""
try:
from momento import CacheClient
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if not isinstance(cache_client, CacheClient):
raise TypeError("cache_client must be a momento.CacheClient object.")
_validate_ttl(ttl)
if ensure_cache_exists:
_ensure_cache_exists(cache_client, cache_name)
self.cache_client = cache_client
self.cache_name = cache_name
self.ttl = ttl
@classmethod
def from_client_params(
cls,
cache_name: str,
ttl: timedelta,
*,
configuration: Optional[momento.config.Configuration] = None,
auth_token: Optional[str] = None,
**kwargs: Any,
) -> MomentoCache:
"""Construct cache from CacheClient parameters."""
try:
from momento import CacheClient, Configurations, CredentialProvider
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if configuration is None:
configuration = Configurations.Laptop.v1()
auth_token = auth_token or get_from_env("auth_token", "MOMENTO_AUTH_TOKEN")
credentials = CredentialProvider.from_string(auth_token)
cache_client = CacheClient(configuration, credentials, default_ttl=ttl)
return cls(cache_client, cache_name, ttl=ttl, **kwargs)
def __key(self, prompt: str, llm_string: str) -> str:
"""Compute cache key from prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Returns:
str: The cache key.
"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Lookup llm generations in cache by prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Raises:
SdkException: Momento service or network error
Returns:
Optional[RETURN_VAL_TYPE]: A list of language model generations.
"""
from momento.responses import CacheGet
generations: RETURN_VAL_TYPE = []
get_response = self.cache_client.get(
self.cache_name, self.__key(prompt, llm_string)
)
if isinstance(get_response, CacheGet.Hit):
value = get_response.value_string
generations = _load_generations_from_json(value)
elif isinstance(get_response, CacheGet.Miss):
pass
elif isinstance(get_response, CacheGet.Error):
raise get_response.inner_exception
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Store llm generations in cache.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model string.
return_val (RETURN_VAL_TYPE): A list of language model generations.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"Momento only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
key = self.__key(prompt, llm_string)
value = _dump_generations_to_json(return_val)
set_response = self.cache_client.set(self.cache_name, key, value, self.ttl)
from momento.responses import CacheSet
if isinstance(set_response, CacheSet.Success):
pass
elif isinstance(set_response, CacheSet.Error):
raise set_response.inner_exception
else:
raise Exception(f"Unexpected response: {set_response}")
def clear(self, **kwargs: Any) -> None:
"""Clear the cache.
Raises:
SdkException: Momento service or network error
"""
from momento.responses import CacheFlush
flush_response = self.cache_client.flush_cache(self.cache_name)
if isinstance(flush_response, CacheFlush.Success):
pass
elif isinstance(flush_response, CacheFlush.Error):
raise flush_response.inner_exception
CASSANDRA_CACHE_DEFAULT_TABLE_NAME = "langchain_llm_cache"
CASSANDRA_CACHE_DEFAULT_TTL_SECONDS = None
class CassandraCache(BaseCache):
"""
Cache that uses Cassandra / Astra DB as a backend.
It uses a single Cassandra table.
The lookup keys (which get to form the primary key) are:
- prompt, a string
- llm_string, a deterministic str representation of the model parameters.
(needed to prevent collisions same-prompt-different-model collisions)
"""
def __init__(
self,
session: Optional[CassandraSession] = None,
keyspace: Optional[str] = None,
table_name: str = CASSANDRA_CACHE_DEFAULT_TABLE_NAME,
ttl_seconds: Optional[int] = CASSANDRA_CACHE_DEFAULT_TTL_SECONDS,
skip_provisioning: bool = False,
):
"""
Initialize with a ready session and a keyspace name.
Args:
session (cassandra.cluster.Session): an open Cassandra session
keyspace (str): the keyspace to use for storing the cache
table_name (str): name of the Cassandra table to use as cache
ttl_seconds (optional int): time-to-live for cache entries
(default: None, i.e. forever)
"""
try:
from cassio.table import ElasticCassandraTable
except (ImportError, ModuleNotFoundError):
raise ValueError(
"Could not import cassio python package. "
"Please install it with `pip install cassio`."
)
self.session = session
self.keyspace = keyspace
self.table_name = table_name
self.ttl_seconds = ttl_seconds
self.kv_cache = ElasticCassandraTable(
session=self.session,
keyspace=self.keyspace,
table=self.table_name,
keys=["llm_string", "prompt"],
primary_key_type=["TEXT", "TEXT"],
ttl_seconds=self.ttl_seconds,
skip_provisioning=skip_provisioning,
)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
item = self.kv_cache.get(
llm_string=_hash(llm_string),
prompt=_hash(prompt),
)
if item is not None:
generations = _loads_generations(item["body_blob"])
# this protects against malformed cached items:
if generations is not None:
return generations
else:
return None
else:
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
blob = _dumps_generations(return_val)
self.kv_cache.put(
llm_string=_hash(llm_string),
prompt=_hash(prompt),
body_blob=blob,
)
def delete_through_llm(
self, prompt: str, llm: LLM, stop: Optional[List[str]] = None
) -> None:
"""
A wrapper around `delete` with the LLM being passed.
In case the llm(prompt) calls have a `stop` param, you should pass it here
"""
llm_string = get_prompts(
{**llm.dict(), **{"stop": stop}},
[],
)[1]
return self.delete(prompt, llm_string=llm_string)
def delete(self, prompt: str, llm_string: str) -> None:
"""Evict from cache if there's an entry."""
return self.kv_cache.delete(
llm_string=_hash(llm_string),
prompt=_hash(prompt),
)
def clear(self, **kwargs: Any) -> None:
"""Clear cache. This is for all LLMs at once."""
self.kv_cache.clear()
CASSANDRA_SEMANTIC_CACHE_DEFAULT_DISTANCE_METRIC = "dot"
CASSANDRA_SEMANTIC_CACHE_DEFAULT_SCORE_THRESHOLD = 0.85
CASSANDRA_SEMANTIC_CACHE_DEFAULT_TABLE_NAME = "langchain_llm_semantic_cache"
CASSANDRA_SEMANTIC_CACHE_DEFAULT_TTL_SECONDS = None
CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE = 16
class CassandraSemanticCache(BaseCache):
"""
Cache that uses Cassandra as a vector-store backend for semantic
(i.e. similarity-based) lookup.
It uses a single (vector) Cassandra table and stores, in principle,
cached values from several LLMs, so the LLM's llm_string is part
of the rows' primary keys.
The similarity is based on one of several distance metrics (default: "dot").
If choosing another metric, the default threshold is to be re-tuned accordingly.
"""
def __init__(
self,
session: Optional[CassandraSession],
keyspace: Optional[str],
embedding: Embeddings,
table_name: str = CASSANDRA_SEMANTIC_CACHE_DEFAULT_TABLE_NAME,
distance_metric: str = CASSANDRA_SEMANTIC_CACHE_DEFAULT_DISTANCE_METRIC,
score_threshold: float = CASSANDRA_SEMANTIC_CACHE_DEFAULT_SCORE_THRESHOLD,
ttl_seconds: Optional[int] = CASSANDRA_SEMANTIC_CACHE_DEFAULT_TTL_SECONDS,
skip_provisioning: bool = False,
):
"""
Initialize the cache with all relevant parameters.
Args:
session (cassandra.cluster.Session): an open Cassandra session
keyspace (str): the keyspace to use for storing the cache
embedding (Embedding): Embedding provider for semantic
encoding and search.
table_name (str): name of the Cassandra (vector) table
to use as cache
distance_metric (str, 'dot'): which measure to adopt for
similarity searches
score_threshold (optional float): numeric value to use as
cutoff for the similarity searches
ttl_seconds (optional int): time-to-live for cache entries
(default: None, i.e. forever)
The default score threshold is tuned to the default metric.
Tune it carefully yourself if switching to another distance metric.
"""
try:
from cassio.table import MetadataVectorCassandraTable
except (ImportError, ModuleNotFoundError):
raise ValueError(
"Could not import cassio python package. "
"Please install it with `pip install cassio`."
)
self.session = session
self.keyspace = keyspace
self.embedding = embedding
self.table_name = table_name
self.distance_metric = distance_metric
self.score_threshold = score_threshold
self.ttl_seconds = ttl_seconds
# The contract for this class has separate lookup and update:
# in order to spare some embedding calculations we cache them between
# the two calls.
# Note: each instance of this class has its own `_get_embedding` with
# its own lru.
@lru_cache(maxsize=CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE)
def _cache_embedding(text: str) -> List[float]:
return self.embedding.embed_query(text=text)
self._get_embedding = _cache_embedding
self.embedding_dimension = self._get_embedding_dimension()
self.table = MetadataVectorCassandraTable(
session=self.session,
keyspace=self.keyspace,
table=self.table_name,
primary_key_type=["TEXT"],
vector_dimension=self.embedding_dimension,
ttl_seconds=self.ttl_seconds,
metadata_indexing=("allow", {"_llm_string_hash"}),
skip_provisioning=skip_provisioning,
)
def _get_embedding_dimension(self) -> int:
return len(self._get_embedding(text="This is a sample sentence."))
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
embedding_vector = self._get_embedding(text=prompt)
llm_string_hash = _hash(llm_string)
body = _dumps_generations(return_val)
metadata = {
"_prompt": prompt,
"_llm_string_hash": llm_string_hash,
}
row_id = f"{_hash(prompt)}-{llm_string_hash}"
#
self.table.put(
body_blob=body,
vector=embedding_vector,
row_id=row_id,
metadata=metadata,
)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
hit_with_id = self.lookup_with_id(prompt, llm_string)
if hit_with_id is not None:
return hit_with_id[1]
else:
return None
def lookup_with_id(
self, prompt: str, llm_string: str
) -> Optional[Tuple[str, RETURN_VAL_TYPE]]:
"""
Look up based on prompt and llm_string.
If there are hits, return (document_id, cached_entry)
"""
prompt_embedding: List[float] = self._get_embedding(text=prompt)
hits = list(
self.table.metric_ann_search(
vector=prompt_embedding,
metadata={"_llm_string_hash": _hash(llm_string)},
n=1,
metric=self.distance_metric,
metric_threshold=self.score_threshold,
)
)
if hits:
hit = hits[0]
generations = _loads_generations(hit["body_blob"])
if generations is not None:
# this protects against malformed cached items:
return (
hit["row_id"],
generations,
)
else:
return None
else:
return None
def lookup_with_id_through_llm(
self, prompt: str, llm: LLM, stop: Optional[List[str]] = None
) -> Optional[Tuple[str, RETURN_VAL_TYPE]]:
llm_string = get_prompts(
{**llm.dict(), **{"stop": stop}},
[],
)[1]
return self.lookup_with_id(prompt, llm_string=llm_string)
def delete_by_document_id(self, document_id: str) -> None:
"""
Given this is a "similarity search" cache, an invalidation pattern
that makes sense is first a lookup to get an ID, and then deleting
with that ID. This is for the second step.
"""
self.table.delete(row_id=document_id)
def clear(self, **kwargs: Any) -> None:
"""Clear the *whole* semantic cache."""
self.table.clear()
| [
"langchain.schema.Generation",
"langchain.utils.get_from_env",
"langchain.load.load.loads",
"langchain.load.dump.dumps"
] | [((1586, 1613), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (1603, 1613), False, 'import logging\n'), ((5793, 5811), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (5809, 5811), False, 'from sqlalchemy.ext.declarative import declarative_base\n'), ((5968, 6000), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (5974, 6000), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((6011, 6043), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (6017, 6043), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((6054, 6087), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (6060, 6087), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((6103, 6117), 'sqlalchemy.Column', 'Column', (['String'], {}), '(String)\n', (6109, 6117), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((2730, 2758), 'json.loads', 'json.loads', (['generations_json'], {}), '(generations_json)\n', (2740, 2758), False, 'import json\n'), ((4550, 4577), 'json.loads', 'json.loads', (['generations_str'], {}), '(generations_str)\n', (4560, 4577), False, 'import json\n'), ((8521, 8564), 'sqlalchemy.create_engine', 'create_engine', (['f"""sqlite:///{database_path}"""'], {}), "(f'sqlite:///{database_path}')\n", (8534, 8564), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((18425, 18432), 'gptcache.Cache', 'Cache', ([], {}), '()\n', (18430, 18432), False, 'from gptcache import Cache\n'), ((19758, 19790), 'gptcache.adapter.api.get', 'get', (['prompt'], {'cache_obj': '_gptcache'}), '(prompt, cache_obj=_gptcache)\n', (19761, 19790), False, 'from gptcache.adapter.api import get\n'), ((20677, 20723), 'gptcache.adapter.api.put', 'put', (['prompt', 'handled_data'], {'cache_obj': '_gptcache'}), '(prompt, handled_data, cache_obj=_gptcache)\n', (20680, 20723), False, 'from gptcache.adapter.api import put\n'), ((24572, 24614), 'momento.CredentialProvider.from_string', 'CredentialProvider.from_string', (['auth_token'], {}), '(auth_token)\n', (24602, 24614), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((24638, 24694), 'momento.CacheClient', 'CacheClient', (['configuration', 'credentials'], {'default_ttl': 'ttl'}), '(configuration, credentials, default_ttl=ttl)\n', (24649, 24694), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((29638, 29876), 'cassio.table.ElasticCassandraTable', 'ElasticCassandraTable', ([], {'session': 'self.session', 'keyspace': 'self.keyspace', 'table': 'self.table_name', 'keys': "['llm_string', 'prompt']", 'primary_key_type': "['TEXT', 'TEXT']", 'ttl_seconds': 'self.ttl_seconds', 'skip_provisioning': 'skip_provisioning'}), "(session=self.session, keyspace=self.keyspace, table=\n self.table_name, keys=['llm_string', 'prompt'], primary_key_type=[\n 'TEXT', 'TEXT'], ttl_seconds=self.ttl_seconds, skip_provisioning=\n skip_provisioning)\n", (29659, 29876), False, 'from cassio.table import ElasticCassandraTable\n'), ((34766, 34830), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': 'CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE'}), '(maxsize=CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE)\n', (34775, 34830), False, 'from functools import lru_cache\n'), ((35081, 35380), 'cassio.table.MetadataVectorCassandraTable', 'MetadataVectorCassandraTable', ([], {'session': 'self.session', 'keyspace': 'self.keyspace', 'table': 'self.table_name', 'primary_key_type': "['TEXT']", 'vector_dimension': 'self.embedding_dimension', 'ttl_seconds': 'self.ttl_seconds', 'metadata_indexing': "('allow', {'_llm_string_hash'})", 'skip_provisioning': 'skip_provisioning'}), "(session=self.session, keyspace=self.keyspace,\n table=self.table_name, primary_key_type=['TEXT'], vector_dimension=self\n .embedding_dimension, ttl_seconds=self.ttl_seconds, metadata_indexing=(\n 'allow', {'_llm_string_hash'}), skip_provisioning=skip_provisioning)\n", (35109, 35380), False, 'from cassio.table import MetadataVectorCassandraTable\n'), ((2775, 2804), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (2785, 2804), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((3618, 3630), 'langchain.load.dump.dumps', 'dumps', (['_item'], {}), '(_item)\n', (3623, 3630), False, 'from langchain.load.dump import dumps\n'), ((4296, 4312), 'langchain.load.load.loads', 'loads', (['_item_str'], {}), '(_item_str)\n', (4301, 4312), False, 'from langchain.load.load import loads\n'), ((4681, 4710), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (4691, 4710), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((6867, 6887), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6874, 6887), False, 'from sqlalchemy.orm import Session\n'), ((7974, 7994), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (7981, 7994), False, 'from sqlalchemy.orm import Session\n'), ((8176, 8196), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (8183, 8196), False, 'from sqlalchemy.orm import Session\n'), ((18499, 18541), 'inspect.signature', 'inspect.signature', (['self.init_gptcache_func'], {}), '(self.init_gptcache_func)\n', (18516, 18541), False, 'import inspect\n'), ((20946, 20976), 'typing.cast', 'cast', (['Cache', 'gptcache_instance'], {}), '(Cache, gptcache_instance)\n', (20950, 20976), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, cast\n'), ((21876, 21896), 'datetime.timedelta', 'timedelta', ([], {'seconds': '(0)'}), '(seconds=0)\n', (21885, 21896), False, 'from datetime import timedelta\n'), ((24439, 24465), 'momento.Configurations.Laptop.v1', 'Configurations.Laptop.v1', ([], {}), '()\n', (24463, 24465), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((24501, 24549), 'langchain.utils.get_from_env', 'get_from_env', (['"""auth_token"""', '"""MOMENTO_AUTH_TOKEN"""'], {}), "('auth_token', 'MOMENTO_AUTH_TOKEN')\n", (24513, 24549), False, 'from langchain.utils import get_from_env\n'), ((4330, 4357), 'json.loads', 'json.loads', (['generations_str'], {}), '(generations_str)\n', (4340, 4357), False, 'import json\n'), ((11054, 11173), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs.'\n )\n", (11067, 11173), False, 'import warnings\n'), ((15954, 16082), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs.'\n )\n", (15967, 16082), False, 'import warnings\n'), ((19844, 19873), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (19854, 19873), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((7884, 7894), 'langchain.load.dump.dumps', 'dumps', (['gen'], {}), '(gen)\n', (7889, 7894), False, 'from langchain.load.dump import dumps\n'), ((10513, 10534), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (10523, 10534), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((13908, 13939), 'typing.cast', 'cast', (['Dict', 'self.DEFAULT_SCHEMA'], {}), '(Dict, self.DEFAULT_SCHEMA)\n', (13912, 13939), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, cast\n'), ((18885, 18923), 'gptcache.manager.factory.get_data_manager', 'get_data_manager', ([], {'data_path': 'llm_string'}), '(data_path=llm_string)\n', (18901, 18923), False, 'from gptcache.manager.factory import get_data_manager\n'), ((19897, 19912), 'json.loads', 'json.loads', (['res'], {}), '(res)\n', (19907, 19912), False, 'import json\n'), ((7022, 7035), 'langchain.load.load.loads', 'loads', (['row[0]'], {}), '(row[0])\n', (7027, 7035), False, 'from langchain.load.load import loads\n'), ((14172, 14203), 'typing.cast', 'cast', (['Dict', 'self.DEFAULT_SCHEMA'], {}), '(Dict, self.DEFAULT_SCHEMA)\n', (14176, 14203), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, cast\n'), ((7592, 7615), 'langchain.schema.Generation', 'Generation', ([], {'text': 'row[0]'}), '(text=row[0])\n', (7602, 7615), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((6637, 6671), 'sqlalchemy.select', 'select', (['self.cache_schema.response'], {}), '(self.cache_schema.response)\n', (6643, 6671), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n')] |
"""
.. warning::
Beta Feature!
**Cache** provides an optional caching layer for LLMs.
Cache is useful for two reasons:
- It can save you money by reducing the number of API calls you make to the LLM
provider if you're often requesting the same completion multiple times.
- It can speed up your application by reducing the number of API calls you make
to the LLM provider.
Cache directly competes with Memory. See documentation for Pros and Cons.
**Class hierarchy:**
.. code-block::
BaseCache --> <name>Cache # Examples: InMemoryCache, RedisCache, GPTCache
"""
from __future__ import annotations
import hashlib
import inspect
import json
import logging
import warnings
from datetime import timedelta
from functools import lru_cache
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Tuple,
Type,
Union,
cast,
)
from sqlalchemy import Column, Integer, String, create_engine, select
from sqlalchemy.engine.base import Engine
from sqlalchemy.orm import Session
try:
from sqlalchemy.orm import declarative_base
except ImportError:
from sqlalchemy.ext.declarative import declarative_base
from langchain.embeddings.base import Embeddings
from langchain.llms.base import LLM, get_prompts
from langchain.load.dump import dumps
from langchain.load.load import loads
from langchain.schema import ChatGeneration, Generation
from langchain.schema.cache import RETURN_VAL_TYPE, BaseCache
from langchain.utils import get_from_env
from langchain.vectorstores.redis import Redis as RedisVectorstore
logger = logging.getLogger(__file__)
if TYPE_CHECKING:
import momento
from cassandra.cluster import Session as CassandraSession
def _hash(_input: str) -> str:
"""Use a deterministic hashing approach."""
return hashlib.md5(_input.encode()).hexdigest()
def _dump_generations_to_json(generations: RETURN_VAL_TYPE) -> str:
"""Dump generations to json.
Args:
generations (RETURN_VAL_TYPE): A list of language model generations.
Returns:
str: Json representing a list of generations.
Warning: would not work well with arbitrary subclasses of `Generation`
"""
return json.dumps([generation.dict() for generation in generations])
def _load_generations_from_json(generations_json: str) -> RETURN_VAL_TYPE:
"""Load generations from json.
Args:
generations_json (str): A string of json representing a list of generations.
Raises:
ValueError: Could not decode json string to list of generations.
Returns:
RETURN_VAL_TYPE: A list of generations.
Warning: would not work well with arbitrary subclasses of `Generation`
"""
try:
results = json.loads(generations_json)
return [Generation(**generation_dict) for generation_dict in results]
except json.JSONDecodeError:
raise ValueError(
f"Could not decode json to list of generations: {generations_json}"
)
def _dumps_generations(generations: RETURN_VAL_TYPE) -> str:
"""
Serialization for generic RETURN_VAL_TYPE, i.e. sequence of `Generation`
Args:
generations (RETURN_VAL_TYPE): A list of language model generations.
Returns:
str: a single string representing a list of generations.
This function (+ its counterpart `_loads_generations`) rely on
the dumps/loads pair with Reviver, so are able to deal
with all subclasses of Generation.
Each item in the list can be `dumps`ed to a string,
then we make the whole list of strings into a json-dumped.
"""
return json.dumps([dumps(_item) for _item in generations])
def _loads_generations(generations_str: str) -> Union[RETURN_VAL_TYPE, None]:
"""
Deserialization of a string into a generic RETURN_VAL_TYPE
(i.e. a sequence of `Generation`).
See `_dumps_generations`, the inverse of this function.
Args:
generations_str (str): A string representing a list of generations.
Compatible with the legacy cache-blob format
Does not raise exceptions for malformed entries, just logs a warning
and returns none: the caller should be prepared for such a cache miss.
Returns:
RETURN_VAL_TYPE: A list of generations.
"""
try:
generations = [loads(_item_str) for _item_str in json.loads(generations_str)]
return generations
except (json.JSONDecodeError, TypeError):
# deferring the (soft) handling to after the legacy-format attempt
pass
try:
gen_dicts = json.loads(generations_str)
# not relying on `_load_generations_from_json` (which could disappear):
generations = [Generation(**generation_dict) for generation_dict in gen_dicts]
logger.warning(
f"Legacy 'Generation' cached blob encountered: '{generations_str}'"
)
return generations
except (json.JSONDecodeError, TypeError):
logger.warning(
f"Malformed/unparsable cached blob encountered: '{generations_str}'"
)
return None
class InMemoryCache(BaseCache):
"""Cache that stores things in memory."""
def __init__(self) -> None:
"""Initialize with empty cache."""
self._cache: Dict[Tuple[str, str], RETURN_VAL_TYPE] = {}
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
return self._cache.get((prompt, llm_string), None)
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
self._cache[(prompt, llm_string)] = return_val
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
self._cache = {}
Base = declarative_base()
class FullLLMCache(Base): # type: ignore
"""SQLite table for full LLM Cache (all generations)."""
__tablename__ = "full_llm_cache"
prompt = Column(String, primary_key=True)
llm = Column(String, primary_key=True)
idx = Column(Integer, primary_key=True)
response = Column(String)
class SQLAlchemyCache(BaseCache):
"""Cache that uses SQAlchemy as a backend."""
def __init__(self, engine: Engine, cache_schema: Type[FullLLMCache] = FullLLMCache):
"""Initialize by creating all tables."""
self.engine = engine
self.cache_schema = cache_schema
self.cache_schema.metadata.create_all(self.engine)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
stmt = (
select(self.cache_schema.response)
.where(self.cache_schema.prompt == prompt) # type: ignore
.where(self.cache_schema.llm == llm_string)
.order_by(self.cache_schema.idx)
)
with Session(self.engine) as session:
rows = session.execute(stmt).fetchall()
if rows:
try:
return [loads(row[0]) for row in rows]
except Exception:
logger.warning(
"Retrieving a cache value that could not be deserialized "
"properly. This is likely due to the cache being in an "
"older format. Please recreate your cache to avoid this "
"error."
)
# In a previous life we stored the raw text directly
# in the table, so assume it's in that format.
return [Generation(text=row[0]) for row in rows]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update based on prompt and llm_string."""
items = [
self.cache_schema(prompt=prompt, llm=llm_string, response=dumps(gen), idx=i)
for i, gen in enumerate(return_val)
]
with Session(self.engine) as session, session.begin():
for item in items:
session.merge(item)
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
with Session(self.engine) as session:
session.query(self.cache_schema).delete()
session.commit()
class SQLiteCache(SQLAlchemyCache):
"""Cache that uses SQLite as a backend."""
def __init__(self, database_path: str = ".langchain.db"):
"""Initialize by creating the engine and all tables."""
engine = create_engine(f"sqlite:///{database_path}")
super().__init__(engine)
class RedisCache(BaseCache):
"""Cache that uses Redis as a backend."""
def __init__(self, redis_: Any, *, ttl: Optional[int] = None):
"""
Initialize an instance of RedisCache.
This method initializes an object with Redis caching capabilities.
It takes a `redis_` parameter, which should be an instance of a Redis
client class, allowing the object to interact with a Redis
server for caching purposes.
Parameters:
redis_ (Any): An instance of a Redis client class
(e.g., redis.Redis) used for caching.
This allows the object to communicate with a
Redis server for caching operations.
ttl (int, optional): Time-to-live (TTL) for cached items in seconds.
If provided, it sets the time duration for how long cached
items will remain valid. If not provided, cached items will not
have an automatic expiration.
"""
try:
from redis import Redis
except ImportError:
raise ValueError(
"Could not import redis python package. "
"Please install it with `pip install redis`."
)
if not isinstance(redis_, Redis):
raise ValueError("Please pass in Redis object.")
self.redis = redis_
self.ttl = ttl
def _key(self, prompt: str, llm_string: str) -> str:
"""Compute key from prompt and llm_string"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
generations = []
# Read from a Redis HASH
results = self.redis.hgetall(self._key(prompt, llm_string))
if results:
for _, text in results.items():
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisCache does not"
" support caching ChatModel outputs."
)
return
# Write to a Redis HASH
key = self._key(prompt, llm_string)
with self.redis.pipeline() as pipe:
pipe.hset(
key,
mapping={
str(idx): generation.text
for idx, generation in enumerate(return_val)
},
)
if self.ttl is not None:
pipe.expire(key, self.ttl)
pipe.execute()
def clear(self, **kwargs: Any) -> None:
"""Clear cache. If `asynchronous` is True, flush asynchronously."""
asynchronous = kwargs.get("asynchronous", False)
self.redis.flushdb(asynchronous=asynchronous, **kwargs)
class RedisSemanticCache(BaseCache):
"""Cache that uses Redis as a vector-store backend."""
# TODO - implement a TTL policy in Redis
DEFAULT_SCHEMA = {
"content_key": "prompt",
"text": [
{"name": "prompt"},
],
"extra": [{"name": "return_val"}, {"name": "llm_string"}],
}
def __init__(
self, redis_url: str, embedding: Embeddings, score_threshold: float = 0.2
):
"""Initialize by passing in the `init` GPTCache func
Args:
redis_url (str): URL to connect to Redis.
embedding (Embedding): Embedding provider for semantic encoding and search.
score_threshold (float, 0.2):
Example:
.. code-block:: python
import langchain
from langchain.cache import RedisSemanticCache
from langchain.embeddings import OpenAIEmbeddings
langchain.llm_cache = RedisSemanticCache(
redis_url="redis://localhost:6379",
embedding=OpenAIEmbeddings()
)
"""
self._cache_dict: Dict[str, RedisVectorstore] = {}
self.redis_url = redis_url
self.embedding = embedding
self.score_threshold = score_threshold
def _index_name(self, llm_string: str) -> str:
hashed_index = _hash(llm_string)
return f"cache:{hashed_index}"
def _get_llm_cache(self, llm_string: str) -> RedisVectorstore:
index_name = self._index_name(llm_string)
# return vectorstore client for the specific llm string
if index_name in self._cache_dict:
return self._cache_dict[index_name]
# create new vectorstore client for the specific llm string
try:
self._cache_dict[index_name] = RedisVectorstore.from_existing_index(
embedding=self.embedding,
index_name=index_name,
redis_url=self.redis_url,
schema=cast(Dict, self.DEFAULT_SCHEMA),
)
except ValueError:
redis = RedisVectorstore(
embedding=self.embedding,
index_name=index_name,
redis_url=self.redis_url,
index_schema=cast(Dict, self.DEFAULT_SCHEMA),
)
_embedding = self.embedding.embed_query(text="test")
redis._create_index(dim=len(_embedding))
self._cache_dict[index_name] = redis
return self._cache_dict[index_name]
def clear(self, **kwargs: Any) -> None:
"""Clear semantic cache for a given llm_string."""
index_name = self._index_name(kwargs["llm_string"])
if index_name in self._cache_dict:
self._cache_dict[index_name].drop_index(
index_name=index_name, delete_documents=True, redis_url=self.redis_url
)
del self._cache_dict[index_name]
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
llm_cache = self._get_llm_cache(llm_string)
generations: List = []
# Read from a Hash
results = llm_cache.similarity_search(
query=prompt,
k=1,
distance_threshold=self.score_threshold,
)
if results:
for document in results:
generations.extend(
_load_generations_from_json(document.metadata["return_val"])
)
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisSemanticCache only supports caching of "
f"normal LLM generations, got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisSentimentCache does not"
" support caching ChatModel outputs."
)
return
llm_cache = self._get_llm_cache(llm_string)
_dump_generations_to_json([g for g in return_val])
metadata = {
"llm_string": llm_string,
"prompt": prompt,
"return_val": _dump_generations_to_json([g for g in return_val]),
}
llm_cache.add_texts(texts=[prompt], metadatas=[metadata])
class GPTCache(BaseCache):
"""Cache that uses GPTCache as a backend."""
def __init__(
self,
init_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = None,
):
"""Initialize by passing in init function (default: `None`).
Args:
init_func (Optional[Callable[[Any], None]]): init `GPTCache` function
(default: `None`)
Example:
.. code-block:: python
# Initialize GPTCache with a custom init function
import gptcache
from gptcache.processor.pre import get_prompt
from gptcache.manager.factory import get_data_manager
# Avoid multiple caches using the same file,
causing different llm model caches to affect each other
def init_gptcache(cache_obj: gptcache.Cache, llm str):
cache_obj.init(
pre_embedding_func=get_prompt,
data_manager=manager_factory(
manager="map",
data_dir=f"map_cache_{llm}"
),
)
langchain.llm_cache = GPTCache(init_gptcache)
"""
try:
import gptcache # noqa: F401
except ImportError:
raise ImportError(
"Could not import gptcache python package. "
"Please install it with `pip install gptcache`."
)
self.init_gptcache_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = init_func
self.gptcache_dict: Dict[str, Any] = {}
def _new_gptcache(self, llm_string: str) -> Any:
"""New gptcache object"""
from gptcache import Cache
from gptcache.manager.factory import get_data_manager
from gptcache.processor.pre import get_prompt
_gptcache = Cache()
if self.init_gptcache_func is not None:
sig = inspect.signature(self.init_gptcache_func)
if len(sig.parameters) == 2:
self.init_gptcache_func(_gptcache, llm_string) # type: ignore[call-arg]
else:
self.init_gptcache_func(_gptcache) # type: ignore[call-arg]
else:
_gptcache.init(
pre_embedding_func=get_prompt,
data_manager=get_data_manager(data_path=llm_string),
)
self.gptcache_dict[llm_string] = _gptcache
return _gptcache
def _get_gptcache(self, llm_string: str) -> Any:
"""Get a cache object.
When the corresponding llm model cache does not exist, it will be created."""
_gptcache = self.gptcache_dict.get(llm_string, None)
if not _gptcache:
_gptcache = self._new_gptcache(llm_string)
return _gptcache
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up the cache data.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then retrieve the data from the cache based on the `prompt`.
"""
from gptcache.adapter.api import get
_gptcache = self._get_gptcache(llm_string)
res = get(prompt, cache_obj=_gptcache)
if res:
return [
Generation(**generation_dict) for generation_dict in json.loads(res)
]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then store the `prompt` and `return_val` in the cache object.
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"GPTCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
from gptcache.adapter.api import put
_gptcache = self._get_gptcache(llm_string)
handled_data = json.dumps([generation.dict() for generation in return_val])
put(prompt, handled_data, cache_obj=_gptcache)
return None
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
from gptcache import Cache
for gptcache_instance in self.gptcache_dict.values():
gptcache_instance = cast(Cache, gptcache_instance)
gptcache_instance.flush()
self.gptcache_dict.clear()
def _ensure_cache_exists(cache_client: momento.CacheClient, cache_name: str) -> None:
"""Create cache if it doesn't exist.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
from momento.responses import CreateCache
create_cache_response = cache_client.create_cache(cache_name)
if isinstance(create_cache_response, CreateCache.Success) or isinstance(
create_cache_response, CreateCache.CacheAlreadyExists
):
return None
elif isinstance(create_cache_response, CreateCache.Error):
raise create_cache_response.inner_exception
else:
raise Exception(f"Unexpected response cache creation: {create_cache_response}")
def _validate_ttl(ttl: Optional[timedelta]) -> None:
if ttl is not None and ttl <= timedelta(seconds=0):
raise ValueError(f"ttl must be positive but was {ttl}.")
class MomentoCache(BaseCache):
"""Cache that uses Momento as a backend. See https://gomomento.com/"""
def __init__(
self,
cache_client: momento.CacheClient,
cache_name: str,
*,
ttl: Optional[timedelta] = None,
ensure_cache_exists: bool = True,
):
"""Instantiate a prompt cache using Momento as a backend.
Note: to instantiate the cache client passed to MomentoCache,
you must have a Momento account. See https://gomomento.com/.
Args:
cache_client (CacheClient): The Momento cache client.
cache_name (str): The name of the cache to use to store the data.
ttl (Optional[timedelta], optional): The time to live for the cache items.
Defaults to None, ie use the client default TTL.
ensure_cache_exists (bool, optional): Create the cache if it doesn't
exist. Defaults to True.
Raises:
ImportError: Momento python package is not installed.
TypeError: cache_client is not of type momento.CacheClientObject
ValueError: ttl is non-null and non-negative
"""
try:
from momento import CacheClient
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if not isinstance(cache_client, CacheClient):
raise TypeError("cache_client must be a momento.CacheClient object.")
_validate_ttl(ttl)
if ensure_cache_exists:
_ensure_cache_exists(cache_client, cache_name)
self.cache_client = cache_client
self.cache_name = cache_name
self.ttl = ttl
@classmethod
def from_client_params(
cls,
cache_name: str,
ttl: timedelta,
*,
configuration: Optional[momento.config.Configuration] = None,
auth_token: Optional[str] = None,
**kwargs: Any,
) -> MomentoCache:
"""Construct cache from CacheClient parameters."""
try:
from momento import CacheClient, Configurations, CredentialProvider
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if configuration is None:
configuration = Configurations.Laptop.v1()
auth_token = auth_token or get_from_env("auth_token", "MOMENTO_AUTH_TOKEN")
credentials = CredentialProvider.from_string(auth_token)
cache_client = CacheClient(configuration, credentials, default_ttl=ttl)
return cls(cache_client, cache_name, ttl=ttl, **kwargs)
def __key(self, prompt: str, llm_string: str) -> str:
"""Compute cache key from prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Returns:
str: The cache key.
"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Lookup llm generations in cache by prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Raises:
SdkException: Momento service or network error
Returns:
Optional[RETURN_VAL_TYPE]: A list of language model generations.
"""
from momento.responses import CacheGet
generations: RETURN_VAL_TYPE = []
get_response = self.cache_client.get(
self.cache_name, self.__key(prompt, llm_string)
)
if isinstance(get_response, CacheGet.Hit):
value = get_response.value_string
generations = _load_generations_from_json(value)
elif isinstance(get_response, CacheGet.Miss):
pass
elif isinstance(get_response, CacheGet.Error):
raise get_response.inner_exception
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Store llm generations in cache.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model string.
return_val (RETURN_VAL_TYPE): A list of language model generations.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"Momento only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
key = self.__key(prompt, llm_string)
value = _dump_generations_to_json(return_val)
set_response = self.cache_client.set(self.cache_name, key, value, self.ttl)
from momento.responses import CacheSet
if isinstance(set_response, CacheSet.Success):
pass
elif isinstance(set_response, CacheSet.Error):
raise set_response.inner_exception
else:
raise Exception(f"Unexpected response: {set_response}")
def clear(self, **kwargs: Any) -> None:
"""Clear the cache.
Raises:
SdkException: Momento service or network error
"""
from momento.responses import CacheFlush
flush_response = self.cache_client.flush_cache(self.cache_name)
if isinstance(flush_response, CacheFlush.Success):
pass
elif isinstance(flush_response, CacheFlush.Error):
raise flush_response.inner_exception
CASSANDRA_CACHE_DEFAULT_TABLE_NAME = "langchain_llm_cache"
CASSANDRA_CACHE_DEFAULT_TTL_SECONDS = None
class CassandraCache(BaseCache):
"""
Cache that uses Cassandra / Astra DB as a backend.
It uses a single Cassandra table.
The lookup keys (which get to form the primary key) are:
- prompt, a string
- llm_string, a deterministic str representation of the model parameters.
(needed to prevent collisions same-prompt-different-model collisions)
"""
def __init__(
self,
session: Optional[CassandraSession] = None,
keyspace: Optional[str] = None,
table_name: str = CASSANDRA_CACHE_DEFAULT_TABLE_NAME,
ttl_seconds: Optional[int] = CASSANDRA_CACHE_DEFAULT_TTL_SECONDS,
skip_provisioning: bool = False,
):
"""
Initialize with a ready session and a keyspace name.
Args:
session (cassandra.cluster.Session): an open Cassandra session
keyspace (str): the keyspace to use for storing the cache
table_name (str): name of the Cassandra table to use as cache
ttl_seconds (optional int): time-to-live for cache entries
(default: None, i.e. forever)
"""
try:
from cassio.table import ElasticCassandraTable
except (ImportError, ModuleNotFoundError):
raise ValueError(
"Could not import cassio python package. "
"Please install it with `pip install cassio`."
)
self.session = session
self.keyspace = keyspace
self.table_name = table_name
self.ttl_seconds = ttl_seconds
self.kv_cache = ElasticCassandraTable(
session=self.session,
keyspace=self.keyspace,
table=self.table_name,
keys=["llm_string", "prompt"],
primary_key_type=["TEXT", "TEXT"],
ttl_seconds=self.ttl_seconds,
skip_provisioning=skip_provisioning,
)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
item = self.kv_cache.get(
llm_string=_hash(llm_string),
prompt=_hash(prompt),
)
if item is not None:
generations = _loads_generations(item["body_blob"])
# this protects against malformed cached items:
if generations is not None:
return generations
else:
return None
else:
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
blob = _dumps_generations(return_val)
self.kv_cache.put(
llm_string=_hash(llm_string),
prompt=_hash(prompt),
body_blob=blob,
)
def delete_through_llm(
self, prompt: str, llm: LLM, stop: Optional[List[str]] = None
) -> None:
"""
A wrapper around `delete` with the LLM being passed.
In case the llm(prompt) calls have a `stop` param, you should pass it here
"""
llm_string = get_prompts(
{**llm.dict(), **{"stop": stop}},
[],
)[1]
return self.delete(prompt, llm_string=llm_string)
def delete(self, prompt: str, llm_string: str) -> None:
"""Evict from cache if there's an entry."""
return self.kv_cache.delete(
llm_string=_hash(llm_string),
prompt=_hash(prompt),
)
def clear(self, **kwargs: Any) -> None:
"""Clear cache. This is for all LLMs at once."""
self.kv_cache.clear()
CASSANDRA_SEMANTIC_CACHE_DEFAULT_DISTANCE_METRIC = "dot"
CASSANDRA_SEMANTIC_CACHE_DEFAULT_SCORE_THRESHOLD = 0.85
CASSANDRA_SEMANTIC_CACHE_DEFAULT_TABLE_NAME = "langchain_llm_semantic_cache"
CASSANDRA_SEMANTIC_CACHE_DEFAULT_TTL_SECONDS = None
CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE = 16
class CassandraSemanticCache(BaseCache):
"""
Cache that uses Cassandra as a vector-store backend for semantic
(i.e. similarity-based) lookup.
It uses a single (vector) Cassandra table and stores, in principle,
cached values from several LLMs, so the LLM's llm_string is part
of the rows' primary keys.
The similarity is based on one of several distance metrics (default: "dot").
If choosing another metric, the default threshold is to be re-tuned accordingly.
"""
def __init__(
self,
session: Optional[CassandraSession],
keyspace: Optional[str],
embedding: Embeddings,
table_name: str = CASSANDRA_SEMANTIC_CACHE_DEFAULT_TABLE_NAME,
distance_metric: str = CASSANDRA_SEMANTIC_CACHE_DEFAULT_DISTANCE_METRIC,
score_threshold: float = CASSANDRA_SEMANTIC_CACHE_DEFAULT_SCORE_THRESHOLD,
ttl_seconds: Optional[int] = CASSANDRA_SEMANTIC_CACHE_DEFAULT_TTL_SECONDS,
skip_provisioning: bool = False,
):
"""
Initialize the cache with all relevant parameters.
Args:
session (cassandra.cluster.Session): an open Cassandra session
keyspace (str): the keyspace to use for storing the cache
embedding (Embedding): Embedding provider for semantic
encoding and search.
table_name (str): name of the Cassandra (vector) table
to use as cache
distance_metric (str, 'dot'): which measure to adopt for
similarity searches
score_threshold (optional float): numeric value to use as
cutoff for the similarity searches
ttl_seconds (optional int): time-to-live for cache entries
(default: None, i.e. forever)
The default score threshold is tuned to the default metric.
Tune it carefully yourself if switching to another distance metric.
"""
try:
from cassio.table import MetadataVectorCassandraTable
except (ImportError, ModuleNotFoundError):
raise ValueError(
"Could not import cassio python package. "
"Please install it with `pip install cassio`."
)
self.session = session
self.keyspace = keyspace
self.embedding = embedding
self.table_name = table_name
self.distance_metric = distance_metric
self.score_threshold = score_threshold
self.ttl_seconds = ttl_seconds
# The contract for this class has separate lookup and update:
# in order to spare some embedding calculations we cache them between
# the two calls.
# Note: each instance of this class has its own `_get_embedding` with
# its own lru.
@lru_cache(maxsize=CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE)
def _cache_embedding(text: str) -> List[float]:
return self.embedding.embed_query(text=text)
self._get_embedding = _cache_embedding
self.embedding_dimension = self._get_embedding_dimension()
self.table = MetadataVectorCassandraTable(
session=self.session,
keyspace=self.keyspace,
table=self.table_name,
primary_key_type=["TEXT"],
vector_dimension=self.embedding_dimension,
ttl_seconds=self.ttl_seconds,
metadata_indexing=("allow", {"_llm_string_hash"}),
skip_provisioning=skip_provisioning,
)
def _get_embedding_dimension(self) -> int:
return len(self._get_embedding(text="This is a sample sentence."))
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
embedding_vector = self._get_embedding(text=prompt)
llm_string_hash = _hash(llm_string)
body = _dumps_generations(return_val)
metadata = {
"_prompt": prompt,
"_llm_string_hash": llm_string_hash,
}
row_id = f"{_hash(prompt)}-{llm_string_hash}"
#
self.table.put(
body_blob=body,
vector=embedding_vector,
row_id=row_id,
metadata=metadata,
)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
hit_with_id = self.lookup_with_id(prompt, llm_string)
if hit_with_id is not None:
return hit_with_id[1]
else:
return None
def lookup_with_id(
self, prompt: str, llm_string: str
) -> Optional[Tuple[str, RETURN_VAL_TYPE]]:
"""
Look up based on prompt and llm_string.
If there are hits, return (document_id, cached_entry)
"""
prompt_embedding: List[float] = self._get_embedding(text=prompt)
hits = list(
self.table.metric_ann_search(
vector=prompt_embedding,
metadata={"_llm_string_hash": _hash(llm_string)},
n=1,
metric=self.distance_metric,
metric_threshold=self.score_threshold,
)
)
if hits:
hit = hits[0]
generations = _loads_generations(hit["body_blob"])
if generations is not None:
# this protects against malformed cached items:
return (
hit["row_id"],
generations,
)
else:
return None
else:
return None
def lookup_with_id_through_llm(
self, prompt: str, llm: LLM, stop: Optional[List[str]] = None
) -> Optional[Tuple[str, RETURN_VAL_TYPE]]:
llm_string = get_prompts(
{**llm.dict(), **{"stop": stop}},
[],
)[1]
return self.lookup_with_id(prompt, llm_string=llm_string)
def delete_by_document_id(self, document_id: str) -> None:
"""
Given this is a "similarity search" cache, an invalidation pattern
that makes sense is first a lookup to get an ID, and then deleting
with that ID. This is for the second step.
"""
self.table.delete(row_id=document_id)
def clear(self, **kwargs: Any) -> None:
"""Clear the *whole* semantic cache."""
self.table.clear()
| [
"langchain.schema.Generation",
"langchain.utils.get_from_env",
"langchain.load.load.loads",
"langchain.load.dump.dumps"
] | [((1586, 1613), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (1603, 1613), False, 'import logging\n'), ((5793, 5811), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (5809, 5811), False, 'from sqlalchemy.ext.declarative import declarative_base\n'), ((5968, 6000), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (5974, 6000), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((6011, 6043), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (6017, 6043), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((6054, 6087), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (6060, 6087), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((6103, 6117), 'sqlalchemy.Column', 'Column', (['String'], {}), '(String)\n', (6109, 6117), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((2730, 2758), 'json.loads', 'json.loads', (['generations_json'], {}), '(generations_json)\n', (2740, 2758), False, 'import json\n'), ((4550, 4577), 'json.loads', 'json.loads', (['generations_str'], {}), '(generations_str)\n', (4560, 4577), False, 'import json\n'), ((8521, 8564), 'sqlalchemy.create_engine', 'create_engine', (['f"""sqlite:///{database_path}"""'], {}), "(f'sqlite:///{database_path}')\n", (8534, 8564), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((18425, 18432), 'gptcache.Cache', 'Cache', ([], {}), '()\n', (18430, 18432), False, 'from gptcache import Cache\n'), ((19758, 19790), 'gptcache.adapter.api.get', 'get', (['prompt'], {'cache_obj': '_gptcache'}), '(prompt, cache_obj=_gptcache)\n', (19761, 19790), False, 'from gptcache.adapter.api import get\n'), ((20677, 20723), 'gptcache.adapter.api.put', 'put', (['prompt', 'handled_data'], {'cache_obj': '_gptcache'}), '(prompt, handled_data, cache_obj=_gptcache)\n', (20680, 20723), False, 'from gptcache.adapter.api import put\n'), ((24572, 24614), 'momento.CredentialProvider.from_string', 'CredentialProvider.from_string', (['auth_token'], {}), '(auth_token)\n', (24602, 24614), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((24638, 24694), 'momento.CacheClient', 'CacheClient', (['configuration', 'credentials'], {'default_ttl': 'ttl'}), '(configuration, credentials, default_ttl=ttl)\n', (24649, 24694), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((29638, 29876), 'cassio.table.ElasticCassandraTable', 'ElasticCassandraTable', ([], {'session': 'self.session', 'keyspace': 'self.keyspace', 'table': 'self.table_name', 'keys': "['llm_string', 'prompt']", 'primary_key_type': "['TEXT', 'TEXT']", 'ttl_seconds': 'self.ttl_seconds', 'skip_provisioning': 'skip_provisioning'}), "(session=self.session, keyspace=self.keyspace, table=\n self.table_name, keys=['llm_string', 'prompt'], primary_key_type=[\n 'TEXT', 'TEXT'], ttl_seconds=self.ttl_seconds, skip_provisioning=\n skip_provisioning)\n", (29659, 29876), False, 'from cassio.table import ElasticCassandraTable\n'), ((34766, 34830), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': 'CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE'}), '(maxsize=CASSANDRA_SEMANTIC_CACHE_EMBEDDING_CACHE_SIZE)\n', (34775, 34830), False, 'from functools import lru_cache\n'), ((35081, 35380), 'cassio.table.MetadataVectorCassandraTable', 'MetadataVectorCassandraTable', ([], {'session': 'self.session', 'keyspace': 'self.keyspace', 'table': 'self.table_name', 'primary_key_type': "['TEXT']", 'vector_dimension': 'self.embedding_dimension', 'ttl_seconds': 'self.ttl_seconds', 'metadata_indexing': "('allow', {'_llm_string_hash'})", 'skip_provisioning': 'skip_provisioning'}), "(session=self.session, keyspace=self.keyspace,\n table=self.table_name, primary_key_type=['TEXT'], vector_dimension=self\n .embedding_dimension, ttl_seconds=self.ttl_seconds, metadata_indexing=(\n 'allow', {'_llm_string_hash'}), skip_provisioning=skip_provisioning)\n", (35109, 35380), False, 'from cassio.table import MetadataVectorCassandraTable\n'), ((2775, 2804), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (2785, 2804), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((3618, 3630), 'langchain.load.dump.dumps', 'dumps', (['_item'], {}), '(_item)\n', (3623, 3630), False, 'from langchain.load.dump import dumps\n'), ((4296, 4312), 'langchain.load.load.loads', 'loads', (['_item_str'], {}), '(_item_str)\n', (4301, 4312), False, 'from langchain.load.load import loads\n'), ((4681, 4710), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (4691, 4710), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((6867, 6887), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6874, 6887), False, 'from sqlalchemy.orm import Session\n'), ((7974, 7994), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (7981, 7994), False, 'from sqlalchemy.orm import Session\n'), ((8176, 8196), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (8183, 8196), False, 'from sqlalchemy.orm import Session\n'), ((18499, 18541), 'inspect.signature', 'inspect.signature', (['self.init_gptcache_func'], {}), '(self.init_gptcache_func)\n', (18516, 18541), False, 'import inspect\n'), ((20946, 20976), 'typing.cast', 'cast', (['Cache', 'gptcache_instance'], {}), '(Cache, gptcache_instance)\n', (20950, 20976), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, cast\n'), ((21876, 21896), 'datetime.timedelta', 'timedelta', ([], {'seconds': '(0)'}), '(seconds=0)\n', (21885, 21896), False, 'from datetime import timedelta\n'), ((24439, 24465), 'momento.Configurations.Laptop.v1', 'Configurations.Laptop.v1', ([], {}), '()\n', (24463, 24465), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((24501, 24549), 'langchain.utils.get_from_env', 'get_from_env', (['"""auth_token"""', '"""MOMENTO_AUTH_TOKEN"""'], {}), "('auth_token', 'MOMENTO_AUTH_TOKEN')\n", (24513, 24549), False, 'from langchain.utils import get_from_env\n'), ((4330, 4357), 'json.loads', 'json.loads', (['generations_str'], {}), '(generations_str)\n', (4340, 4357), False, 'import json\n'), ((11054, 11173), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs.'\n )\n", (11067, 11173), False, 'import warnings\n'), ((15954, 16082), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs.'\n )\n", (15967, 16082), False, 'import warnings\n'), ((19844, 19873), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (19854, 19873), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((7884, 7894), 'langchain.load.dump.dumps', 'dumps', (['gen'], {}), '(gen)\n', (7889, 7894), False, 'from langchain.load.dump import dumps\n'), ((10513, 10534), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (10523, 10534), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((13908, 13939), 'typing.cast', 'cast', (['Dict', 'self.DEFAULT_SCHEMA'], {}), '(Dict, self.DEFAULT_SCHEMA)\n', (13912, 13939), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, cast\n'), ((18885, 18923), 'gptcache.manager.factory.get_data_manager', 'get_data_manager', ([], {'data_path': 'llm_string'}), '(data_path=llm_string)\n', (18901, 18923), False, 'from gptcache.manager.factory import get_data_manager\n'), ((19897, 19912), 'json.loads', 'json.loads', (['res'], {}), '(res)\n', (19907, 19912), False, 'import json\n'), ((7022, 7035), 'langchain.load.load.loads', 'loads', (['row[0]'], {}), '(row[0])\n', (7027, 7035), False, 'from langchain.load.load import loads\n'), ((14172, 14203), 'typing.cast', 'cast', (['Dict', 'self.DEFAULT_SCHEMA'], {}), '(Dict, self.DEFAULT_SCHEMA)\n', (14176, 14203), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Type, Union, cast\n'), ((7592, 7615), 'langchain.schema.Generation', 'Generation', ([], {'text': 'row[0]'}), '(text=row[0])\n', (7602, 7615), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((6637, 6671), 'sqlalchemy.select', 'select', (['self.cache_schema.response'], {}), '(self.cache_schema.response)\n', (6643, 6671), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n')] |
"""A tracer that runs evaluators over completed runs."""
from __future__ import annotations
import logging
from concurrent.futures import Future, ThreadPoolExecutor
from typing import Any, Dict, List, Optional, Sequence, Set, Union
from uuid import UUID
import langsmith
from langsmith import schemas as langsmith_schemas
from langchain.callbacks import manager
from langchain.callbacks.tracers import langchain as langchain_tracer
from langchain.callbacks.tracers.base import BaseTracer
from langchain.callbacks.tracers.schemas import Run
logger = logging.getLogger(__name__)
class EvaluatorCallbackHandler(BaseTracer):
"""A tracer that runs a run evaluator whenever a run is persisted.
Parameters
----------
evaluators : Sequence[RunEvaluator]
The run evaluators to apply to all top level runs.
max_workers : int, optional
The maximum number of worker threads to use for running the evaluators.
If not specified, it will default to the number of evaluators.
client : LangSmith Client, optional
The LangSmith client instance to use for evaluating the runs.
If not specified, a new instance will be created.
example_id : Union[UUID, str], optional
The example ID to be associated with the runs.
project_name : str, optional
The LangSmith project name to be organize eval chain runs under.
Attributes
----------
example_id : Union[UUID, None]
The example ID associated with the runs.
client : Client
The LangSmith client instance used for evaluating the runs.
evaluators : Sequence[RunEvaluator]
The sequence of run evaluators to be executed.
executor : ThreadPoolExecutor
The thread pool executor used for running the evaluators.
futures : Set[Future]
The set of futures representing the running evaluators.
skip_unfinished : bool
Whether to skip runs that are not finished or raised
an error.
project_name : Optional[str]
The LangSmith project name to be organize eval chain runs under.
"""
name = "evaluator_callback_handler"
def __init__(
self,
evaluators: Sequence[langsmith.RunEvaluator],
max_workers: Optional[int] = None,
client: Optional[langsmith.Client] = None,
example_id: Optional[Union[UUID, str]] = None,
skip_unfinished: bool = True,
project_name: Optional[str] = "evaluators",
**kwargs: Any,
) -> None:
super().__init__(**kwargs)
self.example_id = (
UUID(example_id) if isinstance(example_id, str) else example_id
)
self.client = client or langchain_tracer.get_client()
self.evaluators = evaluators
self.max_workers = max_workers or len(evaluators)
self.futures: Set[Future] = set()
self.skip_unfinished = skip_unfinished
self.project_name = project_name
self.logged_feedback: Dict[str, List[langsmith_schemas.Feedback]] = {}
def _evaluate_in_project(self, run: Run, evaluator: langsmith.RunEvaluator) -> None:
"""Evaluate the run in the project.
Parameters
----------
run : Run
The run to be evaluated.
evaluator : RunEvaluator
The evaluator to use for evaluating the run.
"""
try:
if self.project_name is None:
feedback = self.client.evaluate_run(run, evaluator)
with manager.tracing_v2_enabled(
project_name=self.project_name, tags=["eval"], client=self.client
):
feedback = self.client.evaluate_run(run, evaluator)
except Exception as e:
logger.error(
f"Error evaluating run {run.id} with "
f"{evaluator.__class__.__name__}: {e}",
exc_info=True,
)
raise e
example_id = str(run.reference_example_id)
self.logged_feedback.setdefault(example_id, []).append(feedback)
def _persist_run(self, run: Run) -> None:
"""Run the evaluator on the run.
Parameters
----------
run : Run
The run to be evaluated.
"""
if self.skip_unfinished and not run.outputs:
logger.debug(f"Skipping unfinished run {run.id}")
return
run_ = run.copy()
run_.reference_example_id = self.example_id
if self.max_workers > 0:
with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
list(
executor.map(
self._evaluate_in_project,
[run_ for _ in range(len(self.evaluators))],
self.evaluators,
)
)
else:
for evaluator in self.evaluators:
self._evaluate_in_project(run_, evaluator)
| [
"langchain.callbacks.tracers.langchain.get_client",
"langchain.callbacks.manager.tracing_v2_enabled"
] | [((553, 580), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (570, 580), False, 'import logging\n'), ((2572, 2588), 'uuid.UUID', 'UUID', (['example_id'], {}), '(example_id)\n', (2576, 2588), False, 'from uuid import UUID\n'), ((2678, 2707), 'langchain.callbacks.tracers.langchain.get_client', 'langchain_tracer.get_client', ([], {}), '()\n', (2705, 2707), True, 'from langchain.callbacks.tracers import langchain as langchain_tracer\n'), ((3483, 3580), 'langchain.callbacks.manager.tracing_v2_enabled', 'manager.tracing_v2_enabled', ([], {'project_name': 'self.project_name', 'tags': "['eval']", 'client': 'self.client'}), "(project_name=self.project_name, tags=['eval'],\n client=self.client)\n", (3509, 3580), False, 'from langchain.callbacks import manager\n'), ((4490, 4538), 'concurrent.futures.ThreadPoolExecutor', 'ThreadPoolExecutor', ([], {'max_workers': 'self.max_workers'}), '(max_workers=self.max_workers)\n', (4508, 4538), False, 'from concurrent.futures import Future, ThreadPoolExecutor\n')] |
"""A tracer that runs evaluators over completed runs."""
from __future__ import annotations
import logging
import threading
import weakref
from concurrent.futures import Future, ThreadPoolExecutor, wait
from typing import Any, Dict, List, Optional, Sequence, Tuple, Union, cast
from uuid import UUID
import langsmith
from langsmith.evaluation.evaluator import EvaluationResult
from langchain.callbacks import manager
from langchain.callbacks.tracers import langchain as langchain_tracer
from langchain.callbacks.tracers.base import BaseTracer
from langchain.callbacks.tracers.langchain import _get_executor
from langchain.callbacks.tracers.schemas import Run
logger = logging.getLogger(__name__)
_TRACERS: weakref.WeakSet[EvaluatorCallbackHandler] = weakref.WeakSet()
def wait_for_all_evaluators() -> None:
"""Wait for all tracers to finish."""
global _TRACERS
for tracer in list(_TRACERS):
if tracer is not None:
tracer.wait_for_futures()
class EvaluatorCallbackHandler(BaseTracer):
"""A tracer that runs a run evaluator whenever a run is persisted.
Parameters
----------
evaluators : Sequence[RunEvaluator]
The run evaluators to apply to all top level runs.
client : LangSmith Client, optional
The LangSmith client instance to use for evaluating the runs.
If not specified, a new instance will be created.
example_id : Union[UUID, str], optional
The example ID to be associated with the runs.
project_name : str, optional
The LangSmith project name to be organize eval chain runs under.
Attributes
----------
example_id : Union[UUID, None]
The example ID associated with the runs.
client : Client
The LangSmith client instance used for evaluating the runs.
evaluators : Sequence[RunEvaluator]
The sequence of run evaluators to be executed.
executor : ThreadPoolExecutor
The thread pool executor used for running the evaluators.
futures : Set[Future]
The set of futures representing the running evaluators.
skip_unfinished : bool
Whether to skip runs that are not finished or raised
an error.
project_name : Optional[str]
The LangSmith project name to be organize eval chain runs under.
"""
name = "evaluator_callback_handler"
def __init__(
self,
evaluators: Sequence[langsmith.RunEvaluator],
client: Optional[langsmith.Client] = None,
example_id: Optional[Union[UUID, str]] = None,
skip_unfinished: bool = True,
project_name: Optional[str] = "evaluators",
max_concurrency: Optional[int] = None,
**kwargs: Any,
) -> None:
super().__init__(**kwargs)
self.example_id = (
UUID(example_id) if isinstance(example_id, str) else example_id
)
self.client = client or langchain_tracer.get_client()
self.evaluators = evaluators
if max_concurrency is None:
self.executor: Optional[ThreadPoolExecutor] = _get_executor()
elif max_concurrency > 0:
self.executor = ThreadPoolExecutor(max_workers=max_concurrency)
weakref.finalize(
self,
lambda: cast(ThreadPoolExecutor, self.executor).shutdown(wait=True),
)
else:
self.executor = None
self.futures: weakref.WeakSet[Future] = weakref.WeakSet()
self.skip_unfinished = skip_unfinished
self.project_name = project_name
self.logged_eval_results: Dict[Tuple[str, str], List[EvaluationResult]] = {}
self.lock = threading.Lock()
global _TRACERS
_TRACERS.add(self)
def _evaluate_in_project(self, run: Run, evaluator: langsmith.RunEvaluator) -> None:
"""Evaluate the run in the project.
Parameters
----------
run : Run
The run to be evaluated.
evaluator : RunEvaluator
The evaluator to use for evaluating the run.
"""
try:
if self.project_name is None:
eval_result = self.client.evaluate_run(run, evaluator)
with manager.tracing_v2_enabled(
project_name=self.project_name, tags=["eval"], client=self.client
) as cb:
reference_example = (
self.client.read_example(run.reference_example_id)
if run.reference_example_id
else None
)
evaluation_result = evaluator.evaluate_run(
run,
example=reference_example,
)
run_id = cb.latest_run.id if cb.latest_run is not None else None
self.client.create_feedback(
run.id,
evaluation_result.key,
score=evaluation_result.score,
value=evaluation_result.value,
comment=evaluation_result.comment,
correction=evaluation_result.correction,
source_info=evaluation_result.evaluator_info,
source_run_id=evaluation_result.source_run_id or run_id,
feedback_source_type=langsmith.schemas.FeedbackSourceType.MODEL,
)
except Exception as e:
logger.error(
f"Error evaluating run {run.id} with "
f"{evaluator.__class__.__name__}: {repr(e)}",
exc_info=True,
)
raise e
example_id = str(run.reference_example_id)
with self.lock:
self.logged_eval_results.setdefault((str(run.id), example_id), []).append(
eval_result
)
def _persist_run(self, run: Run) -> None:
"""Run the evaluator on the run.
Parameters
----------
run : Run
The run to be evaluated.
"""
if self.skip_unfinished and not run.outputs:
logger.debug(f"Skipping unfinished run {run.id}")
return
run_ = run.copy()
run_.reference_example_id = self.example_id
for evaluator in self.evaluators:
if self.executor is None:
self._evaluate_in_project(run_, evaluator)
else:
self.futures.add(
self.executor.submit(self._evaluate_in_project, run_, evaluator)
)
def wait_for_futures(self) -> None:
"""Wait for all futures to complete."""
wait(self.futures)
| [
"langchain.callbacks.tracers.langchain.get_client",
"langchain.callbacks.manager.tracing_v2_enabled",
"langchain.callbacks.tracers.langchain._get_executor"
] | [((672, 699), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (689, 699), False, 'import logging\n'), ((755, 772), 'weakref.WeakSet', 'weakref.WeakSet', ([], {}), '()\n', (770, 772), False, 'import weakref\n'), ((3430, 3447), 'weakref.WeakSet', 'weakref.WeakSet', ([], {}), '()\n', (3445, 3447), False, 'import weakref\n'), ((3641, 3657), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (3655, 3657), False, 'import threading\n'), ((6571, 6589), 'concurrent.futures.wait', 'wait', (['self.futures'], {}), '(self.futures)\n', (6575, 6589), False, 'from concurrent.futures import Future, ThreadPoolExecutor, wait\n'), ((2791, 2807), 'uuid.UUID', 'UUID', (['example_id'], {}), '(example_id)\n', (2795, 2807), False, 'from uuid import UUID\n'), ((2897, 2926), 'langchain.callbacks.tracers.langchain.get_client', 'langchain_tracer.get_client', ([], {}), '()\n', (2924, 2926), True, 'from langchain.callbacks.tracers import langchain as langchain_tracer\n'), ((3058, 3073), 'langchain.callbacks.tracers.langchain._get_executor', '_get_executor', ([], {}), '()\n', (3071, 3073), False, 'from langchain.callbacks.tracers.langchain import _get_executor\n'), ((3136, 3183), 'concurrent.futures.ThreadPoolExecutor', 'ThreadPoolExecutor', ([], {'max_workers': 'max_concurrency'}), '(max_workers=max_concurrency)\n', (3154, 3183), False, 'from concurrent.futures import Future, ThreadPoolExecutor, wait\n'), ((4183, 4280), 'langchain.callbacks.manager.tracing_v2_enabled', 'manager.tracing_v2_enabled', ([], {'project_name': 'self.project_name', 'tags': "['eval']", 'client': 'self.client'}), "(project_name=self.project_name, tags=['eval'],\n client=self.client)\n", (4209, 4280), False, 'from langchain.callbacks import manager\n'), ((3260, 3299), 'typing.cast', 'cast', (['ThreadPoolExecutor', 'self.executor'], {}), '(ThreadPoolExecutor, self.executor)\n', (3264, 3299), False, 'from typing import Any, Dict, List, Optional, Sequence, Tuple, Union, cast\n')] |
import os
import re
from uuid import UUID
from typing import Any, Dict, List, Optional, Union
import asyncio
import langchain
import streamlit as st
from langchain.schema import LLMResult
from langchain.chat_models import ChatOpenAI
from langchain.agents import Tool
from langchain.agents import AgentType
from langchain.llms import OpenAI
from langchain.agents import initialize_agent
from langchain.memory import ConversationBufferMemory
from langchain.callbacks.base import AsyncCallbackHandler, BaseCallbackHandler
from streamlit.delta_generator import DeltaGenerator
from chains import doc_retriever
from chains.conversational_retrieval_over_code import ConversationalRetrievalCodeChain
from chains.parser import parse_code
langchain.debug = st.secrets["langchain"]["debug"]
python_script = os.path.join(os.getcwd(), "langchain", "generated_script.py")
class AsyncHandler(AsyncCallbackHandler):
"""Async callback handler that can be used to handle callbacks from langchain."""
def __init__(self, message_placeholder: DeltaGenerator) -> None:
super().__init__()
self.message_placeholder = message_placeholder
self.code_block = False
self.code_extracted = False
self.full_response = ""
async def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when chain starts running."""
message = ""
for chunk in "⌛Processing".split():
message += chunk + " "
await asyncio.sleep(0.05)
# Add a blinking cursor to simulate typing
self.message_placeholder.info(message + "▌")
async def on_llm_new_token(
self,
token: str,
*,
run_id: UUID,
parent_run_id: Optional[UUID] = None,
**kwargs: Any,
) -> None:
# Detect if the token is a code block, to print it all at once
self.full_response += token
if not self.code_extracted:
if "`" in token and not self.code_block:
self.code_block = True
if self.code_block and self.full_response.count("`") == 6:
# We have a full code block, print it now
code, explanation = parse_code(self.full_response)
container = self.message_placeholder.container()
ex = container.expander("Code")
ex.code(code)
container.markdown(explanation)
self.code_block = False
self.code_extracted = True
if self.code_extracted:
code, explanation = parse_code(self.full_response)
container = self.message_placeholder.container()
ex = container.expander("Code")
ex.code(code)
container.markdown(explanation + "▌")
async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when chain ends running."""
self.code_extracted = False
self.full_response = ""
class Handler(BaseCallbackHandler):
"""Async callback handler that can be used to handle callbacks from langchain."""
def __init__(self, message_placeholder: DeltaGenerator) -> None:
super().__init__()
self.message_placeholder = message_placeholder
self.code_block = False
self.code_extracted = False
self.full_response = ""
def on_chain_start(
self,
serialized: Dict[str, Any],
inputs: Dict[str, Any],
*,
run_id: UUID,
parent_run_id: Union[UUID, None] = None,
tags: Union[List[str], None] = None,
**kwargs: Any,
) -> Any:
"""Run when chain starts running."""
return super().on_chain_start(
serialized,
inputs,
run_id=run_id,
parent_run_id=parent_run_id,
tags=tags,
**kwargs,
)
def on_llm_new_token(
self,
token: str,
*,
run_id: UUID,
parent_run_id: Optional[UUID] = None,
**kwargs: Any,
) -> None:
# Detect if the token is a code block, to print it all at once
self.full_response += token
if not self.code_extracted:
if "`" in token and not self.code_block:
self.code_block = True
if self.code_block and self.full_response.count("`") >= 6:
# We have a full code block, print it now
self.message_placeholder.markdown(self.full_response)
self.code_block = False
self.code_extracted = True
if self.code_extracted:
message = ""
code, explain = parse(self.full_response)
if code:
message = f"```python\n{code}\n```\n"
if explain:
message += f"{explain}"
if message != "":
# Add a blinking cursor to simulate typing
self.message_placeholder.markdown(message + "▌")
return super().on_llm_new_token(
token, run_id=run_id, parent_run_id=parent_run_id, **kwargs
)
def on_chain_end(
self,
outputs: Dict[str, Any],
*,
run_id: UUID,
parent_run_id: Union[UUID, None] = None,
**kwargs: Any,
) -> Any:
"""Run when chain ends running."""
self.code_extracted = False
self.full_response = ""
return super().on_chain_end(
outputs, run_id=run_id, parent_run_id=parent_run_id, **kwargs
)
def load_conversation_chain(
message_placeholder: DeltaGenerator, openai_api_key: str
) -> ConversationalRetrievalCodeChain:
if openai_api_key is None:
raise ValueError("OpenAI API key is required to load the chain.")
llm = ChatOpenAI(
model_name="gpt-3.5-turbo-16k",
temperature=0,
openai_api_key=openai_api_key,
streaming=True,
callbacks=[Handler(message_placeholder)],
)
condense_question_llm = ChatOpenAI(
model_name="gpt-3.5-turbo", temperature=0, openai_api_key=openai_api_key
)
missing_imports_llm = ChatOpenAI(
model_name="gpt-3.5-turbo",
temperature=0,
openai_api_key=openai_api_key,
verbose=False,
)
retriever = doc_retriever.load_streamlit_doc_retriever(
st.secrets["openai_api_key"],
chroma_server_host=st.secrets["chroma"]["host"],
chroma_server_port=st.secrets["chroma"]["port"],
mode="docker",
)
qa_over_streamlit_code = ConversationalRetrievalCodeChain.from_llm(
llm=llm,
retriever=retriever,
condense_question_llm=condense_question_llm,
return_source_documents=True,
missing_imports_llm=missing_imports_llm,
return_revision_request=True,
verbose=False,
)
return qa_over_streamlit_code
def load_agent():
if st.secrets["openai_api_key"] is None:
st.error("OpenAI API key is missing! Please add it to your secrets.")
st.stop()
doc_chain = doc_retriever.load_streamlit_doc_chain(
OpenAI(
temperature=0, max_tokens=2000, openai_api_key=st.secrets["openai_api_key"]
)
)
tools = [
Tool(
name="Streamlit up to date source code",
func=doc_chain.run,
description="useful for when you need to answer questions about the "
"streamlit Python API. Input should be a fully formed question.",
),
]
model_name = "text-davinci-003"
memory = ConversationBufferMemory(memory_key="chat_history")
llm = OpenAI(
openai_api_key=st.secrets["openai_api_key"],
max_tokens=2000,
temperature=0,
model_name=model_name,
)
agent_chain = initialize_agent(
tools,
llm,
agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
verbose=False,
memory=memory,
)
return agent_chain
def load_chat_agent():
if st.secrets["openai_api_key"] is None:
st.error("OpenAI API key is missing! Please add it to your secrets.")
st.stop()
doc_chain = doc_retriever.load_streamlit_doc_chain(
OpenAI(
temperature=0, max_tokens=2000, openai_api_key=st.secrets["openai_api_key"]
)
)
tools = [
Tool(
name="Streamlit up to date source code",
func=doc_chain.run,
description="useful for when you need to answer questions about the streamlit "
"Python API. Input should be a fully formed question.",
),
]
model_name = "text-davinci-003"
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
llm = ChatOpenAI(
openai_api_key=st.secrets["openai_api_key"],
max_tokens=2000,
temperature=0,
model_name=model_name,
)
agent_chain = initialize_agent(
tools,
llm,
agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION,
verbose=False,
memory=memory,
)
return agent_chain
# https://regex101.com/r/fHlyKq/1
parse_code_regex = r"(```python(.*?)```)?(.*?)$"
def parse(output):
python_code = None
explain_code = None
python_code_match = re.search(parse_code_regex, output, re.DOTALL)
if python_code_match:
python_code = python_code_match.group(2)
explain_code = python_code_match.group(3)
if python_code == "None":
python_code = None
return python_code, explain_code
| [
"langchain.agents.initialize_agent",
"langchain.chat_models.ChatOpenAI",
"langchain.llms.OpenAI",
"langchain.memory.ConversationBufferMemory",
"langchain.agents.Tool"
] | [((815, 826), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (824, 826), False, 'import os\n'), ((6031, 6120), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0)', 'openai_api_key': 'openai_api_key'}), "(model_name='gpt-3.5-turbo', temperature=0, openai_api_key=\n openai_api_key)\n", (6041, 6120), False, 'from langchain.chat_models import ChatOpenAI\n'), ((6156, 6260), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0)', 'openai_api_key': 'openai_api_key', 'verbose': '(False)'}), "(model_name='gpt-3.5-turbo', temperature=0, openai_api_key=\n openai_api_key, verbose=False)\n", (6166, 6260), False, 'from langchain.chat_models import ChatOpenAI\n'), ((6311, 6505), 'chains.doc_retriever.load_streamlit_doc_retriever', 'doc_retriever.load_streamlit_doc_retriever', (["st.secrets['openai_api_key']"], {'chroma_server_host': "st.secrets['chroma']['host']", 'chroma_server_port': "st.secrets['chroma']['port']", 'mode': '"""docker"""'}), "(st.secrets['openai_api_key'],\n chroma_server_host=st.secrets['chroma']['host'], chroma_server_port=st.\n secrets['chroma']['port'], mode='docker')\n", (6353, 6505), False, 'from chains import doc_retriever\n'), ((6565, 6811), 'chains.conversational_retrieval_over_code.ConversationalRetrievalCodeChain.from_llm', 'ConversationalRetrievalCodeChain.from_llm', ([], {'llm': 'llm', 'retriever': 'retriever', 'condense_question_llm': 'condense_question_llm', 'return_source_documents': '(True)', 'missing_imports_llm': 'missing_imports_llm', 'return_revision_request': '(True)', 'verbose': '(False)'}), '(llm=llm, retriever=retriever,\n condense_question_llm=condense_question_llm, return_source_documents=\n True, missing_imports_llm=missing_imports_llm, return_revision_request=\n True, verbose=False)\n', (6606, 6811), False, 'from chains.conversational_retrieval_over_code import ConversationalRetrievalCodeChain\n'), ((7573, 7624), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""'}), "(memory_key='chat_history')\n", (7597, 7624), False, 'from langchain.memory import ConversationBufferMemory\n'), ((7635, 7745), 'langchain.llms.OpenAI', 'OpenAI', ([], {'openai_api_key': "st.secrets['openai_api_key']", 'max_tokens': '(2000)', 'temperature': '(0)', 'model_name': 'model_name'}), "(openai_api_key=st.secrets['openai_api_key'], max_tokens=2000,\n temperature=0, model_name=model_name)\n", (7641, 7745), False, 'from langchain.llms import OpenAI\n'), ((7799, 7912), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': 'AgentType.CONVERSATIONAL_REACT_DESCRIPTION', 'verbose': '(False)', 'memory': 'memory'}), '(tools, llm, agent=AgentType.\n CONVERSATIONAL_REACT_DESCRIPTION, verbose=False, memory=memory)\n', (7815, 7912), False, 'from langchain.agents import initialize_agent\n'), ((8661, 8734), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(memory_key='chat_history', return_messages=True)\n", (8685, 8734), False, 'from langchain.memory import ConversationBufferMemory\n'), ((8745, 8859), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': "st.secrets['openai_api_key']", 'max_tokens': '(2000)', 'temperature': '(0)', 'model_name': 'model_name'}), "(openai_api_key=st.secrets['openai_api_key'], max_tokens=2000,\n temperature=0, model_name=model_name)\n", (8755, 8859), False, 'from langchain.chat_models import ChatOpenAI\n'), ((8913, 9031), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': 'AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION', 'verbose': '(False)', 'memory': 'memory'}), '(tools, llm, agent=AgentType.\n CHAT_CONVERSATIONAL_REACT_DESCRIPTION, verbose=False, memory=memory)\n', (8929, 9031), False, 'from langchain.agents import initialize_agent\n'), ((9274, 9320), 're.search', 're.search', (['parse_code_regex', 'output', 're.DOTALL'], {}), '(parse_code_regex, output, re.DOTALL)\n', (9283, 9320), False, 'import re\n'), ((6968, 7037), 'streamlit.error', 'st.error', (['"""OpenAI API key is missing! Please add it to your secrets."""'], {}), "('OpenAI API key is missing! Please add it to your secrets.')\n", (6976, 7037), True, 'import streamlit as st\n'), ((7046, 7055), 'streamlit.stop', 'st.stop', ([], {}), '()\n', (7053, 7055), True, 'import streamlit as st\n'), ((7120, 7208), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'max_tokens': '(2000)', 'openai_api_key': "st.secrets['openai_api_key']"}), "(temperature=0, max_tokens=2000, openai_api_key=st.secrets[\n 'openai_api_key'])\n", (7126, 7208), False, 'from langchain.llms import OpenAI\n'), ((7255, 7467), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""Streamlit up to date source code"""', 'func': 'doc_chain.run', 'description': '"""useful for when you need to answer questions about the streamlit Python API. Input should be a fully formed question."""'}), "(name='Streamlit up to date source code', func=doc_chain.run,\n description=\n 'useful for when you need to answer questions about the streamlit Python API. Input should be a fully formed question.'\n )\n", (7259, 7467), False, 'from langchain.agents import Tool\n'), ((8056, 8125), 'streamlit.error', 'st.error', (['"""OpenAI API key is missing! Please add it to your secrets."""'], {}), "('OpenAI API key is missing! Please add it to your secrets.')\n", (8064, 8125), True, 'import streamlit as st\n'), ((8134, 8143), 'streamlit.stop', 'st.stop', ([], {}), '()\n', (8141, 8143), True, 'import streamlit as st\n'), ((8208, 8296), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'max_tokens': '(2000)', 'openai_api_key': "st.secrets['openai_api_key']"}), "(temperature=0, max_tokens=2000, openai_api_key=st.secrets[\n 'openai_api_key'])\n", (8214, 8296), False, 'from langchain.llms import OpenAI\n'), ((8343, 8555), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""Streamlit up to date source code"""', 'func': 'doc_chain.run', 'description': '"""useful for when you need to answer questions about the streamlit Python API. Input should be a fully formed question."""'}), "(name='Streamlit up to date source code', func=doc_chain.run,\n description=\n 'useful for when you need to answer questions about the streamlit Python API. Input should be a fully formed question.'\n )\n", (8347, 8555), False, 'from langchain.agents import Tool\n'), ((2617, 2647), 'chains.parser.parse_code', 'parse_code', (['self.full_response'], {}), '(self.full_response)\n', (2627, 2647), False, 'from chains.parser import parse_code\n'), ((1529, 1548), 'asyncio.sleep', 'asyncio.sleep', (['(0.05)'], {}), '(0.05)\n', (1542, 1548), False, 'import asyncio\n'), ((2247, 2277), 'chains.parser.parse_code', 'parse_code', (['self.full_response'], {}), '(self.full_response)\n', (2257, 2277), False, 'from chains.parser import parse_code\n')] |
from abc import ABC, abstractmethod
from typing import List, Optional
from pydantic import BaseModel, Extra, Field, validator
import langchain
from langchain.callbacks import get_callback_manager
from langchain.callbacks.base import BaseCallbackManager
from langchain.schema import (
AIMessage,
BaseLanguageModel,
BaseMessage,
ChatGeneration,
ChatResult,
HumanMessage,
LLMResult,
PromptValue,
)
def _get_verbosity() -> bool:
return langchain.verbose
class BaseChatModel(BaseLanguageModel, BaseModel, ABC):
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether to print out response text."""
callback_manager: BaseCallbackManager = Field(default_factory=get_callback_manager)
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@validator("callback_manager", pre=True, always=True)
def set_callback_manager(
cls, callback_manager: Optional[BaseCallbackManager]
) -> BaseCallbackManager:
"""If callback manager is None, set it.
This allows users to pass in None as callback manager, which is a nice UX.
"""
return callback_manager or get_callback_manager()
def _combine_llm_outputs(self, llm_outputs: List[Optional[dict]]) -> dict:
return {}
def generate(
self, messages: List[List[BaseMessage]], stop: Optional[List[str]] = None
) -> LLMResult:
"""Top Level call"""
results = [self._generate(m, stop=stop) for m in messages]
llm_output = self._combine_llm_outputs([res.llm_output for res in results])
generations = [res.generations for res in results]
return LLMResult(generations=generations, llm_output=llm_output)
async def agenerate(
self, messages: List[List[BaseMessage]], stop: Optional[List[str]] = None
) -> LLMResult:
"""Top Level call"""
results = [await self._agenerate(m, stop=stop) for m in messages]
llm_output = self._combine_llm_outputs([res.llm_output for res in results])
generations = [res.generations for res in results]
return LLMResult(generations=generations, llm_output=llm_output)
def generate_prompt(
self, prompts: List[PromptValue], stop: Optional[List[str]] = None
) -> LLMResult:
prompt_messages = [p.to_messages() for p in prompts]
prompt_strings = [p.to_string() for p in prompts]
self.callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
)
try:
output = self.generate(prompt_messages, stop=stop)
except (KeyboardInterrupt, Exception) as e:
self.callback_manager.on_llm_error(e, verbose=self.verbose)
raise e
self.callback_manager.on_llm_end(output, verbose=self.verbose)
return output
async def agenerate_prompt(
self, prompts: List[PromptValue], stop: Optional[List[str]] = None
) -> LLMResult:
prompt_messages = [p.to_messages() for p in prompts]
prompt_strings = [p.to_string() for p in prompts]
if self.callback_manager.is_async:
await self.callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
)
else:
self.callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
)
try:
output = await self.agenerate(prompt_messages, stop=stop)
except (KeyboardInterrupt, Exception) as e:
if self.callback_manager.is_async:
await self.callback_manager.on_llm_error(e, verbose=self.verbose)
else:
self.callback_manager.on_llm_error(e, verbose=self.verbose)
raise e
if self.callback_manager.is_async:
await self.callback_manager.on_llm_end(output, verbose=self.verbose)
else:
self.callback_manager.on_llm_end(output, verbose=self.verbose)
return output
@abstractmethod
def _generate(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> ChatResult:
"""Top Level call"""
@abstractmethod
async def _agenerate(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> ChatResult:
"""Top Level call"""
def __call__(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> BaseMessage:
return self._generate(messages, stop=stop).generations[0].message
def call_as_llm(self, message: str, stop: Optional[List[str]] = None) -> str:
result = self([HumanMessage(content=message)], stop=stop)
return result.content
class SimpleChatModel(BaseChatModel):
def _generate(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> ChatResult:
output_str = self._call(messages, stop=stop)
message = AIMessage(content=output_str)
generation = ChatGeneration(message=message)
return ChatResult(generations=[generation])
@abstractmethod
def _call(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> str:
"""Simpler interface."""
| [
"langchain.schema.AIMessage",
"langchain.schema.ChatGeneration",
"langchain.schema.HumanMessage",
"langchain.schema.ChatResult",
"langchain.schema.LLMResult",
"langchain.callbacks.get_callback_manager"
] | [((568, 605), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (573, 605), False, 'from pydantic import BaseModel, Extra, Field, validator\n'), ((696, 739), 'pydantic.Field', 'Field', ([], {'default_factory': 'get_callback_manager'}), '(default_factory=get_callback_manager)\n', (701, 739), False, 'from pydantic import BaseModel, Extra, Field, validator\n'), ((888, 940), 'pydantic.validator', 'validator', (['"""callback_manager"""'], {'pre': '(True)', 'always': '(True)'}), "('callback_manager', pre=True, always=True)\n", (897, 940), False, 'from pydantic import BaseModel, Extra, Field, validator\n'), ((1737, 1794), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (1746, 1794), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((2184, 2241), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (2193, 2241), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((5092, 5121), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'output_str'}), '(content=output_str)\n', (5101, 5121), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((5143, 5174), 'langchain.schema.ChatGeneration', 'ChatGeneration', ([], {'message': 'message'}), '(message=message)\n', (5157, 5174), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((5190, 5226), 'langchain.schema.ChatResult', 'ChatResult', ([], {'generations': '[generation]'}), '(generations=[generation])\n', (5200, 5226), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((1241, 1263), 'langchain.callbacks.get_callback_manager', 'get_callback_manager', ([], {}), '()\n', (1261, 1263), False, 'from langchain.callbacks import get_callback_manager\n'), ((4792, 4821), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'message'}), '(content=message)\n', (4804, 4821), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n')] |
from abc import ABC, abstractmethod
from typing import List, Optional
from pydantic import BaseModel, Extra, Field, validator
import langchain
from langchain.callbacks import get_callback_manager
from langchain.callbacks.base import BaseCallbackManager
from langchain.schema import (
AIMessage,
BaseLanguageModel,
BaseMessage,
ChatGeneration,
ChatResult,
HumanMessage,
LLMResult,
PromptValue,
)
def _get_verbosity() -> bool:
return langchain.verbose
class BaseChatModel(BaseLanguageModel, BaseModel, ABC):
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether to print out response text."""
callback_manager: BaseCallbackManager = Field(default_factory=get_callback_manager)
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@validator("callback_manager", pre=True, always=True)
def set_callback_manager(
cls, callback_manager: Optional[BaseCallbackManager]
) -> BaseCallbackManager:
"""If callback manager is None, set it.
This allows users to pass in None as callback manager, which is a nice UX.
"""
return callback_manager or get_callback_manager()
def _combine_llm_outputs(self, llm_outputs: List[Optional[dict]]) -> dict:
return {}
def generate(
self, messages: List[List[BaseMessage]], stop: Optional[List[str]] = None
) -> LLMResult:
"""Top Level call"""
results = [self._generate(m, stop=stop) for m in messages]
llm_output = self._combine_llm_outputs([res.llm_output for res in results])
generations = [res.generations for res in results]
return LLMResult(generations=generations, llm_output=llm_output)
async def agenerate(
self, messages: List[List[BaseMessage]], stop: Optional[List[str]] = None
) -> LLMResult:
"""Top Level call"""
results = [await self._agenerate(m, stop=stop) for m in messages]
llm_output = self._combine_llm_outputs([res.llm_output for res in results])
generations = [res.generations for res in results]
return LLMResult(generations=generations, llm_output=llm_output)
def generate_prompt(
self, prompts: List[PromptValue], stop: Optional[List[str]] = None
) -> LLMResult:
prompt_messages = [p.to_messages() for p in prompts]
prompt_strings = [p.to_string() for p in prompts]
self.callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
)
try:
output = self.generate(prompt_messages, stop=stop)
except (KeyboardInterrupt, Exception) as e:
self.callback_manager.on_llm_error(e, verbose=self.verbose)
raise e
self.callback_manager.on_llm_end(output, verbose=self.verbose)
return output
async def agenerate_prompt(
self, prompts: List[PromptValue], stop: Optional[List[str]] = None
) -> LLMResult:
prompt_messages = [p.to_messages() for p in prompts]
prompt_strings = [p.to_string() for p in prompts]
if self.callback_manager.is_async:
await self.callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
)
else:
self.callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompt_strings, verbose=self.verbose
)
try:
output = await self.agenerate(prompt_messages, stop=stop)
except (KeyboardInterrupt, Exception) as e:
if self.callback_manager.is_async:
await self.callback_manager.on_llm_error(e, verbose=self.verbose)
else:
self.callback_manager.on_llm_error(e, verbose=self.verbose)
raise e
if self.callback_manager.is_async:
await self.callback_manager.on_llm_end(output, verbose=self.verbose)
else:
self.callback_manager.on_llm_end(output, verbose=self.verbose)
return output
@abstractmethod
def _generate(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> ChatResult:
"""Top Level call"""
@abstractmethod
async def _agenerate(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> ChatResult:
"""Top Level call"""
def __call__(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> BaseMessage:
return self._generate(messages, stop=stop).generations[0].message
def call_as_llm(self, message: str, stop: Optional[List[str]] = None) -> str:
result = self([HumanMessage(content=message)], stop=stop)
return result.content
class SimpleChatModel(BaseChatModel):
def _generate(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> ChatResult:
output_str = self._call(messages, stop=stop)
message = AIMessage(content=output_str)
generation = ChatGeneration(message=message)
return ChatResult(generations=[generation])
@abstractmethod
def _call(
self, messages: List[BaseMessage], stop: Optional[List[str]] = None
) -> str:
"""Simpler interface."""
| [
"langchain.schema.AIMessage",
"langchain.schema.ChatGeneration",
"langchain.schema.HumanMessage",
"langchain.schema.ChatResult",
"langchain.schema.LLMResult",
"langchain.callbacks.get_callback_manager"
] | [((568, 605), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (573, 605), False, 'from pydantic import BaseModel, Extra, Field, validator\n'), ((696, 739), 'pydantic.Field', 'Field', ([], {'default_factory': 'get_callback_manager'}), '(default_factory=get_callback_manager)\n', (701, 739), False, 'from pydantic import BaseModel, Extra, Field, validator\n'), ((888, 940), 'pydantic.validator', 'validator', (['"""callback_manager"""'], {'pre': '(True)', 'always': '(True)'}), "('callback_manager', pre=True, always=True)\n", (897, 940), False, 'from pydantic import BaseModel, Extra, Field, validator\n'), ((1737, 1794), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (1746, 1794), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((2184, 2241), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (2193, 2241), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((5092, 5121), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'output_str'}), '(content=output_str)\n', (5101, 5121), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((5143, 5174), 'langchain.schema.ChatGeneration', 'ChatGeneration', ([], {'message': 'message'}), '(message=message)\n', (5157, 5174), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((5190, 5226), 'langchain.schema.ChatResult', 'ChatResult', ([], {'generations': '[generation]'}), '(generations=[generation])\n', (5200, 5226), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n'), ((1241, 1263), 'langchain.callbacks.get_callback_manager', 'get_callback_manager', ([], {}), '()\n', (1261, 1263), False, 'from langchain.callbacks import get_callback_manager\n'), ((4792, 4821), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'message'}), '(content=message)\n', (4804, 4821), False, 'from langchain.schema import AIMessage, BaseLanguageModel, BaseMessage, ChatGeneration, ChatResult, HumanMessage, LLMResult, PromptValue\n')] |
"""Base interface for large language models to expose."""
import inspect
import json
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
import yaml
from pydantic import Extra, Field, root_validator, validator
import langchain
from langchain.base_language import BaseLanguageModel
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForLLMRun,
CallbackManager,
CallbackManagerForLLMRun,
Callbacks,
)
from langchain.load.dump import dumpd
from langchain.schema import (
AIMessage,
BaseMessage,
Generation,
LLMResult,
PromptValue,
RunInfo,
get_buffer_string,
)
def _get_verbosity() -> bool:
return langchain.verbose
def get_prompts(
params: Dict[str, Any], prompts: List[str]
) -> Tuple[Dict[int, List], str, List[int], List[str]]:
"""Get prompts that are already cached."""
llm_string = str(sorted([(k, v) for k, v in params.items()]))
missing_prompts = []
missing_prompt_idxs = []
existing_prompts = {}
for i, prompt in enumerate(prompts):
if langchain.llm_cache is not None:
cache_val = langchain.llm_cache.lookup(prompt, llm_string)
if isinstance(cache_val, list):
existing_prompts[i] = cache_val
else:
missing_prompts.append(prompt)
missing_prompt_idxs.append(i)
return existing_prompts, llm_string, missing_prompt_idxs, missing_prompts
def update_cache(
existing_prompts: Dict[int, List],
llm_string: str,
missing_prompt_idxs: List[int],
new_results: LLMResult,
prompts: List[str],
) -> Optional[dict]:
"""Update the cache and get the LLM output."""
for i, result in enumerate(new_results.generations):
existing_prompts[missing_prompt_idxs[i]] = result
prompt = prompts[missing_prompt_idxs[i]]
if langchain.llm_cache is not None:
langchain.llm_cache.update(prompt, llm_string, result)
llm_output = new_results.llm_output
return llm_output
class BaseLLM(BaseLanguageModel, ABC):
"""LLM wrapper should take in a prompt and return a string."""
cache: Optional[bool] = None
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether to print out response text."""
callbacks: Callbacks = Field(default=None, exclude=True)
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
tags: Optional[List[str]] = Field(default=None, exclude=True)
"""Tags to add to the run trace."""
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@root_validator()
def raise_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@abstractmethod
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompts."""
@abstractmethod
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompts."""
def generate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return self.generate(prompt_strings, stop=stop, callbacks=callbacks, **kwargs)
async def agenerate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return await self.agenerate(
prompt_strings, stop=stop, callbacks=callbacks, **kwargs
)
def generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# If string is passed in directly no errors will be raised but outputs will
# not make sense.
if not isinstance(prompts, list):
raise ValueError(
"Argument 'prompts' is expected to be of type List[str], received"
f" argument of type {type(prompts)}."
)
params = self.dict()
params["stop"] = stop
options = {"stop": stop}
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = CallbackManager.configure(
callbacks, self.callbacks, self.verbose, tags, self.tags
)
new_arg_supported = inspect.signature(self._generate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = callback_manager.on_llm_start(
dumpd(self), prompts, invocation_params=params, options=options
)
try:
output = (
self._generate(
prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else self._generate(prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(output)
if run_manager:
output.run = RunInfo(run_id=run_manager.run_id)
return output
if len(missing_prompts) > 0:
run_manager = callback_manager.on_llm_start(
dumpd(self),
missing_prompts,
invocation_params=params,
options=options,
)
try:
new_results = (
self._generate(
missing_prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else self._generate(missing_prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
run_info = None
if run_manager:
run_info = RunInfo(run_id=run_manager.run_id)
else:
llm_output = {}
run_info = None
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output, run=run_info)
async def agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
params = self.dict()
params["stop"] = stop
options = {"stop": stop}
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = AsyncCallbackManager.configure(
callbacks, self.callbacks, self.verbose, tags, self.tags
)
new_arg_supported = inspect.signature(self._agenerate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = await callback_manager.on_llm_start(
dumpd(self), prompts, invocation_params=params, options=options
)
try:
output = (
await self._agenerate(
prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else await self._agenerate(prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e, verbose=self.verbose)
raise e
await run_manager.on_llm_end(output, verbose=self.verbose)
if run_manager:
output.run = RunInfo(run_id=run_manager.run_id)
return output
if len(missing_prompts) > 0:
run_manager = await callback_manager.on_llm_start(
dumpd(self),
missing_prompts,
invocation_params=params,
options=options,
)
try:
new_results = (
await self._agenerate(
missing_prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else await self._agenerate(missing_prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e)
raise e
await run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
run_info = None
if run_manager:
run_info = RunInfo(run_id=run_manager.run_id)
else:
llm_output = {}
run_info = None
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output, run=run_info)
def __call__(
self,
prompt: str,
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
if not isinstance(prompt, str):
raise ValueError(
"Argument `prompt` is expected to be a string. Instead found "
f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
"`generate` instead."
)
return (
self.generate([prompt], stop=stop, callbacks=callbacks, **kwargs)
.generations[0][0]
.text
)
async def _call_async(
self,
prompt: str,
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
result = await self.agenerate(
[prompt], stop=stop, callbacks=callbacks, **kwargs
)
return result.generations[0][0].text
def predict(
self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return self(text, stop=_stop, **kwargs)
def predict_messages(
self,
messages: List[BaseMessage],
*,
stop: Optional[Sequence[str]] = None,
**kwargs: Any,
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = self(text, stop=_stop, **kwargs)
return AIMessage(content=content)
async def apredict(
self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return await self._call_async(text, stop=_stop, **kwargs)
async def apredict_messages(
self,
messages: List[BaseMessage],
*,
stop: Optional[Sequence[str]] = None,
**kwargs: Any,
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = await self._call_async(text, stop=_stop, **kwargs)
return AIMessage(content=content)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {}
def __str__(self) -> str:
"""Get a string representation of the object for printing."""
cls_name = f"\033[1m{self.__class__.__name__}\033[0m"
return f"{cls_name}\nParams: {self._identifying_params}"
@property
@abstractmethod
def _llm_type(self) -> str:
"""Return type of llm."""
def dict(self, **kwargs: Any) -> Dict:
"""Return a dictionary of the LLM."""
starter_dict = dict(self._identifying_params)
starter_dict["_type"] = self._llm_type
return starter_dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the LLM.
Args:
file_path: Path to file to save the LLM to.
Example:
.. code-block:: python
llm.save(file_path="path/llm.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
prompt_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(prompt_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(prompt_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
class LLM(BaseLLM):
"""LLM class that expect subclasses to implement a simpler call method.
The purpose of this class is to expose a simpler interface for working
with LLMs, rather than expect the user to implement the full _generate method.
"""
@abstractmethod
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Run the LLM on the given prompt and input."""
async def _acall(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Run the LLM on the given prompt and input."""
raise NotImplementedError("Async generation not implemented for this LLM.")
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# TODO: add caching here.
generations = []
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
for prompt in prompts:
text = (
self._call(prompt, stop=stop, run_manager=run_manager, **kwargs)
if new_arg_supported
else self._call(prompt, stop=stop, **kwargs)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
generations = []
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
for prompt in prompts:
text = (
await self._acall(prompt, stop=stop, run_manager=run_manager, **kwargs)
if new_arg_supported
else await self._acall(prompt, stop=stop, **kwargs)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
| [
"langchain.llm_cache.lookup",
"langchain.schema.Generation",
"langchain.schema.AIMessage",
"langchain.llm_cache.update",
"langchain.schema.RunInfo",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.callbacks.manager.CallbackManager.configure",
"langchain.schema.LLMResult",
"langchain.load.dump.dumpd",
"langchain.schema.get_buffer_string"
] | [((2353, 2390), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2358, 2390), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2464, 2497), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2469, 2497), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2552, 2585), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2557, 2585), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2618, 2651), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2623, 2651), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2840, 2856), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (2854, 2856), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((3292, 3335), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (3301, 3335), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((5907, 5994), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags'], {}), '(callbacks, self.callbacks, self.verbose, tags,\n self.tags)\n', (5932, 5994), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((8360, 8431), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output', 'run': 'run_info'}), '(generations=generations, llm_output=llm_output, run=run_info)\n', (8369, 8431), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((9086, 9178), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags'], {}), '(callbacks, self.callbacks, self.verbose,\n tags, self.tags)\n', (9116, 9178), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((11653, 11724), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output', 'run': 'run_info'}), '(generations=generations, llm_output=llm_output, run=run_info)\n', (11662, 11724), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((13270, 13297), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (13287, 13297), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((13459, 13485), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (13468, 13485), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((13968, 13995), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (13985, 13995), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((14175, 14201), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (14184, 14201), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((17471, 17505), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (17480, 17505), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((18230, 18264), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (18239, 18264), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((1286, 1332), 'langchain.llm_cache.lookup', 'langchain.llm_cache.lookup', (['prompt', 'llm_string'], {}), '(prompt, llm_string)\n', (1312, 1332), False, 'import langchain\n'), ((2074, 2128), 'langchain.llm_cache.update', 'langchain.llm_cache.update', (['prompt', 'llm_string', 'result'], {}), '(prompt, llm_string, result)\n', (2100, 2128), False, 'import langchain\n'), ((3047, 3149), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (3060, 3149), False, 'import warnings\n'), ((15251, 15266), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (15255, 15266), False, 'from pathlib import Path\n'), ((6524, 6535), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (6529, 6535), False, 'from langchain.load.dump import dumpd\n'), ((7135, 7169), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (7142, 7169), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((7306, 7317), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (7311, 7317), False, 'from langchain.load.dump import dumpd\n'), ((8167, 8201), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (8174, 8201), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((10396, 10430), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (10403, 10430), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((11460, 11494), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (11467, 11494), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((15587, 15622), 'json.dump', 'json.dump', (['prompt_dict', 'f'], {'indent': '(4)'}), '(prompt_dict, f, indent=4)\n', (15596, 15622), False, 'import json\n'), ((6041, 6074), 'inspect.signature', 'inspect.signature', (['self._generate'], {}), '(self._generate)\n', (6058, 6074), False, 'import inspect\n'), ((9225, 9259), 'inspect.signature', 'inspect.signature', (['self._agenerate'], {}), '(self._agenerate)\n', (9242, 9259), False, 'import inspect\n'), ((9715, 9726), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (9720, 9726), False, 'from langchain.load.dump import dumpd\n'), ((10573, 10584), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (10578, 10584), False, 'from langchain.load.dump import dumpd\n'), ((15725, 15776), 'yaml.dump', 'yaml.dump', (['prompt_dict', 'f'], {'default_flow_style': '(False)'}), '(prompt_dict, f, default_flow_style=False)\n', (15734, 15776), False, 'import yaml\n'), ((17095, 17124), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (17112, 17124), False, 'import inspect\n'), ((17432, 17453), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (17442, 17453), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((17839, 17869), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (17856, 17869), False, 'import inspect\n'), ((18191, 18212), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (18201, 18212), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n')] |
"""Base interface for large language models to expose."""
import inspect
import json
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
import yaml
from pydantic import Extra, Field, root_validator, validator
import langchain
from langchain.base_language import BaseLanguageModel
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForLLMRun,
CallbackManager,
CallbackManagerForLLMRun,
Callbacks,
)
from langchain.load.dump import dumpd
from langchain.schema import (
AIMessage,
BaseMessage,
Generation,
LLMResult,
PromptValue,
RunInfo,
get_buffer_string,
)
def _get_verbosity() -> bool:
return langchain.verbose
def get_prompts(
params: Dict[str, Any], prompts: List[str]
) -> Tuple[Dict[int, List], str, List[int], List[str]]:
"""Get prompts that are already cached."""
llm_string = str(sorted([(k, v) for k, v in params.items()]))
missing_prompts = []
missing_prompt_idxs = []
existing_prompts = {}
for i, prompt in enumerate(prompts):
if langchain.llm_cache is not None:
cache_val = langchain.llm_cache.lookup(prompt, llm_string)
if isinstance(cache_val, list):
existing_prompts[i] = cache_val
else:
missing_prompts.append(prompt)
missing_prompt_idxs.append(i)
return existing_prompts, llm_string, missing_prompt_idxs, missing_prompts
def update_cache(
existing_prompts: Dict[int, List],
llm_string: str,
missing_prompt_idxs: List[int],
new_results: LLMResult,
prompts: List[str],
) -> Optional[dict]:
"""Update the cache and get the LLM output."""
for i, result in enumerate(new_results.generations):
existing_prompts[missing_prompt_idxs[i]] = result
prompt = prompts[missing_prompt_idxs[i]]
if langchain.llm_cache is not None:
langchain.llm_cache.update(prompt, llm_string, result)
llm_output = new_results.llm_output
return llm_output
class BaseLLM(BaseLanguageModel, ABC):
"""LLM wrapper should take in a prompt and return a string."""
cache: Optional[bool] = None
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether to print out response text."""
callbacks: Callbacks = Field(default=None, exclude=True)
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
tags: Optional[List[str]] = Field(default=None, exclude=True)
"""Tags to add to the run trace."""
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@root_validator()
def raise_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@abstractmethod
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompts."""
@abstractmethod
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompts."""
def generate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return self.generate(prompt_strings, stop=stop, callbacks=callbacks, **kwargs)
async def agenerate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return await self.agenerate(
prompt_strings, stop=stop, callbacks=callbacks, **kwargs
)
def generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# If string is passed in directly no errors will be raised but outputs will
# not make sense.
if not isinstance(prompts, list):
raise ValueError(
"Argument 'prompts' is expected to be of type List[str], received"
f" argument of type {type(prompts)}."
)
params = self.dict()
params["stop"] = stop
options = {"stop": stop}
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = CallbackManager.configure(
callbacks, self.callbacks, self.verbose, tags, self.tags
)
new_arg_supported = inspect.signature(self._generate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = callback_manager.on_llm_start(
dumpd(self), prompts, invocation_params=params, options=options
)
try:
output = (
self._generate(
prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else self._generate(prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(output)
if run_manager:
output.run = RunInfo(run_id=run_manager.run_id)
return output
if len(missing_prompts) > 0:
run_manager = callback_manager.on_llm_start(
dumpd(self),
missing_prompts,
invocation_params=params,
options=options,
)
try:
new_results = (
self._generate(
missing_prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else self._generate(missing_prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
run_info = None
if run_manager:
run_info = RunInfo(run_id=run_manager.run_id)
else:
llm_output = {}
run_info = None
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output, run=run_info)
async def agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
params = self.dict()
params["stop"] = stop
options = {"stop": stop}
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = AsyncCallbackManager.configure(
callbacks, self.callbacks, self.verbose, tags, self.tags
)
new_arg_supported = inspect.signature(self._agenerate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = await callback_manager.on_llm_start(
dumpd(self), prompts, invocation_params=params, options=options
)
try:
output = (
await self._agenerate(
prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else await self._agenerate(prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e, verbose=self.verbose)
raise e
await run_manager.on_llm_end(output, verbose=self.verbose)
if run_manager:
output.run = RunInfo(run_id=run_manager.run_id)
return output
if len(missing_prompts) > 0:
run_manager = await callback_manager.on_llm_start(
dumpd(self),
missing_prompts,
invocation_params=params,
options=options,
)
try:
new_results = (
await self._agenerate(
missing_prompts, stop=stop, run_manager=run_manager, **kwargs
)
if new_arg_supported
else await self._agenerate(missing_prompts, stop=stop, **kwargs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e)
raise e
await run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
run_info = None
if run_manager:
run_info = RunInfo(run_id=run_manager.run_id)
else:
llm_output = {}
run_info = None
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output, run=run_info)
def __call__(
self,
prompt: str,
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
if not isinstance(prompt, str):
raise ValueError(
"Argument `prompt` is expected to be a string. Instead found "
f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
"`generate` instead."
)
return (
self.generate([prompt], stop=stop, callbacks=callbacks, **kwargs)
.generations[0][0]
.text
)
async def _call_async(
self,
prompt: str,
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
**kwargs: Any,
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
result = await self.agenerate(
[prompt], stop=stop, callbacks=callbacks, **kwargs
)
return result.generations[0][0].text
def predict(
self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return self(text, stop=_stop, **kwargs)
def predict_messages(
self,
messages: List[BaseMessage],
*,
stop: Optional[Sequence[str]] = None,
**kwargs: Any,
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = self(text, stop=_stop, **kwargs)
return AIMessage(content=content)
async def apredict(
self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return await self._call_async(text, stop=_stop, **kwargs)
async def apredict_messages(
self,
messages: List[BaseMessage],
*,
stop: Optional[Sequence[str]] = None,
**kwargs: Any,
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = await self._call_async(text, stop=_stop, **kwargs)
return AIMessage(content=content)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {}
def __str__(self) -> str:
"""Get a string representation of the object for printing."""
cls_name = f"\033[1m{self.__class__.__name__}\033[0m"
return f"{cls_name}\nParams: {self._identifying_params}"
@property
@abstractmethod
def _llm_type(self) -> str:
"""Return type of llm."""
def dict(self, **kwargs: Any) -> Dict:
"""Return a dictionary of the LLM."""
starter_dict = dict(self._identifying_params)
starter_dict["_type"] = self._llm_type
return starter_dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the LLM.
Args:
file_path: Path to file to save the LLM to.
Example:
.. code-block:: python
llm.save(file_path="path/llm.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
prompt_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(prompt_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(prompt_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
class LLM(BaseLLM):
"""LLM class that expect subclasses to implement a simpler call method.
The purpose of this class is to expose a simpler interface for working
with LLMs, rather than expect the user to implement the full _generate method.
"""
@abstractmethod
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Run the LLM on the given prompt and input."""
async def _acall(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Run the LLM on the given prompt and input."""
raise NotImplementedError("Async generation not implemented for this LLM.")
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# TODO: add caching here.
generations = []
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
for prompt in prompts:
text = (
self._call(prompt, stop=stop, run_manager=run_manager, **kwargs)
if new_arg_supported
else self._call(prompt, stop=stop, **kwargs)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
generations = []
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
for prompt in prompts:
text = (
await self._acall(prompt, stop=stop, run_manager=run_manager, **kwargs)
if new_arg_supported
else await self._acall(prompt, stop=stop, **kwargs)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
| [
"langchain.llm_cache.lookup",
"langchain.schema.Generation",
"langchain.schema.AIMessage",
"langchain.llm_cache.update",
"langchain.schema.RunInfo",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.callbacks.manager.CallbackManager.configure",
"langchain.schema.LLMResult",
"langchain.load.dump.dumpd",
"langchain.schema.get_buffer_string"
] | [((2353, 2390), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2358, 2390), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2464, 2497), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2469, 2497), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2552, 2585), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2557, 2585), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2618, 2651), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2623, 2651), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2840, 2856), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (2854, 2856), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((3292, 3335), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (3301, 3335), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((5907, 5994), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags'], {}), '(callbacks, self.callbacks, self.verbose, tags,\n self.tags)\n', (5932, 5994), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((8360, 8431), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output', 'run': 'run_info'}), '(generations=generations, llm_output=llm_output, run=run_info)\n', (8369, 8431), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((9086, 9178), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags'], {}), '(callbacks, self.callbacks, self.verbose,\n tags, self.tags)\n', (9116, 9178), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((11653, 11724), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output', 'run': 'run_info'}), '(generations=generations, llm_output=llm_output, run=run_info)\n', (11662, 11724), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((13270, 13297), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (13287, 13297), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((13459, 13485), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (13468, 13485), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((13968, 13995), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (13985, 13995), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((14175, 14201), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (14184, 14201), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((17471, 17505), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (17480, 17505), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((18230, 18264), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (18239, 18264), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((1286, 1332), 'langchain.llm_cache.lookup', 'langchain.llm_cache.lookup', (['prompt', 'llm_string'], {}), '(prompt, llm_string)\n', (1312, 1332), False, 'import langchain\n'), ((2074, 2128), 'langchain.llm_cache.update', 'langchain.llm_cache.update', (['prompt', 'llm_string', 'result'], {}), '(prompt, llm_string, result)\n', (2100, 2128), False, 'import langchain\n'), ((3047, 3149), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (3060, 3149), False, 'import warnings\n'), ((15251, 15266), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (15255, 15266), False, 'from pathlib import Path\n'), ((6524, 6535), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (6529, 6535), False, 'from langchain.load.dump import dumpd\n'), ((7135, 7169), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (7142, 7169), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((7306, 7317), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (7311, 7317), False, 'from langchain.load.dump import dumpd\n'), ((8167, 8201), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (8174, 8201), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((10396, 10430), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (10403, 10430), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((11460, 11494), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (11467, 11494), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((15587, 15622), 'json.dump', 'json.dump', (['prompt_dict', 'f'], {'indent': '(4)'}), '(prompt_dict, f, indent=4)\n', (15596, 15622), False, 'import json\n'), ((6041, 6074), 'inspect.signature', 'inspect.signature', (['self._generate'], {}), '(self._generate)\n', (6058, 6074), False, 'import inspect\n'), ((9225, 9259), 'inspect.signature', 'inspect.signature', (['self._agenerate'], {}), '(self._agenerate)\n', (9242, 9259), False, 'import inspect\n'), ((9715, 9726), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (9720, 9726), False, 'from langchain.load.dump import dumpd\n'), ((10573, 10584), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (10578, 10584), False, 'from langchain.load.dump import dumpd\n'), ((15725, 15776), 'yaml.dump', 'yaml.dump', (['prompt_dict', 'f'], {'default_flow_style': '(False)'}), '(prompt_dict, f, default_flow_style=False)\n', (15734, 15776), False, 'import yaml\n'), ((17095, 17124), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (17112, 17124), False, 'import inspect\n'), ((17432, 17453), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (17442, 17453), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n'), ((17839, 17869), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (17856, 17869), False, 'import inspect\n'), ((18191, 18212), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (18201, 18212), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, RunInfo, get_buffer_string\n')] |
from langchain.agents import AgentExecutor, LLMSingleActionAgent, AgentOutputParser
from langchain.tools import Tool, StructuredTool
from langchain.prompts import StringPromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.llms import VertexAI
from typing import List, Union, Tuple, Any, Dict
from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult
import re
import langchain
import os
import json
import requests
from utils import *
from tools import take_environment_action_wrapper
from debate import view_debate_wrapper
from langchain.callbacks import FileCallbackHandler
from langchain.callbacks.base import BaseCallbackHandler
import logging
from langchain.agents.agent_iterator import AgentExecutorIterator
from datetime import datetime
from pydantic import BaseModel, Field
# Example usage:
log_levels = {
'none': logging.CRITICAL,
'all': logging.INFO,
}
def get_info_logger():
timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
os.makedirs(f'./results/{timestamp}', exist_ok=True)
info_filename = f'./results/{timestamp}/info_{timestamp}.log'
debug_filename = f'./results/{timestamp}/debug_{timestamp}.log'
logging.basicConfig(level=logging.NOTSET, handlers=[logging.NullHandler()])
info_logger = logging.getLogger('info_logger')
# Create an INFO file handler
file_handler_info = logging.FileHandler(info_filename)
file_handler_info.setLevel(logging.INFO)
# Create formatters and set them for the file handlers
formatter_info = logging.Formatter('%(message)s')
file_handler_info.setFormatter(formatter_info)
# Add the file handlers to the logger
info_logger.addHandler(file_handler_info)
info_logger.info(timestamp)
return info_logger, timestamp, info_filename, debug_filename
class Context(BaseModel):
generation_observation_history: List[str] = []
log_count: int = 0
action_count: int = 0
debate_count: int = 0
do_debate: bool = False
system_hint_mod: int = 2
max_votes: int = 1
vote_count: int = 0
votes: List[Tuple[str, str, str]] = []
info_logger: Any = None
token_count: int = 0
class CustomPromptTemplate(StringPromptTemplate):
# The template to use
template: str
# The list of tools available
tools: List[Tool]
# Context for information
context: Context
def format(self, **kwargs) -> str:
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = [(a, o) for a, o in kwargs.pop("intermediate_steps") if o != EMPTY_RESPONSE]
# if recently finished voting, then vote count is 0
done_voting = self.context.vote_count == 0
history_lines = []
last_action = None
last_observation = None
# create history to prompt agent
for action, observation in intermediate_steps:
history_lines.append(action.log.strip())
history_lines.append(f"{OBSERVATION_PREFIX} {observation.strip()}")
last_action = action
last_observation = observation.strip()
history = '\n'.join(history_lines)
# append observation to list for debaters to use. Only append the environment observation, not debate observation
# only do this if done voting, else we'll append it 'self.context.max_votes' many times
if done_voting and last_action and last_action.tool == TAKE_ENVIRONMENT_ACTION:
self.context.generation_observation_history.append(f'{OBSERVATION_PREFIX} {last_observation}')
system_hint = None
valid_action_hint = None
# append system hint for after taking action
if (self.context.do_debate and
last_action and
last_action.tool == TAKE_ENVIRONMENT_ACTION and
self.context.action_count % self.context.system_hint_mod == 0):
system_hint = HINT_AFTER_ACTION
history += '\n' + system_hint
# append system hint for after viewing debate
if (self.context.do_debate and
last_action and
last_action.tool == VIEW_DEBATE):
system_hint = HINT_AFTER_DEBATE
history += '\n' + system_hint
# append system hint that reminds
valid_action_hint = VALID_ACTIONS
history += '\n' + valid_action_hint
# Set the agent_scratchpad variable to that value
kwargs["agent_scratchpad"] = history
# Create a tools variable from the list of tools provided
tool_strings = []
for tool in self.tools:
s = f"{tool.name}: {tool.description}"
params = [f'{param} - {info["description"]}' for param, info in tool.args.items()]
s += ' Argument: ' + ' '.join(params)
tool_strings.append(s)
kwargs["tools"] = "\n".join(tool_strings)
# Create a list of tool names for the tools provided
kwargs["tool_names"] = " or ".join([tool.name for tool in self.tools])
agent_prompt = self.template.format(**kwargs)
# log some stuff
if self.context.log_count == 0:
self.context.info_logger.info(f"Step {self.context.log_count} ===")
self.context.info_logger.info(agent_prompt)
self.context.log_count += 1
elif done_voting and self.context.log_count > 0 and last_action:
self.context.info_logger.info(f"\nStep {self.context.log_count} ===")
self.context.info_logger.info(f'Generation ---\n{last_action.log.strip()}')
self.context.info_logger.info(f'Observation ---\n{last_observation}')
if system_hint:
self.context.info_logger.info(f'<only seen once by agent> {system_hint}')
if valid_action_hint:
self.context.info_logger.info(f'<only seen once by agent> {valid_action_hint}')
self.context.log_count += 1
self.context.token_count += tokens(agent_prompt)
return agent_prompt
class CustomOutputParser(AgentOutputParser):
# Context for information
context: Context
def parse(self, llm_output: str) -> Union[AgentFinish, AgentAction, list[AgentAction]]:
self.context.token_count += tokens(llm_output)
default_agent_finish = AgentFinish(
return_values={'output': "Task finished."},
log=llm_output
)
# first, extract the answer and append it to the votes
# this includes final answers, and even treats errors as an answer
try:
pattern = r'Tool: (.*)\nTool Input: (.*)'
match = re.search(pattern, llm_output, re.DOTALL)
# if the agent wants to do a final answer
if "final answer" in llm_output.lower() or "final_answer" in llm_output.lower():
self.context.vote_count += 1
self.context.votes.append(('final answer', 'final answer', llm_output))
# else, look for a tool
elif match:
# extract the tool information
tool_name: str = match.group(1)
tool_input: str = match.group(2)
# increment the votes
self.context.vote_count += 1
self.context.votes.append((tool_name, tool_input, llm_output))
else:
raise ValueError(f"Could not find 'Tool:' or 'Tool Input:' : `{llm_output}`")
except Exception as e:
self.context.vote_count += 1
self.context.votes.append(('error', 'error', llm_output + f'\n ERROR === \n{e}'))
# if not done voting, then don't take an action
# the take_environment_action tool handles this
if self.context.vote_count < self.context.max_votes:
return AgentAction(tool=TAKE_ENVIRONMENT_ACTION, tool_input='empty param', log='empty tool')
# if done voting, return majority vote and reset voting
else:
# log the votes
self.context.info_logger.info("Casting votes... ===")
for i, vote in enumerate(self.context.votes):
self.context.info_logger.info(f"Vote {i} ---\n{vote}")
# get the majority vote
majority_tool_name, majority_tool_input, random_llm_output = get_majority_vote(self.context.votes)
# reset the voting
self.context.vote_count = 0
self.context.votes = []
# if the majority vote was a final answer or an error:
if majority_tool_name == 'final answer' or majority_tool_name == 'error':
return default_agent_finish
# if the majority vote is a debate tool, then call that tool
elif majority_tool_name == VIEW_DEBATE:
self.context.debate_count += 1
return AgentAction(tool=majority_tool_name, tool_input=majority_tool_input,
log=random_llm_output)
# if the majority vote is a environment action tool, then call that tool and log stuff
elif majority_tool_name == TAKE_ENVIRONMENT_ACTION:
# increment action count and log it
self.context.action_count += 1
self.context.info_logger.info(f"\nAction Count {self.context.action_count} +++")
# add action to the history for debaters
self.context.generation_observation_history.append('Action: ' + majority_tool_input)
return AgentAction(tool=majority_tool_name, tool_input=majority_tool_input,
log=random_llm_output)
else:
print('This happened!')
return default_agent_finish
# raise ValueError(f"An error occurred that should never occur: `{majority_tool_name}`")
def run_experiment(exp):
description = exp['description']
langchain.debug = exp['langchain.debug']
langchain_verbose = exp['langchain_verbose']
log_level = log_levels['all']
langchain_logging = False
do_debate = exp['do_debate']
MAX_STEPS = exp['MAX_STEPS']
MAX_VOTES = exp['MAX_VOTES']
temperature = 0 if MAX_VOTES == 1 else 0.7
model = exp['agent_model']
system_hint_mod = 1000000
debate_params = dict()
if 'debate_params' in exp:
debate_params = exp['debate_params']
system_hint_mod = debate_params.pop('system_hint_mod')
info_logger, timestamp, info_filename, debug_filename = get_info_logger()
info_logger.setLevel(log_level)
if langchain_logging:
handler = FileCallbackHandler(debug_filename)
results = []
num_tasks = exp['num_tasks']
start_task = exp['start_task']
reset_tasks()
for _ in range(1, start_task):
get_next_task(MAX_STEPS)
filename = None
for _ in range(num_tasks):
# set up the context to pass around
context = Context()
# file that debaters will use to see agent history
context.generation_observation_history = []
# information to know when to log the full action count
context.log_count = 0
# information to know when to provide the system hint
context.action_count = 0
# count the number of debates
context.debate_count = 0
# only display the system hints if do_debate is true
context.do_debate = do_debate
# show the hints after every x many actions.
context.system_hint_mod = system_hint_mod
# do majority voting
context.max_votes = MAX_VOTES
# count total votes so far
context.vote_count = 0
# store the votes
context.votes = []
# expose the logger
context.info_logger = info_logger
# count the tokens
context.token_count = 0
# set up the available tools
tools = [
take_environment_action_wrapper(context)
]
if do_debate:
tools.append(view_debate_wrapper(context, **debate_params, logger=info_logger))
# load the examples and task from ALFWorld
examples, task, task_index = get_next_task(MAX_STEPS,
do_debate=False) # not inserting debates even if in debate mode
print(f'Task index: {task_index}')
examples_str = '\n\n'.join([f'Example {i + 1}:\n{ex}' for i, ex in enumerate(examples)])
examples_str = examples_str.replace('{', '{{').replace('}', '}}')
info_logger.info(f'\n\n\n\n\n\n\n\n\nTask index: {task_index}')
# load the prompt that tells how to format the actions
formatting = read_text_file("./prompts/action_formatting.txt")
# load the examples of failures
failure_examples_str = read_text_file("./prompts/failure_examples.txt")
# set up strings to insert if do_debate == True
debate_examples_str = ''
debate_msg_1 = ''
debate_msg_2 = ''
if do_debate:
debate_msg_2 = f'\n- IMPORTANT: Remember to use the "{VIEW_DEBATE}" tool to get a better understanding about your problem and proposed action BEFORE using "{TAKE_ENVIRONMENT_ACTION}".'
debate_examples_str = '\n\n' + read_text_file("./prompts/debate_examples.txt")
template = read_text_file("prompts/prompt_template.txt")
# fill out the template
template = template.format(
formatting=formatting,
success_examples=examples_str,
failure_examples=failure_examples_str,
debate_examples=debate_examples_str,
debate_msg_1=debate_msg_1,
debate_msg_2=debate_msg_2,
)
# create the prompt
prompt = CustomPromptTemplate(
template=template,
tools=tools,
# This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables=["input", "intermediate_steps"],
context=context,
)
llm = VertexAI(
model_name=model,
temperature=temperature,
max_output_tokens=256,
)
callbacks = []
if langchain_logging:
callbacks.append(handler)
llm_chain = LLMChain(
llm=llm,
prompt=prompt,
callbacks=callbacks
)
agent = LLMSingleActionAgent(
llm_chain=llm_chain,
output_parser=CustomOutputParser(context=context),
stop=[f"\n{OBSERVATION_PREFIX}"],
allowed_tools=[tool.name for tool in tools],
)
agent_executor = AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
verbose=langchain_verbose,
max_iterations=2 * MAX_STEPS * context.max_votes + 1)
agent_iterator = agent_executor.iter(inputs=task)
# append to history for the debaters
context.generation_observation_history.append('Task: ' + task)
result_dict = dict()
result_dict['task'] = task
result_dict['task_index'] = task_index
result_dict['success'] = False
total_steps = 0
for step_num, step in enumerate(agent_iterator):
# intermediate_step is a (action, observation) pair
prev_ob = step.get('intermediate_step')
if prev_ob:
a, o = prev_ob[-1]
if not o:
break
if FAIL_OBSERVATION in o:
total_steps += 1
break
elif SUCCESS_OBSERVATION in o:
total_steps += 1
result_dict['success'] = True
break
elif EMPTY_RESPONSE not in o:
total_steps += 1
else:
# print("HERE")
# print(step)
break
result_dict['total_steps'] = total_steps
# the number of times take_environment_action was called
result_dict['total_actions'] = context.action_count
result_dict['total_debates'] = context.debate_count
result_dict['token_count'] = context.token_count
results.append(result_dict)
# save the results every time, so we don't lose anything
results_dir = f'./results/{timestamp}/'
filename = f"{results_dir}results_{timestamp}.json"
if not os.path.exists(results_dir):
os.makedirs(results_dir)
# put back system hint mod because we popped it
if 'debate_params' in exp:
exp['debate_params']['system_hint_mod'] = system_hint_mod
extended_results = {
'description': description,
'params': exp,
'timestamp': timestamp,
'results': results
}
write_json_file(filename, extended_results)
# pop it again
if 'debate_params' in exp:
exp['debate_params'].pop('system_hint_mod')
return timestamp, filename
| [
"langchain.chains.LLMChain",
"langchain.llms.VertexAI",
"langchain.agents.AgentExecutor.from_agent_and_tools",
"langchain.schema.AgentFinish",
"langchain.schema.AgentAction",
"langchain.callbacks.FileCallbackHandler"
] | [((1046, 1098), 'os.makedirs', 'os.makedirs', (['f"""./results/{timestamp}"""'], {'exist_ok': '(True)'}), "(f'./results/{timestamp}', exist_ok=True)\n", (1057, 1098), False, 'import os\n'), ((1332, 1364), 'logging.getLogger', 'logging.getLogger', (['"""info_logger"""'], {}), "('info_logger')\n", (1349, 1364), False, 'import logging\n'), ((1424, 1458), 'logging.FileHandler', 'logging.FileHandler', (['info_filename'], {}), '(info_filename)\n', (1443, 1458), False, 'import logging\n'), ((1585, 1617), 'logging.Formatter', 'logging.Formatter', (['"""%(message)s"""'], {}), "('%(message)s')\n", (1602, 1617), False, 'import logging\n'), ((6381, 6452), 'langchain.schema.AgentFinish', 'AgentFinish', ([], {'return_values': "{'output': 'Task finished.'}", 'log': 'llm_output'}), "(return_values={'output': 'Task finished.'}, log=llm_output)\n", (6392, 6452), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n'), ((10667, 10702), 'langchain.callbacks.FileCallbackHandler', 'FileCallbackHandler', (['debug_filename'], {}), '(debug_filename)\n', (10686, 10702), False, 'from langchain.callbacks import FileCallbackHandler\n'), ((14195, 14269), 'langchain.llms.VertexAI', 'VertexAI', ([], {'model_name': 'model', 'temperature': 'temperature', 'max_output_tokens': '(256)'}), '(model_name=model, temperature=temperature, max_output_tokens=256)\n', (14203, 14269), False, 'from langchain.llms import VertexAI\n'), ((14429, 14482), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt', 'callbacks': 'callbacks'}), '(llm=llm, prompt=prompt, callbacks=callbacks)\n', (14437, 14482), False, 'from langchain.chains import LLMChain\n'), ((14802, 14948), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'agent', 'tools': 'tools', 'verbose': 'langchain_verbose', 'max_iterations': '(2 * MAX_STEPS * context.max_votes + 1)'}), '(agent=agent, tools=tools, verbose=\n langchain_verbose, max_iterations=2 * MAX_STEPS * context.max_votes + 1)\n', (14836, 14948), False, 'from langchain.agents import AgentExecutor, LLMSingleActionAgent, AgentOutputParser\n'), ((997, 1011), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1009, 1011), False, 'from datetime import datetime\n'), ((6714, 6755), 're.search', 're.search', (['pattern', 'llm_output', 're.DOTALL'], {}), '(pattern, llm_output, re.DOTALL)\n', (6723, 6755), False, 'import re\n'), ((7875, 7965), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'TAKE_ENVIRONMENT_ACTION', 'tool_input': '"""empty param"""', 'log': '"""empty tool"""'}), "(tool=TAKE_ENVIRONMENT_ACTION, tool_input='empty param', log=\n 'empty tool')\n", (7886, 7965), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n'), ((11956, 11996), 'tools.take_environment_action_wrapper', 'take_environment_action_wrapper', (['context'], {}), '(context)\n', (11987, 11996), False, 'from tools import take_environment_action_wrapper\n'), ((16594, 16621), 'os.path.exists', 'os.path.exists', (['results_dir'], {}), '(results_dir)\n', (16608, 16621), False, 'import os\n'), ((16635, 16659), 'os.makedirs', 'os.makedirs', (['results_dir'], {}), '(results_dir)\n', (16646, 16659), False, 'import os\n'), ((1290, 1311), 'logging.NullHandler', 'logging.NullHandler', ([], {}), '()\n', (1309, 1311), False, 'import logging\n'), ((12054, 12119), 'debate.view_debate_wrapper', 'view_debate_wrapper', (['context'], {'logger': 'info_logger'}), '(context, **debate_params, logger=info_logger)\n', (12073, 12119), False, 'from debate import view_debate_wrapper\n'), ((8911, 9007), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'majority_tool_name', 'tool_input': 'majority_tool_input', 'log': 'random_llm_output'}), '(tool=majority_tool_name, tool_input=majority_tool_input, log=\n random_llm_output)\n', (8922, 9007), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n'), ((9578, 9674), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'majority_tool_name', 'tool_input': 'majority_tool_input', 'log': 'random_llm_output'}), '(tool=majority_tool_name, tool_input=majority_tool_input, log=\n random_llm_output)\n', (9589, 9674), False, 'from langchain.schema import AgentAction, AgentFinish, BaseMessage, LLMResult\n')] |
"""Base interface that all chains should implement."""
import inspect
import json
import logging
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import Field, root_validator, validator
import langchain
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForChainRun,
CallbackManager,
CallbackManagerForChainRun,
Callbacks,
)
from langchain.load.dump import dumpd
from langchain.load.serializable import Serializable
from langchain.schema import RUN_KEY, BaseMemory, RunInfo
logger = logging.getLogger(__name__)
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(Serializable, ABC):
"""Abstract base class for creating structured sequences of calls to components.
Chains should be used to encode a sequence of calls to components like
models, document retrievers, other chains, etc., and provide a simple interface
to this sequence.
The Chain interface makes it easy to create apps that are:
- Stateful: add Memory to any Chain to give it state,
- Observable: pass Callbacks to a Chain to execute additional functionality,
like logging, outside the main sequence of component calls,
- Composable: the Chain API is flexible enough that it is easy to combine
Chains with other components, including other Chains.
The main methods exposed by chains are:
- `__call__`: Chains are callable. The `__call__` method is the primary way to
execute a Chain. This takes inputs as a dictionary and returns a
dictionary output.
- `run`: A convenience method that takes inputs as args/kwargs and returns the
output as a string. This method can only be used for a subset of chains and
cannot return as rich of an output as `__call__`.
"""
memory: Optional[BaseMemory] = None
"""Optional memory object. Defaults to None.
Memory is a class that gets called at the start
and at the end of every chain. At the start, memory loads variables and passes
them along in the chain. At the end, it saves any returned variables.
There are many different types of memory - please see memory docs
for the full catalog."""
callbacks: Callbacks = Field(default=None, exclude=True)
"""Optional list of callback handlers (or callback manager). Defaults to None.
Callback handlers are called throughout the lifecycle of a call to a chain,
starting with on_chain_start, ending with on_chain_end or on_chain_error.
Each custom chain can optionally call additional callback methods, see Callback docs
for full details."""
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
"""Deprecated, use `callbacks` instead."""
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether or not run in verbose mode. In verbose mode, some intermediate logs
will be printed to the console. Defaults to `langchain.verbose` value."""
tags: Optional[List[str]] = None
"""Optional list of tags associated with the chain. Defaults to None
These tags will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
metadata: Optional[Dict[str, Any]] = None
"""Optional metadata associated with the chain. Defaults to None
This metadata will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@root_validator()
def raise_callback_manager_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""Set the chain verbosity.
Defaults to the global setting if not specified by the user.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Return the keys expected to be in the chain input."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Return the keys expected to be in the chain output."""
def _validate_inputs(self, inputs: Dict[str, Any]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, Any]) -> None:
missing_keys = set(self.output_keys).difference(outputs)
if missing_keys:
raise ValueError(f"Missing some output keys: {missing_keys}")
@abstractmethod
def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.__call__`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
async def _acall(
self,
inputs: Dict[str, Any],
run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.acall`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = CallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
run_manager = callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
self._call(inputs, run_manager=run_manager)
if new_arg_supported
else self._call(inputs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise e
run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
async def acall(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = AsyncCallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
run_manager = await callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
await self._acall(inputs, run_manager=run_manager)
if new_arg_supported
else await self._acall(inputs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise e
await run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prepare chain outputs, and save info about this run to memory.
Args:
inputs: Dictionary of chain inputs, including any inputs added by chain
memory.
outputs: Dictionary of initial chain outputs.
return_only_outputs: Whether to only return the chain outputs. If False,
inputs are also added to the final outputs.
Returns:
A dict of the final chain outputs.
"""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prepare chain inputs, including adding inputs from memory.
Args:
inputs: Dictionary of raw inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
Returns:
A dictionary of all inputs, including those added by the chain's memory.
"""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
@property
def _run_output_key(self) -> str:
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
return self.output_keys[0]
def run(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."
"""
# Run at start to make sure this is possible/defined
_output_key = self._run_output_key
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if kwargs and not args:
return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if not kwargs and not args:
raise ValueError(
"`run` supported with either positional arguments or keyword arguments,"
" but none were provided."
)
else:
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
await chain.arun("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
await chain.arun(question=question, context=context)
# -> "The temperature in Boise is..."
"""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
elif args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (
await self.acall(
args[0], callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
if kwargs and not args:
return (
await self.acall(
kwargs, callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
**kwargs: Keyword arguments passed to default `pydantic.BaseModel.dict`
method.
Returns:
A dictionary representation of the chain.
Example:
..code-block:: python
chain.dict(exclude_unset=True)
# -> {"_type": "foo", "verbose": False, ...}
"""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict(**kwargs)
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
def apply(
self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs, callbacks=callbacks) for inputs in input_list]
| [
"langchain.load.dump.dumpd",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.schema.RunInfo",
"langchain.callbacks.manager.CallbackManager.configure"
] | [((702, 729), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (719, 729), False, 'import logging\n'), ((2435, 2468), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2440, 2468), False, 'from pydantic import Field, root_validator, validator\n'), ((2878, 2911), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2883, 2911), False, 'from pydantic import Field, root_validator, validator\n'), ((2979, 3016), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2984, 3016), False, 'from pydantic import Field, root_validator, validator\n'), ((4107, 4123), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (4121, 4123), False, 'from pydantic import Field, root_validator, validator\n'), ((4576, 4619), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (4585, 4619), False, 'from pydantic import Field, root_validator, validator\n'), ((9402, 9514), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose, tags,\n self.tags, metadata, self.metadata)\n', (9427, 9514), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((12243, 12360), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose,\n tags, self.tags, metadata, self.metadata)\n', (12273, 12360), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((4331, 4433), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (4344, 4433), False, 'import warnings\n'), ((9761, 9772), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (9766, 9772), False, 'from langchain.load.dump import dumpd\n'), ((10332, 10366), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (10339, 10366), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((13211, 13245), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (13218, 13245), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((23986, 24001), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (23990, 24001), False, 'from pathlib import Path\n'), ((12614, 12625), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (12619, 12625), False, 'from langchain.load.dump import dumpd\n'), ((24321, 24355), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (24330, 24355), False, 'import json\n'), ((9634, 9663), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (9651, 9663), False, 'import inspect\n'), ((12480, 12510), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (12497, 12510), False, 'import inspect\n'), ((24458, 24508), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (24467, 24508), False, 'import yaml\n')] |
"""Base interface that all chains should implement."""
import inspect
import json
import logging
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import Field, root_validator, validator
import langchain
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForChainRun,
CallbackManager,
CallbackManagerForChainRun,
Callbacks,
)
from langchain.load.dump import dumpd
from langchain.load.serializable import Serializable
from langchain.schema import RUN_KEY, BaseMemory, RunInfo
logger = logging.getLogger(__name__)
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(Serializable, ABC):
"""Abstract base class for creating structured sequences of calls to components.
Chains should be used to encode a sequence of calls to components like
models, document retrievers, other chains, etc., and provide a simple interface
to this sequence.
The Chain interface makes it easy to create apps that are:
- Stateful: add Memory to any Chain to give it state,
- Observable: pass Callbacks to a Chain to execute additional functionality,
like logging, outside the main sequence of component calls,
- Composable: the Chain API is flexible enough that it is easy to combine
Chains with other components, including other Chains.
The main methods exposed by chains are:
- `__call__`: Chains are callable. The `__call__` method is the primary way to
execute a Chain. This takes inputs as a dictionary and returns a
dictionary output.
- `run`: A convenience method that takes inputs as args/kwargs and returns the
output as a string. This method can only be used for a subset of chains and
cannot return as rich of an output as `__call__`.
"""
memory: Optional[BaseMemory] = None
"""Optional memory object. Defaults to None.
Memory is a class that gets called at the start
and at the end of every chain. At the start, memory loads variables and passes
them along in the chain. At the end, it saves any returned variables.
There are many different types of memory - please see memory docs
for the full catalog."""
callbacks: Callbacks = Field(default=None, exclude=True)
"""Optional list of callback handlers (or callback manager). Defaults to None.
Callback handlers are called throughout the lifecycle of a call to a chain,
starting with on_chain_start, ending with on_chain_end or on_chain_error.
Each custom chain can optionally call additional callback methods, see Callback docs
for full details."""
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
"""Deprecated, use `callbacks` instead."""
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether or not run in verbose mode. In verbose mode, some intermediate logs
will be printed to the console. Defaults to `langchain.verbose` value."""
tags: Optional[List[str]] = None
"""Optional list of tags associated with the chain. Defaults to None
These tags will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
metadata: Optional[Dict[str, Any]] = None
"""Optional metadata associated with the chain. Defaults to None
This metadata will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@root_validator()
def raise_callback_manager_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""Set the chain verbosity.
Defaults to the global setting if not specified by the user.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Return the keys expected to be in the chain input."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Return the keys expected to be in the chain output."""
def _validate_inputs(self, inputs: Dict[str, Any]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, Any]) -> None:
missing_keys = set(self.output_keys).difference(outputs)
if missing_keys:
raise ValueError(f"Missing some output keys: {missing_keys}")
@abstractmethod
def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.__call__`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
async def _acall(
self,
inputs: Dict[str, Any],
run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.acall`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = CallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
run_manager = callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
self._call(inputs, run_manager=run_manager)
if new_arg_supported
else self._call(inputs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise e
run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
async def acall(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = AsyncCallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
run_manager = await callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
await self._acall(inputs, run_manager=run_manager)
if new_arg_supported
else await self._acall(inputs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise e
await run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prepare chain outputs, and save info about this run to memory.
Args:
inputs: Dictionary of chain inputs, including any inputs added by chain
memory.
outputs: Dictionary of initial chain outputs.
return_only_outputs: Whether to only return the chain outputs. If False,
inputs are also added to the final outputs.
Returns:
A dict of the final chain outputs.
"""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prepare chain inputs, including adding inputs from memory.
Args:
inputs: Dictionary of raw inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
Returns:
A dictionary of all inputs, including those added by the chain's memory.
"""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
@property
def _run_output_key(self) -> str:
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
return self.output_keys[0]
def run(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."
"""
# Run at start to make sure this is possible/defined
_output_key = self._run_output_key
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if kwargs and not args:
return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if not kwargs and not args:
raise ValueError(
"`run` supported with either positional arguments or keyword arguments,"
" but none were provided."
)
else:
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
await chain.arun("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
await chain.arun(question=question, context=context)
# -> "The temperature in Boise is..."
"""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
elif args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (
await self.acall(
args[0], callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
if kwargs and not args:
return (
await self.acall(
kwargs, callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
**kwargs: Keyword arguments passed to default `pydantic.BaseModel.dict`
method.
Returns:
A dictionary representation of the chain.
Example:
..code-block:: python
chain.dict(exclude_unset=True)
# -> {"_type": "foo", "verbose": False, ...}
"""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict(**kwargs)
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
def apply(
self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs, callbacks=callbacks) for inputs in input_list]
| [
"langchain.load.dump.dumpd",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.schema.RunInfo",
"langchain.callbacks.manager.CallbackManager.configure"
] | [((702, 729), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (719, 729), False, 'import logging\n'), ((2435, 2468), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2440, 2468), False, 'from pydantic import Field, root_validator, validator\n'), ((2878, 2911), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2883, 2911), False, 'from pydantic import Field, root_validator, validator\n'), ((2979, 3016), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2984, 3016), False, 'from pydantic import Field, root_validator, validator\n'), ((4107, 4123), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (4121, 4123), False, 'from pydantic import Field, root_validator, validator\n'), ((4576, 4619), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (4585, 4619), False, 'from pydantic import Field, root_validator, validator\n'), ((9402, 9514), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose, tags,\n self.tags, metadata, self.metadata)\n', (9427, 9514), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((12243, 12360), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose,\n tags, self.tags, metadata, self.metadata)\n', (12273, 12360), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((4331, 4433), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (4344, 4433), False, 'import warnings\n'), ((9761, 9772), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (9766, 9772), False, 'from langchain.load.dump import dumpd\n'), ((10332, 10366), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (10339, 10366), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((13211, 13245), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (13218, 13245), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((23986, 24001), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (23990, 24001), False, 'from pathlib import Path\n'), ((12614, 12625), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (12619, 12625), False, 'from langchain.load.dump import dumpd\n'), ((24321, 24355), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (24330, 24355), False, 'import json\n'), ((9634, 9663), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (9651, 9663), False, 'import inspect\n'), ((12480, 12510), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (12497, 12510), False, 'import inspect\n'), ((24458, 24508), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (24467, 24508), False, 'import yaml\n')] |
"""Base interface that all chains should implement."""
import inspect
import json
import logging
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import Field, root_validator, validator
import langchain
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForChainRun,
CallbackManager,
CallbackManagerForChainRun,
Callbacks,
)
from langchain.load.dump import dumpd
from langchain.load.serializable import Serializable
from langchain.schema import RUN_KEY, BaseMemory, RunInfo
logger = logging.getLogger(__name__)
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(Serializable, ABC):
"""Abstract base class for creating structured sequences of calls to components.
Chains should be used to encode a sequence of calls to components like
models, document retrievers, other chains, etc., and provide a simple interface
to this sequence.
The Chain interface makes it easy to create apps that are:
- Stateful: add Memory to any Chain to give it state,
- Observable: pass Callbacks to a Chain to execute additional functionality,
like logging, outside the main sequence of component calls,
- Composable: the Chain API is flexible enough that it is easy to combine
Chains with other components, including other Chains.
The main methods exposed by chains are:
- `__call__`: Chains are callable. The `__call__` method is the primary way to
execute a Chain. This takes inputs as a dictionary and returns a
dictionary output.
- `run`: A convenience method that takes inputs as args/kwargs and returns the
output as a string. This method can only be used for a subset of chains and
cannot return as rich of an output as `__call__`.
"""
memory: Optional[BaseMemory] = None
"""Optional memory object. Defaults to None.
Memory is a class that gets called at the start
and at the end of every chain. At the start, memory loads variables and passes
them along in the chain. At the end, it saves any returned variables.
There are many different types of memory - please see memory docs
for the full catalog."""
callbacks: Callbacks = Field(default=None, exclude=True)
"""Optional list of callback handlers (or callback manager). Defaults to None.
Callback handlers are called throughout the lifecycle of a call to a chain,
starting with on_chain_start, ending with on_chain_end or on_chain_error.
Each custom chain can optionally call additional callback methods, see Callback docs
for full details."""
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
"""Deprecated, use `callbacks` instead."""
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether or not run in verbose mode. In verbose mode, some intermediate logs
will be printed to the console. Defaults to `langchain.verbose` value."""
tags: Optional[List[str]] = None
"""Optional list of tags associated with the chain. Defaults to None
These tags will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
metadata: Optional[Dict[str, Any]] = None
"""Optional metadata associated with the chain. Defaults to None
This metadata will be associated with each call to this chain,
and passed as arguments to the handlers defined in `callbacks`.
You can use these to eg identify a specific instance of a chain with its use case.
"""
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@root_validator()
def raise_callback_manager_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""Set the chain verbosity.
Defaults to the global setting if not specified by the user.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Return the keys expected to be in the chain input."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Return the keys expected to be in the chain output."""
def _validate_inputs(self, inputs: Dict[str, Any]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, Any]) -> None:
missing_keys = set(self.output_keys).difference(outputs)
if missing_keys:
raise ValueError(f"Missing some output keys: {missing_keys}")
@abstractmethod
def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.__call__`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
async def _acall(
self,
inputs: Dict[str, Any],
run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
This is a private method that is not user-facing. It is only called within
`Chain.acall`, which is the user-facing wrapper method that handles
callbacks configuration and some input/output processing.
Args:
inputs: A dict of named inputs to the chain. Assumed to contain all inputs
specified in `Chain.input_keys`, including any inputs added by memory.
run_manager: The callbacks manager that contains the callback handlers for
this run of the chain.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = CallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
run_manager = callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
self._call(inputs, run_manager=run_manager)
if new_arg_supported
else self._call(inputs)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_chain_error(e)
raise e
run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
async def acall(
self,
inputs: Union[Dict[str, Any], Any],
return_only_outputs: bool = False,
callbacks: Callbacks = None,
*,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
include_run_info: bool = False,
) -> Dict[str, Any]:
"""Asynchronously execute the chain.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
return_only_outputs: Whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
metadata: Optional metadata associated with the chain. Defaults to None
include_run_info: Whether to include run info in the response. Defaults
to False.
Returns:
A dict of named outputs. Should contain all outputs specified in
`Chain.output_keys`.
"""
inputs = self.prep_inputs(inputs)
callback_manager = AsyncCallbackManager.configure(
callbacks,
self.callbacks,
self.verbose,
tags,
self.tags,
metadata,
self.metadata,
)
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
run_manager = await callback_manager.on_chain_start(
dumpd(self),
inputs,
)
try:
outputs = (
await self._acall(inputs, run_manager=run_manager)
if new_arg_supported
else await self._acall(inputs)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_chain_error(e)
raise e
await run_manager.on_chain_end(outputs)
final_outputs: Dict[str, Any] = self.prep_outputs(
inputs, outputs, return_only_outputs
)
if include_run_info:
final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
return final_outputs
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prepare chain outputs, and save info about this run to memory.
Args:
inputs: Dictionary of chain inputs, including any inputs added by chain
memory.
outputs: Dictionary of initial chain outputs.
return_only_outputs: Whether to only return the chain outputs. If False,
inputs are also added to the final outputs.
Returns:
A dict of the final chain outputs.
"""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prepare chain inputs, including adding inputs from memory.
Args:
inputs: Dictionary of raw inputs, or single input if chain expects
only one param. Should contain all inputs specified in
`Chain.input_keys` except for inputs that will be set by the chain's
memory.
Returns:
A dictionary of all inputs, including those added by the chain's memory.
"""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
@property
def _run_output_key(self) -> str:
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
return self.output_keys[0]
def run(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
chain.run("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
chain.run(question=question, context=context)
# -> "The temperature in Boise is..."
"""
# Run at start to make sure this is possible/defined
_output_key = self._run_output_key
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if kwargs and not args:
return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
_output_key
]
if not kwargs and not args:
raise ValueError(
"`run` supported with either positional arguments or keyword arguments,"
" but none were provided."
)
else:
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(
self,
*args: Any,
callbacks: Callbacks = None,
tags: Optional[List[str]] = None,
metadata: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> str:
"""Convenience method for executing chain when there's a single string output.
The main difference between this method and `Chain.__call__` is that this method
can only be used for chains that return a single string output. If a Chain
has more outputs, a non-string output, or you want to return the inputs/run
info along with the outputs, use `Chain.__call__`.
The other difference is that this method expects inputs to be passed directly in
as positional arguments or keyword arguments, whereas `Chain.__call__` expects
a single input dictionary with all the inputs.
Args:
*args: If the chain expects a single input, it can be passed in as the
sole positional argument.
callbacks: Callbacks to use for this chain run. These will be called in
addition to callbacks passed to the chain during construction, but only
these runtime callbacks will propagate to calls to other objects.
tags: List of string tags to pass to all callbacks. These will be passed in
addition to tags passed to the chain during construction, but only
these runtime tags will propagate to calls to other objects.
**kwargs: If the chain expects multiple inputs, they can be passed in
directly as keyword arguments.
Returns:
The chain output as a string.
Example:
.. code-block:: python
# Suppose we have a single-input chain that takes a 'question' string:
await chain.arun("What's the temperature in Boise, Idaho?")
# -> "The temperature in Boise is..."
# Suppose we have a multi-input chain that takes a 'question' string
# and 'context' string:
question = "What's the temperature in Boise, Idaho?"
context = "Weather report for Boise, Idaho on 07/03/23..."
await chain.arun(question=question, context=context)
# -> "The temperature in Boise is..."
"""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
elif args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (
await self.acall(
args[0], callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
if kwargs and not args:
return (
await self.acall(
kwargs, callbacks=callbacks, tags=tags, metadata=metadata
)
)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
**kwargs: Keyword arguments passed to default `pydantic.BaseModel.dict`
method.
Returns:
A dictionary representation of the chain.
Example:
..code-block:: python
chain.dict(exclude_unset=True)
# -> {"_type": "foo", "verbose": False, ...}
"""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict(**kwargs)
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Expects `Chain._chain_type` property to be implemented and for memory to be
null.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
def apply(
self, input_list: List[Dict[str, Any]], callbacks: Callbacks = None
) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs, callbacks=callbacks) for inputs in input_list]
| [
"langchain.load.dump.dumpd",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.schema.RunInfo",
"langchain.callbacks.manager.CallbackManager.configure"
] | [((702, 729), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (719, 729), False, 'import logging\n'), ((2435, 2468), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2440, 2468), False, 'from pydantic import Field, root_validator, validator\n'), ((2878, 2911), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2883, 2911), False, 'from pydantic import Field, root_validator, validator\n'), ((2979, 3016), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2984, 3016), False, 'from pydantic import Field, root_validator, validator\n'), ((4107, 4123), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (4121, 4123), False, 'from pydantic import Field, root_validator, validator\n'), ((4576, 4619), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (4585, 4619), False, 'from pydantic import Field, root_validator, validator\n'), ((9402, 9514), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose, tags,\n self.tags, metadata, self.metadata)\n', (9427, 9514), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((12243, 12360), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose', 'tags', 'self.tags', 'metadata', 'self.metadata'], {}), '(callbacks, self.callbacks, self.verbose,\n tags, self.tags, metadata, self.metadata)\n', (12273, 12360), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForChainRun, CallbackManager, CallbackManagerForChainRun, Callbacks\n'), ((4331, 4433), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (4344, 4433), False, 'import warnings\n'), ((9761, 9772), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (9766, 9772), False, 'from langchain.load.dump import dumpd\n'), ((10332, 10366), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (10339, 10366), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((13211, 13245), 'langchain.schema.RunInfo', 'RunInfo', ([], {'run_id': 'run_manager.run_id'}), '(run_id=run_manager.run_id)\n', (13218, 13245), False, 'from langchain.schema import RUN_KEY, BaseMemory, RunInfo\n'), ((23986, 24001), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (23990, 24001), False, 'from pathlib import Path\n'), ((12614, 12625), 'langchain.load.dump.dumpd', 'dumpd', (['self'], {}), '(self)\n', (12619, 12625), False, 'from langchain.load.dump import dumpd\n'), ((24321, 24355), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (24330, 24355), False, 'import json\n'), ((9634, 9663), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (9651, 9663), False, 'import inspect\n'), ((12480, 12510), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (12497, 12510), False, 'import inspect\n'), ((24458, 24508), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (24467, 24508), False, 'import yaml\n')] |
"""Utilities for running language models or Chains over datasets."""
from __future__ import annotations
import functools
import inspect
import logging
import uuid
from enum import Enum
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Sequence,
Tuple,
Union,
cast,
)
from langsmith.client import Client
from langsmith.evaluation import RunEvaluator
from langsmith.run_helpers import as_runnable, is_traceable_function
from langsmith.schemas import Dataset, DataType, Example
from langsmith.utils import LangSmithError
from requests import HTTPError
from langchain._api import warn_deprecated
from langchain.callbacks.manager import Callbacks
from langchain.callbacks.tracers.evaluation import (
EvaluatorCallbackHandler,
wait_for_all_evaluators,
)
from langchain.callbacks.tracers.langchain import LangChainTracer
from langchain.chains.base import Chain
from langchain.evaluation.loading import load_evaluator
from langchain.evaluation.schema import (
EvaluatorType,
PairwiseStringEvaluator,
StringEvaluator,
)
from langchain.schema import ChatResult, LLMResult
from langchain.schema.language_model import BaseLanguageModel
from langchain.schema.messages import BaseMessage, messages_from_dict
from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda
from langchain.schema.runnable import config as runnable_config
from langchain.schema.runnable import utils as runnable_utils
from langchain.smith import evaluation as smith_eval
from langchain.smith.evaluation import config as smith_eval_config
from langchain.smith.evaluation import name_generation, progress
if TYPE_CHECKING:
import pandas as pd
logger = logging.getLogger(__name__)
MODEL_OR_CHAIN_FACTORY = Union[
Callable[[], Union[Chain, Runnable]],
BaseLanguageModel,
Callable[[dict], Any],
Runnable,
Chain,
]
MCF = Union[Callable[[], Union[Chain, Runnable]], BaseLanguageModel]
class InputFormatError(Exception):
"""Raised when the input format is invalid."""
## Shared Utilities
class TestResult(dict):
"""A dictionary of the results of a single test run."""
def get_aggregate_feedback(
self, quantiles: Optional[Sequence[float]] = None
) -> pd.DataFrame:
"""Return quantiles for the feedback scores.
This method calculates and prints the quantiles for the feedback scores
across all feedback keys.
Returns:
A DataFrame containing the quantiles for each feedback key.
"""
df = self.to_dataframe()
feedback_cols = [
col for col in df.columns if col not in ["input", "output", "reference"]
]
_quantiles = df[feedback_cols].quantile(
quantiles or [0.25, 0.5, 0.75], numeric_only=True
)
_quantiles.loc["mean"] = df[feedback_cols].mean()
_quantiles.loc["mode"] = df[feedback_cols].mode().iloc[0]
return _quantiles.transpose()
def to_dataframe(self) -> pd.DataFrame:
"""Convert the results to a dataframe."""
try:
import pandas as pd
except ImportError as e:
raise ImportError(
"Pandas is required to convert the results to a dataframe."
" to install pandas, run `pip install pandas`."
) from e
indices = []
records = []
for example_id, result in self["results"].items():
feedback = result["feedback"]
r = {
**{f.key: f.score for f in feedback},
"input": result["input"],
"output": result["output"],
}
if "reference" in result:
r["reference"] = result["reference"]
records.append(r)
indices.append(example_id)
return pd.DataFrame(records, index=indices)
def _wrap_in_chain_factory(
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
dataset_name: str = "<my_dataset>",
) -> MCF:
"""Forgive the user if they pass in a chain without memory instead of a chain
factory. It's a common mistake. Raise a more helpful error message as well."""
if isinstance(llm_or_chain_factory, Chain):
chain = llm_or_chain_factory
chain_class = chain.__class__.__name__
if llm_or_chain_factory.memory is not None:
memory_class = chain.memory.__class__.__name__
raise ValueError(
"Cannot directly evaluate a chain with stateful memory."
" To evaluate this chain, pass in a chain constructor"
" that initializes fresh memory each time it is called."
" This will safegaurd against information"
" leakage between dataset examples."
"\nFor example:\n\n"
"def chain_constructor():\n"
f" new_memory = {memory_class}(...)\n"
f" return {chain_class}"
"(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
return lambda: chain
elif isinstance(llm_or_chain_factory, BaseLanguageModel):
return llm_or_chain_factory
elif isinstance(llm_or_chain_factory, Runnable):
# Memory may exist here, but it's not elegant to check all those cases.
lcf = llm_or_chain_factory
return lambda: lcf
elif callable(llm_or_chain_factory):
if is_traceable_function(llm_or_chain_factory):
runnable_ = as_runnable(cast(Callable, llm_or_chain_factory))
return lambda: runnable_
try:
_model = llm_or_chain_factory() # type: ignore[call-arg]
except TypeError:
# It's an arbitrary function, wrap it in a RunnableLambda
user_func = cast(Callable, llm_or_chain_factory)
sig = inspect.signature(user_func)
logger.info(f"Wrapping function {sig} as RunnableLambda.")
wrapped = RunnableLambda(user_func)
return lambda: wrapped
constructor = cast(Callable, llm_or_chain_factory)
if isinstance(_model, BaseLanguageModel):
# It's not uncommon to do an LLM constructor instead of raw LLM,
# so we'll unpack it for the user.
return _model
elif is_traceable_function(cast(Callable, _model)):
runnable_ = as_runnable(cast(Callable, _model))
return lambda: runnable_
elif not isinstance(_model, Runnable):
# This is unlikely to happen - a constructor for a model function
return lambda: RunnableLambda(constructor)
else:
# Typical correct case
return constructor # noqa
return llm_or_chain_factory
def _get_prompt(inputs: Dict[str, Any]) -> str:
"""Get prompt from inputs.
Args:
inputs: The input dictionary.
Returns:
A string prompt.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
prompts = []
if "prompt" in inputs:
if not isinstance(inputs["prompt"], str):
raise InputFormatError(
"Expected string for 'prompt', got"
f" {type(inputs['prompt']).__name__}"
)
prompts = [inputs["prompt"]]
elif "prompts" in inputs:
if not isinstance(inputs["prompts"], list) or not all(
isinstance(i, str) for i in inputs["prompts"]
):
raise InputFormatError(
"Expected list of strings for 'prompts',"
f" got {type(inputs['prompts']).__name__}"
)
prompts = inputs["prompts"]
elif len(inputs) == 1:
prompt_ = next(iter(inputs.values()))
if isinstance(prompt_, str):
prompts = [prompt_]
elif isinstance(prompt_, list) and all(isinstance(i, str) for i in prompt_):
prompts = prompt_
else:
raise InputFormatError(f"LLM Run expects string prompt input. Got {inputs}")
else:
raise InputFormatError(
f"LLM Run expects 'prompt' or 'prompts' in inputs. Got {inputs}"
)
if len(prompts) == 1:
return prompts[0]
else:
raise InputFormatError(
f"LLM Run expects single prompt input. Got {len(prompts)} prompts."
)
def _get_messages(inputs: Dict[str, Any]) -> List[BaseMessage]:
"""Get Chat Messages from inputs.
Args:
inputs: The input dictionary.
Returns:
A list of chat messages.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
if "messages" in inputs:
single_input = inputs["messages"]
elif len(inputs) == 1:
single_input = next(iter(inputs.values()))
else:
raise InputFormatError(
f"Chat Run expects 'messages' in inputs when example has multiple"
f" input keys. Got {inputs}"
)
if isinstance(single_input, list) and all(
isinstance(i, dict) for i in single_input
):
raw_messages = [single_input]
elif isinstance(single_input, list) and all(
isinstance(i, list) for i in single_input
):
raw_messages = single_input
else:
raise InputFormatError(
f"Chat Run expects List[dict] or List[List[dict]] values for"
f" 'messages' key input. Got {inputs}"
)
if len(raw_messages) == 1:
return messages_from_dict(raw_messages[0])
else:
raise InputFormatError(
f"Chat Run expects single List[dict] or List[List[dict]] 'messages'"
f" input. Got {len(raw_messages)} messages from inputs {inputs}"
)
## Shared data validation utilities
def _validate_example_inputs_for_language_model(
first_example: Example,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
if input_mapper:
prompt_input = input_mapper(first_example.inputs)
if not isinstance(prompt_input, str) and not (
isinstance(prompt_input, list)
and all(isinstance(msg, BaseMessage) for msg in prompt_input)
):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for an LLM or chat model, the output must a single string or"
" a list of chat messages."
f"\nGot: {prompt_input} of type {type(prompt_input)}."
)
else:
try:
_get_prompt(first_example.inputs)
except InputFormatError:
try:
_get_messages(first_example.inputs)
except InputFormatError:
raise InputFormatError(
"Example inputs do not match language model input format. "
"Expected a dictionary with messages or a single prompt."
f" Got: {first_example.inputs}"
" Please update your dataset OR provide an input_mapper"
" to convert the example.inputs to a compatible format"
" for the llm or chat model you wish to evaluate."
)
def _validate_example_inputs_for_chain(
first_example: Example,
chain: Chain,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs match the chain input keys."""
if input_mapper:
first_inputs = input_mapper(first_example.inputs)
missing_keys = set(chain.input_keys).difference(first_inputs)
if not isinstance(first_inputs, dict):
raise InputFormatError(
"When using an input_mapper to prepare dataset example"
" inputs for a chain, the mapped value must be a dictionary."
f"\nGot: {first_inputs} of type {type(first_inputs)}."
)
if missing_keys:
raise InputFormatError(
"Missing keys after loading example using input_mapper."
f"\nExpected: {chain.input_keys}. Got: {first_inputs.keys()}"
)
else:
first_inputs = first_example.inputs
missing_keys = set(chain.input_keys).difference(first_inputs)
if len(first_inputs) == 1 and len(chain.input_keys) == 1:
# We can pass this through the run method.
# Refrain from calling to validate.
pass
elif missing_keys:
raise InputFormatError(
"Example inputs missing expected chain input keys."
" Please provide an input_mapper to convert the example.inputs"
" to a compatible format for the chain you wish to evaluate."
f"Expected: {chain.input_keys}. "
f"Got: {first_inputs.keys()}"
)
def _validate_example_inputs(
example: Example,
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs are valid for the model."""
if isinstance(llm_or_chain_factory, BaseLanguageModel):
_validate_example_inputs_for_language_model(example, input_mapper)
else:
chain = llm_or_chain_factory()
if isinstance(chain, Chain):
# Otherwise it's a runnable
_validate_example_inputs_for_chain(example, chain, input_mapper)
elif isinstance(chain, Runnable):
logger.debug(f"Skipping input validation for {chain}")
## Shared Evaluator Setup Utilities
def _setup_evaluation(
llm_or_chain_factory: MCF,
examples: List[Example],
evaluation: Optional[smith_eval.RunEvalConfig],
data_type: DataType,
) -> Optional[List[RunEvaluator]]:
"""Configure the evaluators to run on the results of the chain."""
if evaluation:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
run_inputs, run_outputs = None, None
run_type = "llm"
else:
run_type = "chain"
if data_type in (DataType.chat, DataType.llm):
val = data_type.value if isinstance(data_type, Enum) else data_type
raise ValueError(
"Cannot evaluate a chain on dataset with "
f"data_type={val}. "
"Please specify a dataset with the default 'kv' data type."
)
chain = llm_or_chain_factory()
run_inputs = chain.input_keys if isinstance(chain, Chain) else None
run_outputs = chain.output_keys if isinstance(chain, Chain) else None
run_evaluators = _load_run_evaluators(
evaluation,
run_type,
data_type,
list(examples[0].outputs) if examples[0].outputs else None,
run_inputs,
run_outputs,
)
else:
# TODO: Create a default helpfulness evaluator
run_evaluators = None
return run_evaluators
def _determine_input_key(
config: smith_eval.RunEvalConfig,
run_inputs: Optional[List[str]],
) -> Optional[str]:
input_key = None
if config.input_key:
input_key = config.input_key
if run_inputs and input_key not in run_inputs:
raise ValueError(f"Input key {input_key} not in run inputs {run_inputs}")
elif run_inputs and len(run_inputs) == 1:
input_key = run_inputs[0]
elif run_inputs is not None and len(run_inputs) > 1:
raise ValueError(
f"Must specify input key for model with multiple inputs: {run_inputs}"
)
return input_key
def _determine_prediction_key(
config: smith_eval.RunEvalConfig,
run_outputs: Optional[List[str]],
) -> Optional[str]:
prediction_key = None
if config.prediction_key:
prediction_key = config.prediction_key
if run_outputs and prediction_key not in run_outputs:
raise ValueError(
f"Prediction key {prediction_key} not in run outputs {run_outputs}"
)
elif run_outputs and len(run_outputs) == 1:
prediction_key = run_outputs[0]
elif run_outputs is not None and len(run_outputs) > 1:
raise ValueError(
f"Must specify prediction key for model"
f" with multiple outputs: {run_outputs}"
)
return prediction_key
def _determine_reference_key(
config: smith_eval.RunEvalConfig,
example_outputs: Optional[List[str]],
) -> Optional[str]:
if config.reference_key:
reference_key = config.reference_key
if example_outputs and reference_key not in example_outputs:
raise ValueError(
f"Reference key {reference_key} not in Dataset"
f" example outputs: {example_outputs}"
)
elif example_outputs and len(example_outputs) == 1:
reference_key = list(example_outputs)[0]
else:
reference_key = None
return reference_key
def _construct_run_evaluator(
eval_config: Union[EvaluatorType, str, smith_eval_config.EvalConfig],
eval_llm: Optional[BaseLanguageModel],
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
reference_key: Optional[str],
input_key: Optional[str],
prediction_key: Optional[str],
) -> RunEvaluator:
if isinstance(eval_config, (EvaluatorType, str)):
if not isinstance(eval_config, EvaluatorType):
eval_config = EvaluatorType(eval_config)
evaluator_ = load_evaluator(eval_config, llm=eval_llm)
eval_type_tag = eval_config.value
else:
kwargs = {"llm": eval_llm, **eval_config.get_kwargs()}
evaluator_ = load_evaluator(eval_config.evaluator_type, **kwargs)
eval_type_tag = eval_config.evaluator_type.value
if isinstance(evaluator_, StringEvaluator):
if evaluator_.requires_reference and reference_key is None:
raise ValueError(
f"Must specify reference_key in smith_eval.RunEvalConfig to use"
f" evaluator of type {eval_type_tag} with"
f" dataset with multiple output keys: {example_outputs}."
)
run_evaluator = smith_eval.StringRunEvaluatorChain.from_run_and_data_type(
evaluator_,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
tags=[eval_type_tag],
)
elif isinstance(evaluator_, PairwiseStringEvaluator):
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented."
" PairwiseStringEvaluators compare the outputs of two different models"
" rather than the output of a single model."
" Did you mean to use a StringEvaluator instead?"
"\nSee: https://python.langchain.com/docs/guides/evaluation/string/"
)
else:
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented"
)
return run_evaluator
def _get_keys(
config: smith_eval.RunEvalConfig,
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
example_outputs: Optional[List[str]],
) -> Tuple[Optional[str], Optional[str], Optional[str]]:
input_key = _determine_input_key(config, run_inputs)
prediction_key = _determine_prediction_key(config, run_outputs)
reference_key = _determine_reference_key(config, example_outputs)
return input_key, prediction_key, reference_key
def _load_run_evaluators(
config: smith_eval.RunEvalConfig,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
) -> List[RunEvaluator]:
"""
Load run evaluators from a configuration.
Args:
config: Configuration for the run evaluators.
Returns:
A list of run evaluators.
"""
run_evaluators = []
input_key, prediction_key, reference_key = None, None, None
if (
config.evaluators
or any([isinstance(e, EvaluatorType) for e in config.evaluators])
or (
config.custom_evaluators
and any([isinstance(e, StringEvaluator) for e in config.custom_evaluators])
)
):
input_key, prediction_key, reference_key = _get_keys(
config, run_inputs, run_outputs, example_outputs
)
for eval_config in config.evaluators:
run_evaluator = _construct_run_evaluator(
eval_config,
config.eval_llm,
run_type,
data_type,
example_outputs,
reference_key,
input_key,
prediction_key,
)
run_evaluators.append(run_evaluator)
custom_evaluators = config.custom_evaluators or []
for custom_evaluator in custom_evaluators:
if isinstance(custom_evaluator, RunEvaluator):
run_evaluators.append(custom_evaluator)
elif isinstance(custom_evaluator, StringEvaluator):
run_evaluators.append(
smith_eval.StringRunEvaluatorChain.from_run_and_data_type(
custom_evaluator,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
)
)
else:
raise ValueError(
f"Unsupported custom evaluator: {custom_evaluator}."
f" Expected RunEvaluator or StringEvaluator."
)
return run_evaluators
### Async Helpers
async def _arun_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
*,
tags: Optional[List[str]] = None,
callbacks: Callbacks = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""Asynchronously run the language model.
Args:
llm: The language model to run.
inputs: The input dictionary.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map inputs to the expected format.
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
return await llm.apredict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
return await llm.apredict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format"
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
prompt = _get_prompt(inputs)
llm_output: Union[str, BaseMessage] = await llm.apredict(
prompt, callbacks=callbacks, tags=tags
)
except InputFormatError:
messages = _get_messages(inputs)
llm_output = await llm.apredict_messages(
messages, callbacks=callbacks, tags=tags
)
return llm_output
async def _arun_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str]:
"""Run a chain asynchronously on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if (
isinstance(chain, Chain)
and isinstance(inputs_, dict)
and len(inputs_) == 1
and chain.input_keys
):
val = next(iter(inputs_.values()))
output = await chain.acall(val, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = await chain.ainvoke(inputs_, config=runnable_config)
return output
async def _arun_llm_or_chain(
example: Example,
config: RunnableConfig,
*,
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""Asynchronously run the Chain or language model.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map the input to the expected format.
Returns:
A list of outputs.
"""
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = await _arun_llm(
llm_or_chain_factory,
example.inputs,
tags=config["tags"],
callbacks=config["callbacks"],
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = await _arun_chain(
chain,
example.inputs,
tags=config["tags"],
callbacks=config["callbacks"],
input_mapper=input_mapper,
)
result = output
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id} "
f"with inputs {example.inputs}"
f"\n{repr(e)}"
)
result = {"Error": repr(e)}
return result
## Sync Utilities
def _run_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""
Run the language model on the example.
Args:
llm: The language model to run.
inputs: The input dictionary.
callbacks: The callbacks to use during the run.
tags: Optional tags to add to the run.
input_mapper: function to map to the inputs dictionary from an Example
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
llm_output: Union[str, BaseMessage] = llm.predict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
llm_output = llm.predict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format: "
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
llm_prompts = _get_prompt(inputs)
llm_output = llm.predict(llm_prompts, callbacks=callbacks, tags=tags)
except InputFormatError:
llm_messages = _get_messages(inputs)
llm_output = llm.predict_messages(llm_messages, callbacks=callbacks)
return llm_output
def _run_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[Dict, str]:
"""Run a chain on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if (
isinstance(chain, Chain)
and isinstance(inputs_, dict)
and len(inputs_) == 1
and chain.input_keys
):
val = next(iter(inputs_.values()))
output = chain(val, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = chain.invoke(inputs_, config=runnable_config)
return output
def _run_llm_or_chain(
example: Example,
config: RunnableConfig,
*,
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""
Run the Chain or language model synchronously.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
Returns:
Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
The outputs of the model or chain.
"""
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = _run_llm(
llm_or_chain_factory,
example.inputs,
config["callbacks"],
tags=config["tags"],
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = _run_chain(
chain,
example.inputs,
config["callbacks"],
tags=config["tags"],
input_mapper=input_mapper,
)
result = output
except Exception as e:
error_type = type(e).__name__
logger.warning(
f"{chain_or_llm} failed for example {example.id} "
f"with inputs {example.inputs}"
f"\nError Type: {error_type}, Message: {e}"
)
result = {"Error": repr(e)}
return result
## Public API
def _prepare_eval_run(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: str,
project_metadata: Optional[Dict[str, Any]] = None,
) -> Tuple[MCF, str, Dataset, List[Example]]:
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory, dataset_name)
dataset = client.read_dataset(dataset_name=dataset_name)
try:
project = client.create_project(
project_name,
reference_dataset_id=dataset.id,
project_extra={"metadata": project_metadata} if project_metadata else {},
)
except (HTTPError, ValueError, LangSmithError) as e:
if "already exists " not in str(e):
raise e
uid = uuid.uuid4()
example_msg = f"""
run_on_dataset(
...
project_name="{project_name} - {uid}", # Update since {project_name} already exists
)
"""
raise ValueError(
f"Test project {project_name} already exists. Please use a different name:"
f"\n\n{example_msg}"
)
print(
f"View the evaluation results for project '{project_name}'"
f" at:\n{project.url}?eval=true\n\n"
f"View all tests for Dataset {dataset_name} at:\n{dataset.url}",
flush=True,
)
examples = list(client.list_examples(dataset_id=dataset.id))
if not examples:
raise ValueError(f"Dataset {dataset_name} has no example rows.")
return wrapped_model, project_name, dataset, examples
def _prepare_run_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: Optional[str],
evaluation: Optional[smith_eval.RunEvalConfig] = None,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
concurrency_level: int = 5,
project_metadata: Optional[Dict[str, Any]] = None,
) -> Tuple[MCF, str, List[Example], List[RunnableConfig]]:
project_name = project_name or name_generation.random_name()
wrapped_model, project_name, dataset, examples = _prepare_eval_run(
client,
dataset_name,
llm_or_chain_factory,
project_name,
project_metadata=project_metadata,
)
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory)
run_evaluators = _setup_evaluation(
wrapped_model, examples, evaluation, dataset.data_type or DataType.kv
)
_validate_example_inputs(examples[0], wrapped_model, input_mapper)
progress_bar = progress.ProgressBarCallback(len(examples))
configs = [
RunnableConfig(
callbacks=[
LangChainTracer(
project_name=project_name,
client=client,
use_threading=False,
example_id=example.id,
),
EvaluatorCallbackHandler(
evaluators=run_evaluators or [],
client=client,
example_id=example.id,
),
progress_bar,
],
tags=tags or [],
max_concurrency=concurrency_level,
)
for example in examples
]
return wrapped_model, project_name, examples, configs
def _collect_test_results(
examples: List[Example],
batch_results: List[Union[dict, str, LLMResult, ChatResult]],
configs: List[RunnableConfig],
project_name: str,
) -> TestResult:
wait_for_all_evaluators()
all_eval_results = {}
for c in configs:
for callback in cast(list, c["callbacks"]):
if isinstance(callback, EvaluatorCallbackHandler):
eval_results = callback.logged_eval_results
all_eval_results.update(
{example_id: v for (_, example_id), v in eval_results.items()}
)
results = {}
for example, output in zip(examples, batch_results):
feedback = all_eval_results.get(str(example.id), [])
results[str(example.id)] = {
"output": output,
"input": example.inputs,
"feedback": feedback,
}
if example.outputs:
results[str(example.id)]["reference"] = example.outputs
return TestResult(
project_name=project_name,
results=results,
)
_INPUT_MAPPER_DEP_WARNING = (
"The input_mapper argument is deprecated and "
"will be removed in a future release. Please add a "
" RunnableLambda to your chain to map inputs to the expected format"
" instead. Example:\n"
"def construct_chain():\n"
" my_chain = ...\n"
" input_mapper = {'other_key': 'MyOtherInput', 'my_input_key': x}\n"
" return input_mapper | my_chain\n"
"run_on_dataset(..., llm_or_chain_factory=construct_chain)\n"
"(See https://api.python.langchain.com/en/latest/schema/"
"langchain.schema.runnable.base.RunnableLambda.html)"
)
async def arun_on_dataset(
client: Optional[Client],
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[smith_eval.RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
project_metadata: Optional[Dict[str, Any]] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
input_mapper = kwargs.pop("input_mapper", None)
if input_mapper:
warn_deprecated("0.0.305", message=_INPUT_MAPPER_DEP_WARNING, pending=True)
if kwargs:
warn_deprecated(
"0.0.305",
message="The following arguments are deprecated and "
"will be removed in a future release: "
f"{kwargs.keys()}.",
removal="0.0.305",
)
client = client or Client()
wrapped_model, project_name, examples, configs = _prepare_run_on_dataset(
client,
dataset_name,
llm_or_chain_factory,
project_name,
evaluation,
tags,
input_mapper,
concurrency_level,
project_metadata=project_metadata,
)
batch_results = await runnable_utils.gather_with_concurrency(
configs[0].get("max_concurrency"),
*map(
functools.partial(
_arun_llm_or_chain,
llm_or_chain_factory=wrapped_model,
input_mapper=input_mapper,
),
examples,
configs,
),
)
results = _collect_test_results(examples, batch_results, configs, project_name)
if verbose:
try:
agg_feedback = results.get_aggregate_feedback()
print("\n Eval quantiles:")
print(agg_feedback)
except Exception as e:
logger.debug(f"Failed to print aggregate feedback: {repr(e)}")
return results
def run_on_dataset(
client: Optional[Client],
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[smith_eval.RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
project_metadata: Optional[Dict[str, Any]] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
input_mapper = kwargs.pop("input_mapper", None)
if input_mapper:
warn_deprecated("0.0.305", message=_INPUT_MAPPER_DEP_WARNING, pending=True)
if kwargs:
warn_deprecated(
"0.0.305",
message="The following arguments are deprecated and "
"will be removed in a future release: "
f"{kwargs.keys()}.",
removal="0.0.305",
)
client = client or Client()
wrapped_model, project_name, examples, configs = _prepare_run_on_dataset(
client,
dataset_name,
llm_or_chain_factory,
project_name,
evaluation,
tags,
input_mapper,
concurrency_level,
project_metadata=project_metadata,
)
if concurrency_level == 0:
batch_results = [
_run_llm_or_chain(
example,
config,
llm_or_chain_factory=wrapped_model,
input_mapper=input_mapper,
)
for example, config in zip(examples, configs)
]
else:
with runnable_config.get_executor_for_config(configs[0]) as executor:
batch_results = list(
executor.map(
functools.partial(
_run_llm_or_chain,
llm_or_chain_factory=wrapped_model,
input_mapper=input_mapper,
),
examples,
configs,
)
)
results = _collect_test_results(examples, batch_results, configs, project_name)
if verbose:
try:
agg_feedback = results.get_aggregate_feedback()
print("\n Eval quantiles:")
print(agg_feedback)
except Exception as e:
logger.debug(f"Failed to print aggregate feedback: {repr(e)}")
return results
_RUN_ON_DATASET_DOCSTRING = """
Run the Chain or language model on a dataset and store traces
to the specified project name.
Args:
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Configuration for evaluators to run on the
results of the chain
concurrency_level: The number of async tasks to run concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
project_metadata: Optional metadata to add to the project.
Useful for storing information the test variant.
(prompt version, model version, etc.)
client: LangSmith client to use to access the dataset and to
log feedback and run traces.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
Returns:
A dictionary containing the run's project name and the resulting model outputs.
For the (usually faster) async version of this function, see :func:`arun_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import smith_eval.RunEvalConfig, run_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = smith_eval.RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
smith_eval.RunEvalConfig.Criteria("helpfulness"),
smith_eval.RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = smith_eval.RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
run_on_dataset.__doc__ = _RUN_ON_DATASET_DOCSTRING
arun_on_dataset.__doc__ = _RUN_ON_DATASET_DOCSTRING.replace(
"run_on_dataset(", "await arun_on_dataset("
)
| [
"langchain.evaluation.loading.load_evaluator",
"langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler",
"langchain.schema.runnable.RunnableConfig",
"langchain.schema.runnable.RunnableLambda",
"langchain.schema.messages.messages_from_dict",
"langchain.schema.runnable.config.get_executor_for_config",
"langchain.callbacks.tracers.evaluation.wait_for_all_evaluators",
"langchain.evaluation.schema.EvaluatorType",
"langchain.smith.evaluation.StringRunEvaluatorChain.from_run_and_data_type",
"langchain.callbacks.tracers.langchain.LangChainTracer",
"langchain.smith.evaluation.name_generation.random_name",
"langchain._api.warn_deprecated"
] | [((1724, 1751), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1741, 1751), False, 'import logging\n'), ((33983, 34008), 'langchain.callbacks.tracers.evaluation.wait_for_all_evaluators', 'wait_for_all_evaluators', ([], {}), '()\n', (34006, 34008), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler, wait_for_all_evaluators\n'), ((3847, 3883), 'pandas.DataFrame', 'pd.DataFrame', (['records'], {'index': 'indices'}), '(records, index=indices)\n', (3859, 3883), True, 'import pandas as pd\n'), ((9632, 9667), 'langchain.schema.messages.messages_from_dict', 'messages_from_dict', (['raw_messages[0]'], {}), '(raw_messages[0])\n', (9650, 9667), False, 'from langchain.schema.messages import BaseMessage, messages_from_dict\n'), ((17595, 17636), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config'], {'llm': 'eval_llm'}), '(eval_config, llm=eval_llm)\n', (17609, 17636), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((17773, 17825), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config.evaluator_type'], {}), '(eval_config.evaluator_type, **kwargs)\n', (17787, 17825), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((18282, 18483), 'langchain.smith.evaluation.StringRunEvaluatorChain.from_run_and_data_type', 'smith_eval.StringRunEvaluatorChain.from_run_and_data_type', (['evaluator_', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key', 'tags': '[eval_type_tag]'}), '(evaluator_,\n run_type, data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key, tags=[eval_type_tag])\n', (18339, 18483), True, 'from langchain.smith import evaluation as smith_eval\n'), ((24388, 24440), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (24402, 24440), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((28680, 28732), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (28694, 28732), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((32515, 32544), 'langchain.smith.evaluation.name_generation.random_name', 'name_generation.random_name', ([], {}), '()\n', (32542, 32544), False, 'from langchain.smith.evaluation import name_generation, progress\n'), ((34081, 34107), 'typing.cast', 'cast', (['list', "c['callbacks']"], {}), "(list, c['callbacks'])\n", (34085, 34107), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((35958, 36033), 'langchain._api.warn_deprecated', 'warn_deprecated', (['"""0.0.305"""'], {'message': '_INPUT_MAPPER_DEP_WARNING', 'pending': '(True)'}), "('0.0.305', message=_INPUT_MAPPER_DEP_WARNING, pending=True)\n", (35973, 36033), False, 'from langchain._api import warn_deprecated\n'), ((36313, 36321), 'langsmith.client.Client', 'Client', ([], {}), '()\n', (36319, 36321), False, 'from langsmith.client import Client\n'), ((37857, 37932), 'langchain._api.warn_deprecated', 'warn_deprecated', (['"""0.0.305"""'], {'message': '_INPUT_MAPPER_DEP_WARNING', 'pending': '(True)'}), "('0.0.305', message=_INPUT_MAPPER_DEP_WARNING, pending=True)\n", (37872, 37932), False, 'from langchain._api import warn_deprecated\n'), ((38212, 38220), 'langsmith.client.Client', 'Client', ([], {}), '()\n', (38218, 38220), False, 'from langsmith.client import Client\n'), ((17547, 17573), 'langchain.evaluation.schema.EvaluatorType', 'EvaluatorType', (['eval_config'], {}), '(eval_config)\n', (17560, 17573), False, 'from langchain.evaluation.schema import EvaluatorType, PairwiseStringEvaluator, StringEvaluator\n'), ((31267, 31279), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (31277, 31279), False, 'import uuid\n'), ((38858, 38909), 'langchain.schema.runnable.config.get_executor_for_config', 'runnable_config.get_executor_for_config', (['configs[0]'], {}), '(configs[0])\n', (38897, 38909), True, 'from langchain.schema.runnable import config as runnable_config\n'), ((5477, 5520), 'langsmith.run_helpers.is_traceable_function', 'is_traceable_function', (['llm_or_chain_factory'], {}), '(llm_or_chain_factory)\n', (5498, 5520), False, 'from langsmith.run_helpers import as_runnable, is_traceable_function\n'), ((6096, 6132), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (6100, 6132), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((21237, 21422), 'langchain.smith.evaluation.StringRunEvaluatorChain.from_run_and_data_type', 'smith_eval.StringRunEvaluatorChain.from_run_and_data_type', (['custom_evaluator', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key'}), '(custom_evaluator,\n run_type, data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key)\n', (21294, 21422), True, 'from langchain.smith import evaluation as smith_eval\n'), ((33159, 33265), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)', 'example_id': 'example.id'}), '(project_name=project_name, client=client, use_threading=\n False, example_id=example.id)\n', (33174, 33265), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((33377, 33476), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'evaluators': '(run_evaluators or [])', 'client': 'client', 'example_id': 'example.id'}), '(evaluators=run_evaluators or [], client=client,\n example_id=example.id)\n', (33401, 33476), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler, wait_for_all_evaluators\n'), ((36758, 36862), 'functools.partial', 'functools.partial', (['_arun_llm_or_chain'], {'llm_or_chain_factory': 'wrapped_model', 'input_mapper': 'input_mapper'}), '(_arun_llm_or_chain, llm_or_chain_factory=wrapped_model,\n input_mapper=input_mapper)\n', (36775, 36862), False, 'import functools\n'), ((39007, 39110), 'functools.partial', 'functools.partial', (['_run_llm_or_chain'], {'llm_or_chain_factory': 'wrapped_model', 'input_mapper': 'input_mapper'}), '(_run_llm_or_chain, llm_or_chain_factory=wrapped_model,\n input_mapper=input_mapper)\n', (39024, 39110), False, 'import functools\n'), ((5558, 5594), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5562, 5594), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((5836, 5872), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5840, 5872), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((5891, 5919), 'inspect.signature', 'inspect.signature', (['user_func'], {}), '(user_func)\n', (5908, 5919), False, 'import inspect\n'), ((6013, 6038), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['user_func'], {}), '(user_func)\n', (6027, 6038), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((6368, 6390), 'typing.cast', 'cast', (['Callable', '_model'], {}), '(Callable, _model)\n', (6372, 6390), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((6429, 6451), 'typing.cast', 'cast', (['Callable', '_model'], {}), '(Callable, _model)\n', (6433, 6451), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Sequence, Tuple, Union, cast\n'), ((6642, 6669), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['constructor'], {}), '(constructor)\n', (6656, 6669), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n')] |
import os
import dotenv
dotenv.load_dotenv()
### Load the credentials
api_key = os.getenv("API_KEY", None)
ibm_cloud_url = os.getenv("IBM_CLOUD_URL", None)
project_id = os.getenv("PROJECT_ID", None)
HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN", None)
min_new_tokens=1
max_new_tokens=300
temperature=1
top_k=50
top_p=1
random_seed=42
repetition_penalty=1.2
from langchain.callbacks.base import BaseCallbackHandler
class StreamHandler(BaseCallbackHandler):
from uuid import UUID
from langchain.schema.output import LLMResult
from typing import Any
def __init__(self, container, initial_text=""):
self.container = container
self.text = initial_text
def on_llm_new_token(self, token: str, **kwargs) -> None:
if token:
self.text += token
self.container.markdown(self.text)
def on_llm_end(self, response: LLMResult, *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> Any:
return super().on_llm_end(response, run_id=run_id, parent_run_id=parent_run_id, **kwargs)
### IBM Watson
def set_params_ibm(decoding_method):
from ibm_watson_machine_learning.metanames import GenTextParamsMetaNames as GenParams
if decoding_method == "sample":
params = {
GenParams.DECODING_METHOD: decoding_method,
GenParams.MIN_NEW_TOKENS: min_new_tokens,
GenParams.MAX_NEW_TOKENS: max_new_tokens,
GenParams.TEMPERATURE: temperature,
GenParams.TOP_K: top_k,
GenParams.TOP_P: top_p,
GenParams.RANDOM_SEED: random_seed,
GenParams.REPETITION_PENALTY: repetition_penalty,
GenParams.STOP_SEQUENCES: ["# [","\n\n","**"],
}
elif decoding_method == "greedy":
params = {
GenParams.DECODING_METHOD: decoding_method,
GenParams.MIN_NEW_TOKENS: min_new_tokens,
GenParams.MAX_NEW_TOKENS: max_new_tokens,
GenParams.RANDOM_SEED: random_seed,
GenParams.TEMPERATURE: temperature,
GenParams.REPETITION_PENALTY: repetition_penalty,
GenParams.STOP_SEQUENCES: ["#","[","\n\n","**"," * "],
}
else:
params = None
print("Decoding method not supported, please use 'sample' or 'greedy'.")
return params
### IBM Research BAM
def llm_param(decoding_method, model_id):
from genai.credentials import Credentials
from genai.model import Model
from genai.extensions.langchain import LangChainInterface
if bam_api_key is None or bam_api_url is None:
llm = None
print("Ensure you copied the .env file that you created earlier into the same directory as this notebook")
else:
creds = Credentials(bam_api_key, api_endpoint=bam_api_url)
# decoding_method = "greedy"
params = set_params_ibm(decoding_method)
message_placeholder = None # You can define this if needed
stream_handler = StreamHandler(message_placeholder)
callback = False
if callback is True:
llm = LangChainInterface(
model=model_id,
credentials=creds,
params=params,
callbacks=[stream_handler]
)
else:
llm = LangChainInterface(
model=model_id,
credentials=creds,
params=params
)
llm = LangChainInterface(model=model_id, credentials=creds, params=params, project_id=project_id)
return llm
### Hugging Face
def hugfacelib(repo_id):
from langchain.embeddings import HuggingFaceHubEmbeddings
repo_id = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
embedding = HuggingFaceHubEmbeddings(
task="feature-extraction",
repo_id = repo_id,
huggingfacehub_api_token = HUGGINGFACEHUB_API_TOKEN
)
return embedding
| [
"langchain.embeddings.HuggingFaceHubEmbeddings"
] | [((24, 44), 'dotenv.load_dotenv', 'dotenv.load_dotenv', ([], {}), '()\n', (42, 44), False, 'import dotenv\n'), ((81, 107), 'os.getenv', 'os.getenv', (['"""API_KEY"""', 'None'], {}), "('API_KEY', None)\n", (90, 107), False, 'import os\n'), ((124, 156), 'os.getenv', 'os.getenv', (['"""IBM_CLOUD_URL"""', 'None'], {}), "('IBM_CLOUD_URL', None)\n", (133, 156), False, 'import os\n'), ((170, 199), 'os.getenv', 'os.getenv', (['"""PROJECT_ID"""', 'None'], {}), "('PROJECT_ID', None)\n", (179, 199), False, 'import os\n'), ((228, 271), 'os.getenv', 'os.getenv', (['"""HUGGINGFACEHUB_API_TOKEN"""', 'None'], {}), "('HUGGINGFACEHUB_API_TOKEN', None)\n", (237, 271), False, 'import os\n'), ((3772, 3895), 'langchain.embeddings.HuggingFaceHubEmbeddings', 'HuggingFaceHubEmbeddings', ([], {'task': '"""feature-extraction"""', 'repo_id': 'repo_id', 'huggingfacehub_api_token': 'HUGGINGFACEHUB_API_TOKEN'}), "(task='feature-extraction', repo_id=repo_id,\n huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN)\n", (3796, 3895), False, 'from langchain.embeddings import HuggingFaceHubEmbeddings\n'), ((2763, 2813), 'genai.credentials.Credentials', 'Credentials', (['bam_api_key'], {'api_endpoint': 'bam_api_url'}), '(bam_api_key, api_endpoint=bam_api_url)\n', (2774, 2813), False, 'from genai.credentials import Credentials\n'), ((3465, 3560), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': 'model_id', 'credentials': 'creds', 'params': 'params', 'project_id': 'project_id'}), '(model=model_id, credentials=creds, params=params,\n project_id=project_id)\n', (3483, 3560), False, 'from genai.extensions.langchain import LangChainInterface\n'), ((3112, 3212), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': 'model_id', 'credentials': 'creds', 'params': 'params', 'callbacks': '[stream_handler]'}), '(model=model_id, credentials=creds, params=params,\n callbacks=[stream_handler])\n', (3130, 3212), False, 'from genai.extensions.langchain import LangChainInterface\n'), ((3319, 3387), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': 'model_id', 'credentials': 'creds', 'params': 'params'}), '(model=model_id, credentials=creds, params=params)\n', (3337, 3387), False, 'from genai.extensions.langchain import LangChainInterface\n')] |
"""Base interface for large language models to expose."""
import inspect
import json
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
import yaml
from pydantic import Extra, Field, root_validator, validator
import langchain
from langchain.base_language import BaseLanguageModel
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForLLMRun,
CallbackManager,
CallbackManagerForLLMRun,
Callbacks,
)
from langchain.schema import (
AIMessage,
BaseMessage,
Generation,
LLMResult,
PromptValue,
get_buffer_string,
)
def _get_verbosity() -> bool:
return langchain.verbose
def get_prompts(
params: Dict[str, Any], prompts: List[str]
) -> Tuple[Dict[int, List], str, List[int], List[str]]:
"""Get prompts that are already cached."""
llm_string = str(sorted([(k, v) for k, v in params.items()]))
missing_prompts = []
missing_prompt_idxs = []
existing_prompts = {}
for i, prompt in enumerate(prompts):
if langchain.llm_cache is not None:
cache_val = langchain.llm_cache.lookup(prompt, llm_string)
if isinstance(cache_val, list):
existing_prompts[i] = cache_val
else:
missing_prompts.append(prompt)
missing_prompt_idxs.append(i)
return existing_prompts, llm_string, missing_prompt_idxs, missing_prompts
def update_cache(
existing_prompts: Dict[int, List],
llm_string: str,
missing_prompt_idxs: List[int],
new_results: LLMResult,
prompts: List[str],
) -> Optional[dict]:
"""Update the cache and get the LLM output."""
for i, result in enumerate(new_results.generations):
existing_prompts[missing_prompt_idxs[i]] = result
prompt = prompts[missing_prompt_idxs[i]]
if langchain.llm_cache is not None:
langchain.llm_cache.update(prompt, llm_string, result)
llm_output = new_results.llm_output
return llm_output
class BaseLLM(BaseLanguageModel, ABC):
"""LLM wrapper should take in a prompt and return a string."""
cache: Optional[bool] = None
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether to print out response text."""
callbacks: Callbacks = Field(default=None, exclude=True)
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@root_validator()
def raise_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@abstractmethod
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompts."""
@abstractmethod
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompts."""
def generate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return self.generate(prompt_strings, stop=stop, callbacks=callbacks)
async def agenerate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return await self.agenerate(prompt_strings, stop=stop, callbacks=callbacks)
def generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# If string is passed in directly no errors will be raised but outputs will
# not make sense.
if not isinstance(prompts, list):
raise ValueError(
"Argument 'prompts' is expected to be of type List[str], received"
f" argument of type {type(prompts)}."
)
params = self.dict()
params["stop"] = stop
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = CallbackManager.configure(
callbacks, self.callbacks, self.verbose
)
new_arg_supported = inspect.signature(self._generate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompts, invocation_params=params
)
try:
output = (
self._generate(prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._generate(prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(output)
return output
if len(missing_prompts) > 0:
run_manager = callback_manager.on_llm_start(
{"name": self.__class__.__name__},
missing_prompts,
invocation_params=params,
)
try:
new_results = (
self._generate(missing_prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._generate(missing_prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
else:
llm_output = {}
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output)
async def agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
params = self.dict()
params["stop"] = stop
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = AsyncCallbackManager.configure(
callbacks, self.callbacks, self.verbose
)
new_arg_supported = inspect.signature(self._agenerate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = await callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompts, invocation_params=params
)
try:
output = (
await self._agenerate(prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else await self._agenerate(prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e, verbose=self.verbose)
raise e
await run_manager.on_llm_end(output, verbose=self.verbose)
return output
if len(missing_prompts) > 0:
run_manager = await callback_manager.on_llm_start(
{"name": self.__class__.__name__},
missing_prompts,
invocation_params=params,
)
try:
new_results = (
await self._agenerate(
missing_prompts, stop=stop, run_manager=run_manager
)
if new_arg_supported
else await self._agenerate(missing_prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e)
raise e
await run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
else:
llm_output = {}
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output)
def __call__(
self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
if not isinstance(prompt, str):
raise ValueError(
"Argument `prompt` is expected to be a string. Instead found "
f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
"`generate` instead."
)
return (
self.generate([prompt], stop=stop, callbacks=callbacks)
.generations[0][0]
.text
)
async def _call_async(
self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
result = await self.agenerate([prompt], stop=stop, callbacks=callbacks)
return result.generations[0][0].text
def predict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return self(text, stop=_stop)
def predict_messages(
self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = self(text, stop=_stop)
return AIMessage(content=content)
async def apredict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return await self._call_async(text, stop=_stop)
async def apredict_messages(
self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = await self._call_async(text, stop=_stop)
return AIMessage(content=content)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {}
def __str__(self) -> str:
"""Get a string representation of the object for printing."""
cls_name = f"\033[1m{self.__class__.__name__}\033[0m"
return f"{cls_name}\nParams: {self._identifying_params}"
@property
@abstractmethod
def _llm_type(self) -> str:
"""Return type of llm."""
def dict(self, **kwargs: Any) -> Dict:
"""Return a dictionary of the LLM."""
starter_dict = dict(self._identifying_params)
starter_dict["_type"] = self._llm_type
return starter_dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the LLM.
Args:
file_path: Path to file to save the LLM to.
Example:
.. code-block:: python
llm.save(file_path="path/llm.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
prompt_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(prompt_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(prompt_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
class LLM(BaseLLM):
"""LLM class that expect subclasses to implement a simpler call method.
The purpose of this class is to expose a simpler interface for working
with LLMs, rather than expect the user to implement the full _generate method.
"""
@abstractmethod
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> str:
"""Run the LLM on the given prompt and input."""
async def _acall(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> str:
"""Run the LLM on the given prompt and input."""
raise NotImplementedError("Async generation not implemented for this LLM.")
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# TODO: add caching here.
generations = []
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
for prompt in prompts:
text = (
self._call(prompt, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._call(prompt, stop=stop)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
generations = []
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
for prompt in prompts:
text = (
await self._acall(prompt, stop=stop, run_manager=run_manager)
if new_arg_supported
else await self._acall(prompt, stop=stop)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
| [
"langchain.llm_cache.lookup",
"langchain.schema.Generation",
"langchain.schema.AIMessage",
"langchain.llm_cache.update",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.callbacks.manager.CallbackManager.configure",
"langchain.schema.LLMResult",
"langchain.schema.get_buffer_string"
] | [((2302, 2339), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2307, 2339), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2413, 2446), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2418, 2446), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2501, 2534), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2506, 2534), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2683, 2699), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (2697, 2699), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((3135, 3178), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (3144, 3178), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((5507, 5573), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose'], {}), '(callbacks, self.callbacks, self.verbose)\n', (5532, 5573), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((7567, 7624), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (7576, 7624), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((8170, 8241), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose'], {}), '(callbacks, self.callbacks, self.verbose)\n', (8200, 8241), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((10390, 10447), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (10399, 10447), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((11768, 11795), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (11785, 11795), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((11947, 11973), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (11956, 11973), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((12369, 12396), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (12386, 12396), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((12566, 12592), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (12575, 12592), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((15773, 15807), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (15782, 15807), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((16489, 16523), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (16498, 16523), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((1235, 1281), 'langchain.llm_cache.lookup', 'langchain.llm_cache.lookup', (['prompt', 'llm_string'], {}), '(prompt, llm_string)\n', (1261, 1281), False, 'import langchain\n'), ((2023, 2077), 'langchain.llm_cache.update', 'langchain.llm_cache.update', (['prompt', 'llm_string', 'result'], {}), '(prompt, llm_string, result)\n', (2049, 2077), False, 'import langchain\n'), ((2890, 2992), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (2903, 2992), False, 'import warnings\n'), ((13642, 13657), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (13646, 13657), False, 'from pathlib import Path\n'), ((13978, 14013), 'json.dump', 'json.dump', (['prompt_dict', 'f'], {'indent': '(4)'}), '(prompt_dict, f, indent=4)\n', (13987, 14013), False, 'import json\n'), ((5624, 5657), 'inspect.signature', 'inspect.signature', (['self._generate'], {}), '(self._generate)\n', (5641, 5657), False, 'import inspect\n'), ((8292, 8326), 'inspect.signature', 'inspect.signature', (['self._agenerate'], {}), '(self._agenerate)\n', (8309, 8326), False, 'import inspect\n'), ((14116, 14167), 'yaml.dump', 'yaml.dump', (['prompt_dict', 'f'], {'default_flow_style': '(False)'}), '(prompt_dict, f, default_flow_style=False)\n', (14125, 14167), False, 'import yaml\n'), ((15417, 15446), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (15434, 15446), False, 'import inspect\n'), ((15734, 15755), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (15744, 15755), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((16118, 16148), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (16135, 16148), False, 'import inspect\n'), ((16450, 16471), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (16460, 16471), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n')] |
"""Base interface for large language models to expose."""
import inspect
import json
import warnings
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union
import yaml
from pydantic import Extra, Field, root_validator, validator
import langchain
from langchain.base_language import BaseLanguageModel
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManager,
AsyncCallbackManagerForLLMRun,
CallbackManager,
CallbackManagerForLLMRun,
Callbacks,
)
from langchain.schema import (
AIMessage,
BaseMessage,
Generation,
LLMResult,
PromptValue,
get_buffer_string,
)
def _get_verbosity() -> bool:
return langchain.verbose
def get_prompts(
params: Dict[str, Any], prompts: List[str]
) -> Tuple[Dict[int, List], str, List[int], List[str]]:
"""Get prompts that are already cached."""
llm_string = str(sorted([(k, v) for k, v in params.items()]))
missing_prompts = []
missing_prompt_idxs = []
existing_prompts = {}
for i, prompt in enumerate(prompts):
if langchain.llm_cache is not None:
cache_val = langchain.llm_cache.lookup(prompt, llm_string)
if isinstance(cache_val, list):
existing_prompts[i] = cache_val
else:
missing_prompts.append(prompt)
missing_prompt_idxs.append(i)
return existing_prompts, llm_string, missing_prompt_idxs, missing_prompts
def update_cache(
existing_prompts: Dict[int, List],
llm_string: str,
missing_prompt_idxs: List[int],
new_results: LLMResult,
prompts: List[str],
) -> Optional[dict]:
"""Update the cache and get the LLM output."""
for i, result in enumerate(new_results.generations):
existing_prompts[missing_prompt_idxs[i]] = result
prompt = prompts[missing_prompt_idxs[i]]
if langchain.llm_cache is not None:
langchain.llm_cache.update(prompt, llm_string, result)
llm_output = new_results.llm_output
return llm_output
class BaseLLM(BaseLanguageModel, ABC):
"""LLM wrapper should take in a prompt and return a string."""
cache: Optional[bool] = None
verbose: bool = Field(default_factory=_get_verbosity)
"""Whether to print out response text."""
callbacks: Callbacks = Field(default=None, exclude=True)
callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
arbitrary_types_allowed = True
@root_validator()
def raise_deprecation(cls, values: Dict) -> Dict:
"""Raise deprecation warning if callback_manager is used."""
if values.get("callback_manager") is not None:
warnings.warn(
"callback_manager is deprecated. Please use callbacks instead.",
DeprecationWarning,
)
values["callbacks"] = values.pop("callback_manager", None)
return values
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@abstractmethod
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompts."""
@abstractmethod
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompts."""
def generate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return self.generate(prompt_strings, stop=stop, callbacks=callbacks)
async def agenerate_prompt(
self,
prompts: List[PromptValue],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
prompt_strings = [p.to_string() for p in prompts]
return await self.agenerate(prompt_strings, stop=stop, callbacks=callbacks)
def generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# If string is passed in directly no errors will be raised but outputs will
# not make sense.
if not isinstance(prompts, list):
raise ValueError(
"Argument 'prompts' is expected to be of type List[str], received"
f" argument of type {type(prompts)}."
)
params = self.dict()
params["stop"] = stop
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = CallbackManager.configure(
callbacks, self.callbacks, self.verbose
)
new_arg_supported = inspect.signature(self._generate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompts, invocation_params=params
)
try:
output = (
self._generate(prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._generate(prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(output)
return output
if len(missing_prompts) > 0:
run_manager = callback_manager.on_llm_start(
{"name": self.__class__.__name__},
missing_prompts,
invocation_params=params,
)
try:
new_results = (
self._generate(missing_prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._generate(missing_prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
run_manager.on_llm_error(e)
raise e
run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
else:
llm_output = {}
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output)
async def agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
params = self.dict()
params["stop"] = stop
(
existing_prompts,
llm_string,
missing_prompt_idxs,
missing_prompts,
) = get_prompts(params, prompts)
disregard_cache = self.cache is not None and not self.cache
callback_manager = AsyncCallbackManager.configure(
callbacks, self.callbacks, self.verbose
)
new_arg_supported = inspect.signature(self._agenerate).parameters.get(
"run_manager"
)
if langchain.llm_cache is None or disregard_cache:
# This happens when langchain.cache is None, but self.cache is True
if self.cache is not None and self.cache:
raise ValueError(
"Asked to cache, but no cache found at `langchain.cache`."
)
run_manager = await callback_manager.on_llm_start(
{"name": self.__class__.__name__}, prompts, invocation_params=params
)
try:
output = (
await self._agenerate(prompts, stop=stop, run_manager=run_manager)
if new_arg_supported
else await self._agenerate(prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e, verbose=self.verbose)
raise e
await run_manager.on_llm_end(output, verbose=self.verbose)
return output
if len(missing_prompts) > 0:
run_manager = await callback_manager.on_llm_start(
{"name": self.__class__.__name__},
missing_prompts,
invocation_params=params,
)
try:
new_results = (
await self._agenerate(
missing_prompts, stop=stop, run_manager=run_manager
)
if new_arg_supported
else await self._agenerate(missing_prompts, stop=stop)
)
except (KeyboardInterrupt, Exception) as e:
await run_manager.on_llm_error(e)
raise e
await run_manager.on_llm_end(new_results)
llm_output = update_cache(
existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
)
else:
llm_output = {}
generations = [existing_prompts[i] for i in range(len(prompts))]
return LLMResult(generations=generations, llm_output=llm_output)
def __call__(
self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
if not isinstance(prompt, str):
raise ValueError(
"Argument `prompt` is expected to be a string. Instead found "
f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
"`generate` instead."
)
return (
self.generate([prompt], stop=stop, callbacks=callbacks)
.generations[0][0]
.text
)
async def _call_async(
self, prompt: str, stop: Optional[List[str]] = None, callbacks: Callbacks = None
) -> str:
"""Check Cache and run the LLM on the given prompt and input."""
result = await self.agenerate([prompt], stop=stop, callbacks=callbacks)
return result.generations[0][0].text
def predict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return self(text, stop=_stop)
def predict_messages(
self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = self(text, stop=_stop)
return AIMessage(content=content)
async def apredict(self, text: str, *, stop: Optional[Sequence[str]] = None) -> str:
if stop is None:
_stop = None
else:
_stop = list(stop)
return await self._call_async(text, stop=_stop)
async def apredict_messages(
self, messages: List[BaseMessage], *, stop: Optional[Sequence[str]] = None
) -> BaseMessage:
text = get_buffer_string(messages)
if stop is None:
_stop = None
else:
_stop = list(stop)
content = await self._call_async(text, stop=_stop)
return AIMessage(content=content)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {}
def __str__(self) -> str:
"""Get a string representation of the object for printing."""
cls_name = f"\033[1m{self.__class__.__name__}\033[0m"
return f"{cls_name}\nParams: {self._identifying_params}"
@property
@abstractmethod
def _llm_type(self) -> str:
"""Return type of llm."""
def dict(self, **kwargs: Any) -> Dict:
"""Return a dictionary of the LLM."""
starter_dict = dict(self._identifying_params)
starter_dict["_type"] = self._llm_type
return starter_dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the LLM.
Args:
file_path: Path to file to save the LLM to.
Example:
.. code-block:: python
llm.save(file_path="path/llm.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
prompt_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(prompt_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(prompt_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
class LLM(BaseLLM):
"""LLM class that expect subclasses to implement a simpler call method.
The purpose of this class is to expose a simpler interface for working
with LLMs, rather than expect the user to implement the full _generate method.
"""
@abstractmethod
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> str:
"""Run the LLM on the given prompt and input."""
async def _acall(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> str:
"""Run the LLM on the given prompt and input."""
raise NotImplementedError("Async generation not implemented for this LLM.")
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
# TODO: add caching here.
generations = []
new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
for prompt in prompts:
text = (
self._call(prompt, stop=stop, run_manager=run_manager)
if new_arg_supported
else self._call(prompt, stop=stop)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> LLMResult:
"""Run the LLM on the given prompt and input."""
generations = []
new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
for prompt in prompts:
text = (
await self._acall(prompt, stop=stop, run_manager=run_manager)
if new_arg_supported
else await self._acall(prompt, stop=stop)
)
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
| [
"langchain.llm_cache.lookup",
"langchain.schema.Generation",
"langchain.schema.AIMessage",
"langchain.llm_cache.update",
"langchain.callbacks.manager.AsyncCallbackManager.configure",
"langchain.callbacks.manager.CallbackManager.configure",
"langchain.schema.LLMResult",
"langchain.schema.get_buffer_string"
] | [((2302, 2339), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (2307, 2339), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2413, 2446), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2418, 2446), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2501, 2534), 'pydantic.Field', 'Field', ([], {'default': 'None', 'exclude': '(True)'}), '(default=None, exclude=True)\n', (2506, 2534), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((2683, 2699), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (2697, 2699), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((3135, 3178), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (3144, 3178), False, 'from pydantic import Extra, Field, root_validator, validator\n'), ((5507, 5573), 'langchain.callbacks.manager.CallbackManager.configure', 'CallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose'], {}), '(callbacks, self.callbacks, self.verbose)\n', (5532, 5573), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((7567, 7624), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (7576, 7624), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((8170, 8241), 'langchain.callbacks.manager.AsyncCallbackManager.configure', 'AsyncCallbackManager.configure', (['callbacks', 'self.callbacks', 'self.verbose'], {}), '(callbacks, self.callbacks, self.verbose)\n', (8200, 8241), False, 'from langchain.callbacks.manager import AsyncCallbackManager, AsyncCallbackManagerForLLMRun, CallbackManager, CallbackManagerForLLMRun, Callbacks\n'), ((10390, 10447), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (10399, 10447), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((11768, 11795), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (11785, 11795), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((11947, 11973), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (11956, 11973), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((12369, 12396), 'langchain.schema.get_buffer_string', 'get_buffer_string', (['messages'], {}), '(messages)\n', (12386, 12396), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((12566, 12592), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (12575, 12592), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((15773, 15807), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (15782, 15807), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((16489, 16523), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (16498, 16523), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((1235, 1281), 'langchain.llm_cache.lookup', 'langchain.llm_cache.lookup', (['prompt', 'llm_string'], {}), '(prompt, llm_string)\n', (1261, 1281), False, 'import langchain\n'), ((2023, 2077), 'langchain.llm_cache.update', 'langchain.llm_cache.update', (['prompt', 'llm_string', 'result'], {}), '(prompt, llm_string, result)\n', (2049, 2077), False, 'import langchain\n'), ((2890, 2992), 'warnings.warn', 'warnings.warn', (['"""callback_manager is deprecated. Please use callbacks instead."""', 'DeprecationWarning'], {}), "('callback_manager is deprecated. Please use callbacks instead.',\n DeprecationWarning)\n", (2903, 2992), False, 'import warnings\n'), ((13642, 13657), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (13646, 13657), False, 'from pathlib import Path\n'), ((13978, 14013), 'json.dump', 'json.dump', (['prompt_dict', 'f'], {'indent': '(4)'}), '(prompt_dict, f, indent=4)\n', (13987, 14013), False, 'import json\n'), ((5624, 5657), 'inspect.signature', 'inspect.signature', (['self._generate'], {}), '(self._generate)\n', (5641, 5657), False, 'import inspect\n'), ((8292, 8326), 'inspect.signature', 'inspect.signature', (['self._agenerate'], {}), '(self._agenerate)\n', (8309, 8326), False, 'import inspect\n'), ((14116, 14167), 'yaml.dump', 'yaml.dump', (['prompt_dict', 'f'], {'default_flow_style': '(False)'}), '(prompt_dict, f, default_flow_style=False)\n', (14125, 14167), False, 'import yaml\n'), ((15417, 15446), 'inspect.signature', 'inspect.signature', (['self._call'], {}), '(self._call)\n', (15434, 15446), False, 'import inspect\n'), ((15734, 15755), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (15744, 15755), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n'), ((16118, 16148), 'inspect.signature', 'inspect.signature', (['self._acall'], {}), '(self._acall)\n', (16135, 16148), False, 'import inspect\n'), ((16450, 16471), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (16460, 16471), False, 'from langchain.schema import AIMessage, BaseMessage, Generation, LLMResult, PromptValue, get_buffer_string\n')] |
import tempfile
from copy import deepcopy
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Sequence
import langchain
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.utils import (
BaseMetadataCallbackHandler,
flatten_dict,
import_pandas,
import_spacy,
import_textstat,
)
from langchain.schema import AgentAction, AgentFinish, Generation, LLMResult
LANGCHAIN_MODEL_NAME = "langchain-model"
def import_comet_ml() -> Any:
"""Import comet_ml and raise an error if it is not installed."""
try:
import comet_ml # noqa: F401
except ImportError:
raise ImportError(
"To use the comet_ml callback manager you need to have the "
"`comet_ml` python package installed. Please install it with"
" `pip install comet_ml`"
)
return comet_ml
def _get_experiment(
workspace: Optional[str] = None, project_name: Optional[str] = None
) -> Any:
comet_ml = import_comet_ml()
experiment = comet_ml.Experiment( # type: ignore
workspace=workspace,
project_name=project_name,
)
return experiment
def _fetch_text_complexity_metrics(text: str) -> dict:
textstat = import_textstat()
text_complexity_metrics = {
"flesch_reading_ease": textstat.flesch_reading_ease(text),
"flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
"smog_index": textstat.smog_index(text),
"coleman_liau_index": textstat.coleman_liau_index(text),
"automated_readability_index": textstat.automated_readability_index(text),
"dale_chall_readability_score": textstat.dale_chall_readability_score(text),
"difficult_words": textstat.difficult_words(text),
"linsear_write_formula": textstat.linsear_write_formula(text),
"gunning_fog": textstat.gunning_fog(text),
"text_standard": textstat.text_standard(text),
"fernandez_huerta": textstat.fernandez_huerta(text),
"szigriszt_pazos": textstat.szigriszt_pazos(text),
"gutierrez_polini": textstat.gutierrez_polini(text),
"crawford": textstat.crawford(text),
"gulpease_index": textstat.gulpease_index(text),
"osman": textstat.osman(text),
}
return text_complexity_metrics
def _summarize_metrics_for_generated_outputs(metrics: Sequence) -> dict:
pd = import_pandas()
metrics_df = pd.DataFrame(metrics)
metrics_summary = metrics_df.describe()
return metrics_summary.to_dict()
class CometCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
"""Callback Handler that logs to Comet.
Parameters:
job_type (str): The type of comet_ml task such as "inference",
"testing" or "qc"
project_name (str): The comet_ml project name
tags (list): Tags to add to the task
task_name (str): Name of the comet_ml task
visualize (bool): Whether to visualize the run.
complexity_metrics (bool): Whether to log complexity metrics
stream_logs (bool): Whether to stream callback actions to Comet
This handler will utilize the associated callback method and formats
the input of each callback function with metadata regarding the state of LLM run,
and adds the response to the list of records for both the {method}_records and
action. It then logs the response to Comet.
"""
def __init__(
self,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
stream_logs: bool = True,
) -> None:
"""Initialize callback handler."""
self.comet_ml = import_comet_ml()
super().__init__()
self.task_type = task_type
self.workspace = workspace
self.project_name = project_name
self.tags = tags
self.visualizations = visualizations
self.complexity_metrics = complexity_metrics
self.custom_metrics = custom_metrics
self.stream_logs = stream_logs
self.temp_dir = tempfile.TemporaryDirectory()
self.experiment = _get_experiment(workspace, project_name)
self.experiment.log_other("Created from", "langchain")
if tags:
self.experiment.add_tags(tags)
self.name = name
if self.name:
self.experiment.set_name(self.name)
warning = (
"The comet_ml callback is currently in beta and is subject to change "
"based on updates to `langchain`. Please report any issues to "
"https://github.com/comet-ml/issue-tracking/issues with the tag "
"`langchain`."
)
self.comet_ml.LOGGER.warning(warning)
self.callback_columns: list = []
self.action_records: list = []
self.complexity_metrics = complexity_metrics
if self.visualizations:
spacy = import_spacy()
self.nlp = spacy.load("en_core_web_sm")
else:
self.nlp = None
def _init_resp(self) -> Dict:
return {k: None for k in self.callback_columns}
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when LLM starts."""
self.step += 1
self.llm_starts += 1
self.starts += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_start"})
metadata.update(flatten_dict(serialized))
metadata.update(self.get_custom_callback_meta())
for prompt in prompts:
prompt_resp = deepcopy(metadata)
prompt_resp["prompts"] = prompt
self.on_llm_start_records.append(prompt_resp)
self.action_records.append(prompt_resp)
if self.stream_logs:
self._log_stream(prompt, metadata, self.step)
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run when LLM generates a new token."""
self.step += 1
self.llm_streams += 1
resp = self._init_resp()
resp.update({"action": "on_llm_new_token", "token": token})
resp.update(self.get_custom_callback_meta())
self.action_records.append(resp)
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when LLM ends running."""
self.step += 1
self.llm_ends += 1
self.ends += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_end"})
metadata.update(flatten_dict(response.llm_output or {}))
metadata.update(self.get_custom_callback_meta())
output_complexity_metrics = []
output_custom_metrics = []
for prompt_idx, generations in enumerate(response.generations):
for gen_idx, generation in enumerate(generations):
text = generation.text
generation_resp = deepcopy(metadata)
generation_resp.update(flatten_dict(generation.dict()))
complexity_metrics = self._get_complexity_metrics(text)
if complexity_metrics:
output_complexity_metrics.append(complexity_metrics)
generation_resp.update(complexity_metrics)
custom_metrics = self._get_custom_metrics(
generation, prompt_idx, gen_idx
)
if custom_metrics:
output_custom_metrics.append(custom_metrics)
generation_resp.update(custom_metrics)
if self.stream_logs:
self._log_stream(text, metadata, self.step)
self.action_records.append(generation_resp)
self.on_llm_end_records.append(generation_resp)
self._log_text_metrics(output_complexity_metrics, step=self.step)
self._log_text_metrics(output_custom_metrics, step=self.step)
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when LLM errors."""
self.step += 1
self.errors += 1
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Run when chain starts running."""
self.step += 1
self.chain_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_chain_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
for chain_input_key, chain_input_val in inputs.items():
if isinstance(chain_input_val, str):
input_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_input_val, resp, self.step)
input_resp.update({chain_input_key: chain_input_val})
self.action_records.append(input_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Input Value for {chain_input_key} will not be logged"
)
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Run when chain ends running."""
self.step += 1
self.chain_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_chain_end"})
resp.update(self.get_custom_callback_meta())
for chain_output_key, chain_output_val in outputs.items():
if isinstance(chain_output_val, str):
output_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_output_val, resp, self.step)
output_resp.update({chain_output_key: chain_output_val})
self.action_records.append(output_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Output Value for {chain_output_key} will not be logged"
)
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when chain errors."""
self.step += 1
self.errors += 1
def on_tool_start(
self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
) -> None:
"""Run when tool starts running."""
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_tool_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(input_str, resp, self.step)
resp.update({"input_str": input_str})
self.action_records.append(resp)
def on_tool_end(self, output: str, **kwargs: Any) -> None:
"""Run when tool ends running."""
self.step += 1
self.tool_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_tool_end"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when tool errors."""
self.step += 1
self.errors += 1
def on_text(self, text: str, **kwargs: Any) -> None:
"""
Run when agent is ending.
"""
self.step += 1
self.text_ctr += 1
resp = self._init_resp()
resp.update({"action": "on_text"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(text, resp, self.step)
resp.update({"text": text})
self.action_records.append(resp)
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run when agent ends running."""
self.step += 1
self.agent_ends += 1
self.ends += 1
resp = self._init_resp()
output = finish.return_values["output"]
log = finish.log
resp.update({"action": "on_agent_finish", "log": log})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
self.step += 1
self.tool_starts += 1
self.starts += 1
tool = action.tool
tool_input = str(action.tool_input)
log = action.log
resp = self._init_resp()
resp.update({"action": "on_agent_action", "log": log, "tool": tool})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(tool_input, resp, self.step)
resp.update({"tool_input": tool_input})
self.action_records.append(resp)
def _get_complexity_metrics(self, text: str) -> dict:
"""Compute text complexity metrics using textstat.
Parameters:
text (str): The text to analyze.
Returns:
(dict): A dictionary containing the complexity metrics.
"""
resp = {}
if self.complexity_metrics:
text_complexity_metrics = _fetch_text_complexity_metrics(text)
resp.update(text_complexity_metrics)
return resp
def _get_custom_metrics(
self, generation: Generation, prompt_idx: int, gen_idx: int
) -> dict:
"""Compute Custom Metrics for an LLM Generated Output
Args:
generation (LLMResult): Output generation from an LLM
prompt_idx (int): List index of the input prompt
gen_idx (int): List index of the generated output
Returns:
dict: A dictionary containing the custom metrics.
"""
resp = {}
if self.custom_metrics:
custom_metrics = self.custom_metrics(generation, prompt_idx, gen_idx)
resp.update(custom_metrics)
return resp
def flush_tracker(
self,
langchain_asset: Any = None,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = "comet-langchain-demo",
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
finish: bool = False,
reset: bool = False,
) -> None:
"""Flush the tracker and setup the session.
Everything after this will be a new table.
Args:
name: Name of the performed session so far so it is identifiable
langchain_asset: The langchain asset to save.
finish: Whether to finish the run.
Returns:
None
"""
self._log_session(langchain_asset)
if langchain_asset:
try:
self._log_model(langchain_asset)
except Exception:
self.comet_ml.LOGGER.error(
"Failed to export agent or LLM to Comet",
exc_info=True,
extra={"show_traceback": True},
)
if finish:
self.experiment.end()
if reset:
self._reset(
task_type,
workspace,
project_name,
tags,
name,
visualizations,
complexity_metrics,
custom_metrics,
)
def _log_stream(self, prompt: str, metadata: dict, step: int) -> None:
self.experiment.log_text(prompt, metadata=metadata, step=step)
def _log_model(self, langchain_asset: Any) -> None:
model_parameters = self._get_llm_parameters(langchain_asset)
self.experiment.log_parameters(model_parameters, prefix="model")
langchain_asset_path = Path(self.temp_dir.name, "model.json")
model_name = self.name if self.name else LANGCHAIN_MODEL_NAME
try:
if hasattr(langchain_asset, "save"):
langchain_asset.save(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
except (ValueError, AttributeError, NotImplementedError) as e:
if hasattr(langchain_asset, "save_agent"):
langchain_asset.save_agent(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
else:
self.comet_ml.LOGGER.error(
f"{e}"
" Could not save Langchain Asset "
f"for {langchain_asset.__class__.__name__}"
)
def _log_session(self, langchain_asset: Optional[Any] = None) -> None:
try:
llm_session_df = self._create_session_analysis_dataframe(langchain_asset)
# Log the cleaned dataframe as a table
self.experiment.log_table("langchain-llm-session.csv", llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
metadata = {"langchain_version": str(langchain.__version__)}
# Log the langchain low-level records as a JSON file directly
self.experiment.log_asset_data(
self.action_records, "langchain-action_records.json", metadata=metadata
)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
self._log_visualizations(llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log visualizations to Comet",
exc_info=True,
extra={"show_traceback": True},
)
def _log_text_metrics(self, metrics: Sequence[dict], step: int) -> None:
if not metrics:
return
metrics_summary = _summarize_metrics_for_generated_outputs(metrics)
for key, value in metrics_summary.items():
self.experiment.log_metrics(value, prefix=key, step=step)
def _log_visualizations(self, session_df: Any) -> None:
if not (self.visualizations and self.nlp):
return
spacy = import_spacy()
prompts = session_df["prompts"].tolist()
outputs = session_df["text"].tolist()
for idx, (prompt, output) in enumerate(zip(prompts, outputs)):
doc = self.nlp(output)
sentence_spans = list(doc.sents)
for visualization in self.visualizations:
try:
html = spacy.displacy.render(
sentence_spans,
style=visualization,
options={"compact": True},
jupyter=False,
page=True,
)
self.experiment.log_asset_data(
html,
name=f"langchain-viz-{visualization}-{idx}.html",
metadata={"prompt": prompt},
step=idx,
)
except Exception as e:
self.comet_ml.LOGGER.warning(
e, exc_info=True, extra={"show_traceback": True}
)
return
def _reset(
self,
task_type: Optional[str] = None,
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
) -> None:
_task_type = task_type if task_type else self.task_type
_workspace = workspace if workspace else self.workspace
_project_name = project_name if project_name else self.project_name
_tags = tags if tags else self.tags
_name = name if name else self.name
_visualizations = visualizations if visualizations else self.visualizations
_complexity_metrics = (
complexity_metrics if complexity_metrics else self.complexity_metrics
)
_custom_metrics = custom_metrics if custom_metrics else self.custom_metrics
self.__init__( # type: ignore
task_type=_task_type,
workspace=_workspace,
project_name=_project_name,
tags=_tags,
name=_name,
visualizations=_visualizations,
complexity_metrics=_complexity_metrics,
custom_metrics=_custom_metrics,
)
self.reset_callback_meta()
self.temp_dir = tempfile.TemporaryDirectory()
def _create_session_analysis_dataframe(self, langchain_asset: Any = None) -> dict:
pd = import_pandas()
llm_parameters = self._get_llm_parameters(langchain_asset)
num_generations_per_prompt = llm_parameters.get("n", 1)
llm_start_records_df = pd.DataFrame(self.on_llm_start_records)
# Repeat each input row based on the number of outputs generated per prompt
llm_start_records_df = llm_start_records_df.loc[
llm_start_records_df.index.repeat(num_generations_per_prompt)
].reset_index(drop=True)
llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
llm_session_df = pd.merge(
llm_start_records_df,
llm_end_records_df,
left_index=True,
right_index=True,
suffixes=["_llm_start", "_llm_end"],
)
return llm_session_df
def _get_llm_parameters(self, langchain_asset: Any = None) -> dict:
if not langchain_asset:
return {}
try:
if hasattr(langchain_asset, "agent"):
llm_parameters = langchain_asset.agent.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm_chain"):
llm_parameters = langchain_asset.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm"):
llm_parameters = langchain_asset.llm.dict()
else:
llm_parameters = langchain_asset.dict()
except Exception:
return {}
return llm_parameters
| [
"langchain.callbacks.utils.import_spacy",
"langchain.callbacks.utils.import_textstat",
"langchain.callbacks.utils.import_pandas",
"langchain.callbacks.utils.flatten_dict"
] | [((1047, 1114), 'comet_ml.Experiment', 'comet_ml.Experiment', ([], {'workspace': 'workspace', 'project_name': 'project_name'}), '(workspace=workspace, project_name=project_name)\n', (1066, 1114), False, 'import comet_ml\n'), ((1249, 1266), 'langchain.callbacks.utils.import_textstat', 'import_textstat', ([], {}), '()\n', (1264, 1266), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((2400, 2415), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (2413, 2415), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((4318, 4347), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (4345, 4347), False, 'import tempfile\n'), ((16471, 16509), 'pathlib.Path', 'Path', (['self.temp_dir.name', '"""model.json"""'], {}), "(self.temp_dir.name, 'model.json')\n", (16475, 16509), False, 'from pathlib import Path\n'), ((19081, 19095), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (19093, 19095), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((21551, 21580), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (21578, 21580), False, 'import tempfile\n'), ((21682, 21697), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (21695, 21697), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5161, 5175), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (5173, 5175), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5701, 5725), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (5713, 5725), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5842, 5860), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (5850, 5860), False, 'from copy import deepcopy\n'), ((6776, 6815), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['(response.llm_output or {})'], {}), '(response.llm_output or {})\n', (6788, 6815), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((8664, 8688), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (8676, 8688), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((10795, 10819), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (10807, 10819), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((7159, 7177), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (7167, 7177), False, 'from copy import deepcopy\n'), ((8886, 8900), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (8894, 8900), False, 'from copy import deepcopy\n'), ((9828, 9842), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (9836, 9842), False, 'from copy import deepcopy\n')] |
import tempfile
from copy import deepcopy
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Sequence
import langchain
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.utils import (
BaseMetadataCallbackHandler,
flatten_dict,
import_pandas,
import_spacy,
import_textstat,
)
from langchain.schema import AgentAction, AgentFinish, Generation, LLMResult
LANGCHAIN_MODEL_NAME = "langchain-model"
def import_comet_ml() -> Any:
"""Import comet_ml and raise an error if it is not installed."""
try:
import comet_ml # noqa: F401
except ImportError:
raise ImportError(
"To use the comet_ml callback manager you need to have the "
"`comet_ml` python package installed. Please install it with"
" `pip install comet_ml`"
)
return comet_ml
def _get_experiment(
workspace: Optional[str] = None, project_name: Optional[str] = None
) -> Any:
comet_ml = import_comet_ml()
experiment = comet_ml.Experiment( # type: ignore
workspace=workspace,
project_name=project_name,
)
return experiment
def _fetch_text_complexity_metrics(text: str) -> dict:
textstat = import_textstat()
text_complexity_metrics = {
"flesch_reading_ease": textstat.flesch_reading_ease(text),
"flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
"smog_index": textstat.smog_index(text),
"coleman_liau_index": textstat.coleman_liau_index(text),
"automated_readability_index": textstat.automated_readability_index(text),
"dale_chall_readability_score": textstat.dale_chall_readability_score(text),
"difficult_words": textstat.difficult_words(text),
"linsear_write_formula": textstat.linsear_write_formula(text),
"gunning_fog": textstat.gunning_fog(text),
"text_standard": textstat.text_standard(text),
"fernandez_huerta": textstat.fernandez_huerta(text),
"szigriszt_pazos": textstat.szigriszt_pazos(text),
"gutierrez_polini": textstat.gutierrez_polini(text),
"crawford": textstat.crawford(text),
"gulpease_index": textstat.gulpease_index(text),
"osman": textstat.osman(text),
}
return text_complexity_metrics
def _summarize_metrics_for_generated_outputs(metrics: Sequence) -> dict:
pd = import_pandas()
metrics_df = pd.DataFrame(metrics)
metrics_summary = metrics_df.describe()
return metrics_summary.to_dict()
class CometCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
"""Callback Handler that logs to Comet.
Parameters:
job_type (str): The type of comet_ml task such as "inference",
"testing" or "qc"
project_name (str): The comet_ml project name
tags (list): Tags to add to the task
task_name (str): Name of the comet_ml task
visualize (bool): Whether to visualize the run.
complexity_metrics (bool): Whether to log complexity metrics
stream_logs (bool): Whether to stream callback actions to Comet
This handler will utilize the associated callback method and formats
the input of each callback function with metadata regarding the state of LLM run,
and adds the response to the list of records for both the {method}_records and
action. It then logs the response to Comet.
"""
def __init__(
self,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
stream_logs: bool = True,
) -> None:
"""Initialize callback handler."""
self.comet_ml = import_comet_ml()
super().__init__()
self.task_type = task_type
self.workspace = workspace
self.project_name = project_name
self.tags = tags
self.visualizations = visualizations
self.complexity_metrics = complexity_metrics
self.custom_metrics = custom_metrics
self.stream_logs = stream_logs
self.temp_dir = tempfile.TemporaryDirectory()
self.experiment = _get_experiment(workspace, project_name)
self.experiment.log_other("Created from", "langchain")
if tags:
self.experiment.add_tags(tags)
self.name = name
if self.name:
self.experiment.set_name(self.name)
warning = (
"The comet_ml callback is currently in beta and is subject to change "
"based on updates to `langchain`. Please report any issues to "
"https://github.com/comet-ml/issue-tracking/issues with the tag "
"`langchain`."
)
self.comet_ml.LOGGER.warning(warning)
self.callback_columns: list = []
self.action_records: list = []
self.complexity_metrics = complexity_metrics
if self.visualizations:
spacy = import_spacy()
self.nlp = spacy.load("en_core_web_sm")
else:
self.nlp = None
def _init_resp(self) -> Dict:
return {k: None for k in self.callback_columns}
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when LLM starts."""
self.step += 1
self.llm_starts += 1
self.starts += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_start"})
metadata.update(flatten_dict(serialized))
metadata.update(self.get_custom_callback_meta())
for prompt in prompts:
prompt_resp = deepcopy(metadata)
prompt_resp["prompts"] = prompt
self.on_llm_start_records.append(prompt_resp)
self.action_records.append(prompt_resp)
if self.stream_logs:
self._log_stream(prompt, metadata, self.step)
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run when LLM generates a new token."""
self.step += 1
self.llm_streams += 1
resp = self._init_resp()
resp.update({"action": "on_llm_new_token", "token": token})
resp.update(self.get_custom_callback_meta())
self.action_records.append(resp)
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when LLM ends running."""
self.step += 1
self.llm_ends += 1
self.ends += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_end"})
metadata.update(flatten_dict(response.llm_output or {}))
metadata.update(self.get_custom_callback_meta())
output_complexity_metrics = []
output_custom_metrics = []
for prompt_idx, generations in enumerate(response.generations):
for gen_idx, generation in enumerate(generations):
text = generation.text
generation_resp = deepcopy(metadata)
generation_resp.update(flatten_dict(generation.dict()))
complexity_metrics = self._get_complexity_metrics(text)
if complexity_metrics:
output_complexity_metrics.append(complexity_metrics)
generation_resp.update(complexity_metrics)
custom_metrics = self._get_custom_metrics(
generation, prompt_idx, gen_idx
)
if custom_metrics:
output_custom_metrics.append(custom_metrics)
generation_resp.update(custom_metrics)
if self.stream_logs:
self._log_stream(text, metadata, self.step)
self.action_records.append(generation_resp)
self.on_llm_end_records.append(generation_resp)
self._log_text_metrics(output_complexity_metrics, step=self.step)
self._log_text_metrics(output_custom_metrics, step=self.step)
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when LLM errors."""
self.step += 1
self.errors += 1
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Run when chain starts running."""
self.step += 1
self.chain_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_chain_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
for chain_input_key, chain_input_val in inputs.items():
if isinstance(chain_input_val, str):
input_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_input_val, resp, self.step)
input_resp.update({chain_input_key: chain_input_val})
self.action_records.append(input_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Input Value for {chain_input_key} will not be logged"
)
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Run when chain ends running."""
self.step += 1
self.chain_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_chain_end"})
resp.update(self.get_custom_callback_meta())
for chain_output_key, chain_output_val in outputs.items():
if isinstance(chain_output_val, str):
output_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_output_val, resp, self.step)
output_resp.update({chain_output_key: chain_output_val})
self.action_records.append(output_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Output Value for {chain_output_key} will not be logged"
)
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when chain errors."""
self.step += 1
self.errors += 1
def on_tool_start(
self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
) -> None:
"""Run when tool starts running."""
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_tool_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(input_str, resp, self.step)
resp.update({"input_str": input_str})
self.action_records.append(resp)
def on_tool_end(self, output: str, **kwargs: Any) -> None:
"""Run when tool ends running."""
self.step += 1
self.tool_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_tool_end"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when tool errors."""
self.step += 1
self.errors += 1
def on_text(self, text: str, **kwargs: Any) -> None:
"""
Run when agent is ending.
"""
self.step += 1
self.text_ctr += 1
resp = self._init_resp()
resp.update({"action": "on_text"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(text, resp, self.step)
resp.update({"text": text})
self.action_records.append(resp)
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run when agent ends running."""
self.step += 1
self.agent_ends += 1
self.ends += 1
resp = self._init_resp()
output = finish.return_values["output"]
log = finish.log
resp.update({"action": "on_agent_finish", "log": log})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
self.step += 1
self.tool_starts += 1
self.starts += 1
tool = action.tool
tool_input = str(action.tool_input)
log = action.log
resp = self._init_resp()
resp.update({"action": "on_agent_action", "log": log, "tool": tool})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(tool_input, resp, self.step)
resp.update({"tool_input": tool_input})
self.action_records.append(resp)
def _get_complexity_metrics(self, text: str) -> dict:
"""Compute text complexity metrics using textstat.
Parameters:
text (str): The text to analyze.
Returns:
(dict): A dictionary containing the complexity metrics.
"""
resp = {}
if self.complexity_metrics:
text_complexity_metrics = _fetch_text_complexity_metrics(text)
resp.update(text_complexity_metrics)
return resp
def _get_custom_metrics(
self, generation: Generation, prompt_idx: int, gen_idx: int
) -> dict:
"""Compute Custom Metrics for an LLM Generated Output
Args:
generation (LLMResult): Output generation from an LLM
prompt_idx (int): List index of the input prompt
gen_idx (int): List index of the generated output
Returns:
dict: A dictionary containing the custom metrics.
"""
resp = {}
if self.custom_metrics:
custom_metrics = self.custom_metrics(generation, prompt_idx, gen_idx)
resp.update(custom_metrics)
return resp
def flush_tracker(
self,
langchain_asset: Any = None,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = "comet-langchain-demo",
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
finish: bool = False,
reset: bool = False,
) -> None:
"""Flush the tracker and setup the session.
Everything after this will be a new table.
Args:
name: Name of the performed session so far so it is identifiable
langchain_asset: The langchain asset to save.
finish: Whether to finish the run.
Returns:
None
"""
self._log_session(langchain_asset)
if langchain_asset:
try:
self._log_model(langchain_asset)
except Exception:
self.comet_ml.LOGGER.error(
"Failed to export agent or LLM to Comet",
exc_info=True,
extra={"show_traceback": True},
)
if finish:
self.experiment.end()
if reset:
self._reset(
task_type,
workspace,
project_name,
tags,
name,
visualizations,
complexity_metrics,
custom_metrics,
)
def _log_stream(self, prompt: str, metadata: dict, step: int) -> None:
self.experiment.log_text(prompt, metadata=metadata, step=step)
def _log_model(self, langchain_asset: Any) -> None:
model_parameters = self._get_llm_parameters(langchain_asset)
self.experiment.log_parameters(model_parameters, prefix="model")
langchain_asset_path = Path(self.temp_dir.name, "model.json")
model_name = self.name if self.name else LANGCHAIN_MODEL_NAME
try:
if hasattr(langchain_asset, "save"):
langchain_asset.save(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
except (ValueError, AttributeError, NotImplementedError) as e:
if hasattr(langchain_asset, "save_agent"):
langchain_asset.save_agent(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
else:
self.comet_ml.LOGGER.error(
f"{e}"
" Could not save Langchain Asset "
f"for {langchain_asset.__class__.__name__}"
)
def _log_session(self, langchain_asset: Optional[Any] = None) -> None:
try:
llm_session_df = self._create_session_analysis_dataframe(langchain_asset)
# Log the cleaned dataframe as a table
self.experiment.log_table("langchain-llm-session.csv", llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
metadata = {"langchain_version": str(langchain.__version__)}
# Log the langchain low-level records as a JSON file directly
self.experiment.log_asset_data(
self.action_records, "langchain-action_records.json", metadata=metadata
)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
self._log_visualizations(llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log visualizations to Comet",
exc_info=True,
extra={"show_traceback": True},
)
def _log_text_metrics(self, metrics: Sequence[dict], step: int) -> None:
if not metrics:
return
metrics_summary = _summarize_metrics_for_generated_outputs(metrics)
for key, value in metrics_summary.items():
self.experiment.log_metrics(value, prefix=key, step=step)
def _log_visualizations(self, session_df: Any) -> None:
if not (self.visualizations and self.nlp):
return
spacy = import_spacy()
prompts = session_df["prompts"].tolist()
outputs = session_df["text"].tolist()
for idx, (prompt, output) in enumerate(zip(prompts, outputs)):
doc = self.nlp(output)
sentence_spans = list(doc.sents)
for visualization in self.visualizations:
try:
html = spacy.displacy.render(
sentence_spans,
style=visualization,
options={"compact": True},
jupyter=False,
page=True,
)
self.experiment.log_asset_data(
html,
name=f"langchain-viz-{visualization}-{idx}.html",
metadata={"prompt": prompt},
step=idx,
)
except Exception as e:
self.comet_ml.LOGGER.warning(
e, exc_info=True, extra={"show_traceback": True}
)
return
def _reset(
self,
task_type: Optional[str] = None,
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
) -> None:
_task_type = task_type if task_type else self.task_type
_workspace = workspace if workspace else self.workspace
_project_name = project_name if project_name else self.project_name
_tags = tags if tags else self.tags
_name = name if name else self.name
_visualizations = visualizations if visualizations else self.visualizations
_complexity_metrics = (
complexity_metrics if complexity_metrics else self.complexity_metrics
)
_custom_metrics = custom_metrics if custom_metrics else self.custom_metrics
self.__init__( # type: ignore
task_type=_task_type,
workspace=_workspace,
project_name=_project_name,
tags=_tags,
name=_name,
visualizations=_visualizations,
complexity_metrics=_complexity_metrics,
custom_metrics=_custom_metrics,
)
self.reset_callback_meta()
self.temp_dir = tempfile.TemporaryDirectory()
def _create_session_analysis_dataframe(self, langchain_asset: Any = None) -> dict:
pd = import_pandas()
llm_parameters = self._get_llm_parameters(langchain_asset)
num_generations_per_prompt = llm_parameters.get("n", 1)
llm_start_records_df = pd.DataFrame(self.on_llm_start_records)
# Repeat each input row based on the number of outputs generated per prompt
llm_start_records_df = llm_start_records_df.loc[
llm_start_records_df.index.repeat(num_generations_per_prompt)
].reset_index(drop=True)
llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
llm_session_df = pd.merge(
llm_start_records_df,
llm_end_records_df,
left_index=True,
right_index=True,
suffixes=["_llm_start", "_llm_end"],
)
return llm_session_df
def _get_llm_parameters(self, langchain_asset: Any = None) -> dict:
if not langchain_asset:
return {}
try:
if hasattr(langchain_asset, "agent"):
llm_parameters = langchain_asset.agent.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm_chain"):
llm_parameters = langchain_asset.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm"):
llm_parameters = langchain_asset.llm.dict()
else:
llm_parameters = langchain_asset.dict()
except Exception:
return {}
return llm_parameters
| [
"langchain.callbacks.utils.import_spacy",
"langchain.callbacks.utils.import_textstat",
"langchain.callbacks.utils.import_pandas",
"langchain.callbacks.utils.flatten_dict"
] | [((1047, 1114), 'comet_ml.Experiment', 'comet_ml.Experiment', ([], {'workspace': 'workspace', 'project_name': 'project_name'}), '(workspace=workspace, project_name=project_name)\n', (1066, 1114), False, 'import comet_ml\n'), ((1249, 1266), 'langchain.callbacks.utils.import_textstat', 'import_textstat', ([], {}), '()\n', (1264, 1266), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((2400, 2415), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (2413, 2415), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((4318, 4347), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (4345, 4347), False, 'import tempfile\n'), ((16471, 16509), 'pathlib.Path', 'Path', (['self.temp_dir.name', '"""model.json"""'], {}), "(self.temp_dir.name, 'model.json')\n", (16475, 16509), False, 'from pathlib import Path\n'), ((19081, 19095), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (19093, 19095), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((21551, 21580), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (21578, 21580), False, 'import tempfile\n'), ((21682, 21697), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (21695, 21697), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5161, 5175), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (5173, 5175), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5701, 5725), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (5713, 5725), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5842, 5860), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (5850, 5860), False, 'from copy import deepcopy\n'), ((6776, 6815), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['(response.llm_output or {})'], {}), '(response.llm_output or {})\n', (6788, 6815), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((8664, 8688), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (8676, 8688), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((10795, 10819), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (10807, 10819), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((7159, 7177), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (7167, 7177), False, 'from copy import deepcopy\n'), ((8886, 8900), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (8894, 8900), False, 'from copy import deepcopy\n'), ((9828, 9842), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (9836, 9842), False, 'from copy import deepcopy\n')] |
import tempfile
from copy import deepcopy
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Sequence
import langchain
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.utils import (
BaseMetadataCallbackHandler,
flatten_dict,
import_pandas,
import_spacy,
import_textstat,
)
from langchain.schema import AgentAction, AgentFinish, Generation, LLMResult
LANGCHAIN_MODEL_NAME = "langchain-model"
def import_comet_ml() -> Any:
"""Import comet_ml and raise an error if it is not installed."""
try:
import comet_ml # noqa: F401
except ImportError:
raise ImportError(
"To use the comet_ml callback manager you need to have the "
"`comet_ml` python package installed. Please install it with"
" `pip install comet_ml`"
)
return comet_ml
def _get_experiment(
workspace: Optional[str] = None, project_name: Optional[str] = None
) -> Any:
comet_ml = import_comet_ml()
experiment = comet_ml.Experiment( # type: ignore
workspace=workspace,
project_name=project_name,
)
return experiment
def _fetch_text_complexity_metrics(text: str) -> dict:
textstat = import_textstat()
text_complexity_metrics = {
"flesch_reading_ease": textstat.flesch_reading_ease(text),
"flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
"smog_index": textstat.smog_index(text),
"coleman_liau_index": textstat.coleman_liau_index(text),
"automated_readability_index": textstat.automated_readability_index(text),
"dale_chall_readability_score": textstat.dale_chall_readability_score(text),
"difficult_words": textstat.difficult_words(text),
"linsear_write_formula": textstat.linsear_write_formula(text),
"gunning_fog": textstat.gunning_fog(text),
"text_standard": textstat.text_standard(text),
"fernandez_huerta": textstat.fernandez_huerta(text),
"szigriszt_pazos": textstat.szigriszt_pazos(text),
"gutierrez_polini": textstat.gutierrez_polini(text),
"crawford": textstat.crawford(text),
"gulpease_index": textstat.gulpease_index(text),
"osman": textstat.osman(text),
}
return text_complexity_metrics
def _summarize_metrics_for_generated_outputs(metrics: Sequence) -> dict:
pd = import_pandas()
metrics_df = pd.DataFrame(metrics)
metrics_summary = metrics_df.describe()
return metrics_summary.to_dict()
class CometCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
"""Callback Handler that logs to Comet.
Parameters:
job_type (str): The type of comet_ml task such as "inference",
"testing" or "qc"
project_name (str): The comet_ml project name
tags (list): Tags to add to the task
task_name (str): Name of the comet_ml task
visualize (bool): Whether to visualize the run.
complexity_metrics (bool): Whether to log complexity metrics
stream_logs (bool): Whether to stream callback actions to Comet
This handler will utilize the associated callback method and formats
the input of each callback function with metadata regarding the state of LLM run,
and adds the response to the list of records for both the {method}_records and
action. It then logs the response to Comet.
"""
def __init__(
self,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
stream_logs: bool = True,
) -> None:
"""Initialize callback handler."""
self.comet_ml = import_comet_ml()
super().__init__()
self.task_type = task_type
self.workspace = workspace
self.project_name = project_name
self.tags = tags
self.visualizations = visualizations
self.complexity_metrics = complexity_metrics
self.custom_metrics = custom_metrics
self.stream_logs = stream_logs
self.temp_dir = tempfile.TemporaryDirectory()
self.experiment = _get_experiment(workspace, project_name)
self.experiment.log_other("Created from", "langchain")
if tags:
self.experiment.add_tags(tags)
self.name = name
if self.name:
self.experiment.set_name(self.name)
warning = (
"The comet_ml callback is currently in beta and is subject to change "
"based on updates to `langchain`. Please report any issues to "
"https://github.com/comet-ml/issue-tracking/issues with the tag "
"`langchain`."
)
self.comet_ml.LOGGER.warning(warning)
self.callback_columns: list = []
self.action_records: list = []
self.complexity_metrics = complexity_metrics
if self.visualizations:
spacy = import_spacy()
self.nlp = spacy.load("en_core_web_sm")
else:
self.nlp = None
def _init_resp(self) -> Dict:
return {k: None for k in self.callback_columns}
def on_llm_start(
self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
) -> None:
"""Run when LLM starts."""
self.step += 1
self.llm_starts += 1
self.starts += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_start"})
metadata.update(flatten_dict(serialized))
metadata.update(self.get_custom_callback_meta())
for prompt in prompts:
prompt_resp = deepcopy(metadata)
prompt_resp["prompts"] = prompt
self.on_llm_start_records.append(prompt_resp)
self.action_records.append(prompt_resp)
if self.stream_logs:
self._log_stream(prompt, metadata, self.step)
def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
"""Run when LLM generates a new token."""
self.step += 1
self.llm_streams += 1
resp = self._init_resp()
resp.update({"action": "on_llm_new_token", "token": token})
resp.update(self.get_custom_callback_meta())
self.action_records.append(resp)
def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
"""Run when LLM ends running."""
self.step += 1
self.llm_ends += 1
self.ends += 1
metadata = self._init_resp()
metadata.update({"action": "on_llm_end"})
metadata.update(flatten_dict(response.llm_output or {}))
metadata.update(self.get_custom_callback_meta())
output_complexity_metrics = []
output_custom_metrics = []
for prompt_idx, generations in enumerate(response.generations):
for gen_idx, generation in enumerate(generations):
text = generation.text
generation_resp = deepcopy(metadata)
generation_resp.update(flatten_dict(generation.dict()))
complexity_metrics = self._get_complexity_metrics(text)
if complexity_metrics:
output_complexity_metrics.append(complexity_metrics)
generation_resp.update(complexity_metrics)
custom_metrics = self._get_custom_metrics(
generation, prompt_idx, gen_idx
)
if custom_metrics:
output_custom_metrics.append(custom_metrics)
generation_resp.update(custom_metrics)
if self.stream_logs:
self._log_stream(text, metadata, self.step)
self.action_records.append(generation_resp)
self.on_llm_end_records.append(generation_resp)
self._log_text_metrics(output_complexity_metrics, step=self.step)
self._log_text_metrics(output_custom_metrics, step=self.step)
def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when LLM errors."""
self.step += 1
self.errors += 1
def on_chain_start(
self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
) -> None:
"""Run when chain starts running."""
self.step += 1
self.chain_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_chain_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
for chain_input_key, chain_input_val in inputs.items():
if isinstance(chain_input_val, str):
input_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_input_val, resp, self.step)
input_resp.update({chain_input_key: chain_input_val})
self.action_records.append(input_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Input Value for {chain_input_key} will not be logged"
)
def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
"""Run when chain ends running."""
self.step += 1
self.chain_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_chain_end"})
resp.update(self.get_custom_callback_meta())
for chain_output_key, chain_output_val in outputs.items():
if isinstance(chain_output_val, str):
output_resp = deepcopy(resp)
if self.stream_logs:
self._log_stream(chain_output_val, resp, self.step)
output_resp.update({chain_output_key: chain_output_val})
self.action_records.append(output_resp)
else:
self.comet_ml.LOGGER.warning(
f"Unexpected data format provided! "
f"Output Value for {chain_output_key} will not be logged"
)
def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when chain errors."""
self.step += 1
self.errors += 1
def on_tool_start(
self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
) -> None:
"""Run when tool starts running."""
self.step += 1
self.tool_starts += 1
self.starts += 1
resp = self._init_resp()
resp.update({"action": "on_tool_start"})
resp.update(flatten_dict(serialized))
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(input_str, resp, self.step)
resp.update({"input_str": input_str})
self.action_records.append(resp)
def on_tool_end(self, output: str, **kwargs: Any) -> None:
"""Run when tool ends running."""
self.step += 1
self.tool_ends += 1
self.ends += 1
resp = self._init_resp()
resp.update({"action": "on_tool_end"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
"""Run when tool errors."""
self.step += 1
self.errors += 1
def on_text(self, text: str, **kwargs: Any) -> None:
"""
Run when agent is ending.
"""
self.step += 1
self.text_ctr += 1
resp = self._init_resp()
resp.update({"action": "on_text"})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(text, resp, self.step)
resp.update({"text": text})
self.action_records.append(resp)
def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
"""Run when agent ends running."""
self.step += 1
self.agent_ends += 1
self.ends += 1
resp = self._init_resp()
output = finish.return_values["output"]
log = finish.log
resp.update({"action": "on_agent_finish", "log": log})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(output, resp, self.step)
resp.update({"output": output})
self.action_records.append(resp)
def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
"""Run on agent action."""
self.step += 1
self.tool_starts += 1
self.starts += 1
tool = action.tool
tool_input = str(action.tool_input)
log = action.log
resp = self._init_resp()
resp.update({"action": "on_agent_action", "log": log, "tool": tool})
resp.update(self.get_custom_callback_meta())
if self.stream_logs:
self._log_stream(tool_input, resp, self.step)
resp.update({"tool_input": tool_input})
self.action_records.append(resp)
def _get_complexity_metrics(self, text: str) -> dict:
"""Compute text complexity metrics using textstat.
Parameters:
text (str): The text to analyze.
Returns:
(dict): A dictionary containing the complexity metrics.
"""
resp = {}
if self.complexity_metrics:
text_complexity_metrics = _fetch_text_complexity_metrics(text)
resp.update(text_complexity_metrics)
return resp
def _get_custom_metrics(
self, generation: Generation, prompt_idx: int, gen_idx: int
) -> dict:
"""Compute Custom Metrics for an LLM Generated Output
Args:
generation (LLMResult): Output generation from an LLM
prompt_idx (int): List index of the input prompt
gen_idx (int): List index of the generated output
Returns:
dict: A dictionary containing the custom metrics.
"""
resp = {}
if self.custom_metrics:
custom_metrics = self.custom_metrics(generation, prompt_idx, gen_idx)
resp.update(custom_metrics)
return resp
def flush_tracker(
self,
langchain_asset: Any = None,
task_type: Optional[str] = "inference",
workspace: Optional[str] = None,
project_name: Optional[str] = "comet-langchain-demo",
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
finish: bool = False,
reset: bool = False,
) -> None:
"""Flush the tracker and setup the session.
Everything after this will be a new table.
Args:
name: Name of the performed session so far so it is identifiable
langchain_asset: The langchain asset to save.
finish: Whether to finish the run.
Returns:
None
"""
self._log_session(langchain_asset)
if langchain_asset:
try:
self._log_model(langchain_asset)
except Exception:
self.comet_ml.LOGGER.error(
"Failed to export agent or LLM to Comet",
exc_info=True,
extra={"show_traceback": True},
)
if finish:
self.experiment.end()
if reset:
self._reset(
task_type,
workspace,
project_name,
tags,
name,
visualizations,
complexity_metrics,
custom_metrics,
)
def _log_stream(self, prompt: str, metadata: dict, step: int) -> None:
self.experiment.log_text(prompt, metadata=metadata, step=step)
def _log_model(self, langchain_asset: Any) -> None:
model_parameters = self._get_llm_parameters(langchain_asset)
self.experiment.log_parameters(model_parameters, prefix="model")
langchain_asset_path = Path(self.temp_dir.name, "model.json")
model_name = self.name if self.name else LANGCHAIN_MODEL_NAME
try:
if hasattr(langchain_asset, "save"):
langchain_asset.save(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
except (ValueError, AttributeError, NotImplementedError) as e:
if hasattr(langchain_asset, "save_agent"):
langchain_asset.save_agent(langchain_asset_path)
self.experiment.log_model(model_name, str(langchain_asset_path))
else:
self.comet_ml.LOGGER.error(
f"{e}"
" Could not save Langchain Asset "
f"for {langchain_asset.__class__.__name__}"
)
def _log_session(self, langchain_asset: Optional[Any] = None) -> None:
try:
llm_session_df = self._create_session_analysis_dataframe(langchain_asset)
# Log the cleaned dataframe as a table
self.experiment.log_table("langchain-llm-session.csv", llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
metadata = {"langchain_version": str(langchain.__version__)}
# Log the langchain low-level records as a JSON file directly
self.experiment.log_asset_data(
self.action_records, "langchain-action_records.json", metadata=metadata
)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log session data to Comet",
exc_info=True,
extra={"show_traceback": True},
)
try:
self._log_visualizations(llm_session_df)
except Exception:
self.comet_ml.LOGGER.warning(
"Failed to log visualizations to Comet",
exc_info=True,
extra={"show_traceback": True},
)
def _log_text_metrics(self, metrics: Sequence[dict], step: int) -> None:
if not metrics:
return
metrics_summary = _summarize_metrics_for_generated_outputs(metrics)
for key, value in metrics_summary.items():
self.experiment.log_metrics(value, prefix=key, step=step)
def _log_visualizations(self, session_df: Any) -> None:
if not (self.visualizations and self.nlp):
return
spacy = import_spacy()
prompts = session_df["prompts"].tolist()
outputs = session_df["text"].tolist()
for idx, (prompt, output) in enumerate(zip(prompts, outputs)):
doc = self.nlp(output)
sentence_spans = list(doc.sents)
for visualization in self.visualizations:
try:
html = spacy.displacy.render(
sentence_spans,
style=visualization,
options={"compact": True},
jupyter=False,
page=True,
)
self.experiment.log_asset_data(
html,
name=f"langchain-viz-{visualization}-{idx}.html",
metadata={"prompt": prompt},
step=idx,
)
except Exception as e:
self.comet_ml.LOGGER.warning(
e, exc_info=True, extra={"show_traceback": True}
)
return
def _reset(
self,
task_type: Optional[str] = None,
workspace: Optional[str] = None,
project_name: Optional[str] = None,
tags: Optional[Sequence] = None,
name: Optional[str] = None,
visualizations: Optional[List[str]] = None,
complexity_metrics: bool = False,
custom_metrics: Optional[Callable] = None,
) -> None:
_task_type = task_type if task_type else self.task_type
_workspace = workspace if workspace else self.workspace
_project_name = project_name if project_name else self.project_name
_tags = tags if tags else self.tags
_name = name if name else self.name
_visualizations = visualizations if visualizations else self.visualizations
_complexity_metrics = (
complexity_metrics if complexity_metrics else self.complexity_metrics
)
_custom_metrics = custom_metrics if custom_metrics else self.custom_metrics
self.__init__( # type: ignore
task_type=_task_type,
workspace=_workspace,
project_name=_project_name,
tags=_tags,
name=_name,
visualizations=_visualizations,
complexity_metrics=_complexity_metrics,
custom_metrics=_custom_metrics,
)
self.reset_callback_meta()
self.temp_dir = tempfile.TemporaryDirectory()
def _create_session_analysis_dataframe(self, langchain_asset: Any = None) -> dict:
pd = import_pandas()
llm_parameters = self._get_llm_parameters(langchain_asset)
num_generations_per_prompt = llm_parameters.get("n", 1)
llm_start_records_df = pd.DataFrame(self.on_llm_start_records)
# Repeat each input row based on the number of outputs generated per prompt
llm_start_records_df = llm_start_records_df.loc[
llm_start_records_df.index.repeat(num_generations_per_prompt)
].reset_index(drop=True)
llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
llm_session_df = pd.merge(
llm_start_records_df,
llm_end_records_df,
left_index=True,
right_index=True,
suffixes=["_llm_start", "_llm_end"],
)
return llm_session_df
def _get_llm_parameters(self, langchain_asset: Any = None) -> dict:
if not langchain_asset:
return {}
try:
if hasattr(langchain_asset, "agent"):
llm_parameters = langchain_asset.agent.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm_chain"):
llm_parameters = langchain_asset.llm_chain.llm.dict()
elif hasattr(langchain_asset, "llm"):
llm_parameters = langchain_asset.llm.dict()
else:
llm_parameters = langchain_asset.dict()
except Exception:
return {}
return llm_parameters
| [
"langchain.callbacks.utils.import_spacy",
"langchain.callbacks.utils.import_textstat",
"langchain.callbacks.utils.import_pandas",
"langchain.callbacks.utils.flatten_dict"
] | [((1047, 1114), 'comet_ml.Experiment', 'comet_ml.Experiment', ([], {'workspace': 'workspace', 'project_name': 'project_name'}), '(workspace=workspace, project_name=project_name)\n', (1066, 1114), False, 'import comet_ml\n'), ((1249, 1266), 'langchain.callbacks.utils.import_textstat', 'import_textstat', ([], {}), '()\n', (1264, 1266), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((2400, 2415), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (2413, 2415), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((4318, 4347), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (4345, 4347), False, 'import tempfile\n'), ((16471, 16509), 'pathlib.Path', 'Path', (['self.temp_dir.name', '"""model.json"""'], {}), "(self.temp_dir.name, 'model.json')\n", (16475, 16509), False, 'from pathlib import Path\n'), ((19081, 19095), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (19093, 19095), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((21551, 21580), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (21578, 21580), False, 'import tempfile\n'), ((21682, 21697), 'langchain.callbacks.utils.import_pandas', 'import_pandas', ([], {}), '()\n', (21695, 21697), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5161, 5175), 'langchain.callbacks.utils.import_spacy', 'import_spacy', ([], {}), '()\n', (5173, 5175), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5701, 5725), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (5713, 5725), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((5842, 5860), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (5850, 5860), False, 'from copy import deepcopy\n'), ((6776, 6815), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['(response.llm_output or {})'], {}), '(response.llm_output or {})\n', (6788, 6815), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((8664, 8688), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (8676, 8688), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((10795, 10819), 'langchain.callbacks.utils.flatten_dict', 'flatten_dict', (['serialized'], {}), '(serialized)\n', (10807, 10819), False, 'from langchain.callbacks.utils import BaseMetadataCallbackHandler, flatten_dict, import_pandas, import_spacy, import_textstat\n'), ((7159, 7177), 'copy.deepcopy', 'deepcopy', (['metadata'], {}), '(metadata)\n', (7167, 7177), False, 'from copy import deepcopy\n'), ((8886, 8900), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (8894, 8900), False, 'from copy import deepcopy\n'), ((9828, 9842), 'copy.deepcopy', 'deepcopy', (['resp'], {}), '(resp)\n', (9836, 9842), False, 'from copy import deepcopy\n')] |
"""Utilities for running language models or Chains over datasets."""
from __future__ import annotations
import asyncio
import functools
import itertools
import logging
import uuid
from enum import Enum
from typing import (
Any,
Callable,
Coroutine,
Dict,
Iterator,
List,
Optional,
Sequence,
Tuple,
Union,
)
from urllib.parse import urlparse, urlunparse
from langsmith import Client, RunEvaluator
from langsmith.schemas import Dataset, DataType, Example
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.manager import Callbacks
from langchain.callbacks.tracers.base import BaseTracer
from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler
from langchain.callbacks.tracers.langchain import LangChainTracer
from langchain.chains.base import Chain
from langchain.chat_models.openai import ChatOpenAI
from langchain.evaluation.loading import load_evaluator
from langchain.evaluation.schema import EvaluatorType, StringEvaluator
from langchain.schema import ChatResult, LLMResult
from langchain.schema.language_model import BaseLanguageModel
from langchain.schema.messages import BaseMessage, messages_from_dict
from langchain.smith.evaluation.config import EvalConfig, RunEvalConfig
from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain
logger = logging.getLogger(__name__)
MODEL_OR_CHAIN_FACTORY = Union[Callable[[], Chain], BaseLanguageModel]
class InputFormatError(Exception):
"""Raised when the input format is invalid."""
## Shared Utilities
def _get_eval_project_url(api_url: str, project_id: str) -> str:
"""Get the project url from the api url."""
parsed = urlparse(api_url)
hostname = parsed.hostname or ""
if "api." in hostname:
hostname = hostname.replace("api.", "", 1)
if "localhost" in hostname:
# Remove the port
hostname = "localhost"
url = urlunparse(parsed._replace(netloc=hostname))
return f"{url}/projects/p/{project_id}?eval=true"
def _wrap_in_chain_factory(
llm_or_chain_factory: Union[Chain, MODEL_OR_CHAIN_FACTORY],
dataset_name: str = "<my_dataset>",
) -> MODEL_OR_CHAIN_FACTORY:
"""Forgive the user if they pass in a chain without memory instead of a chain
factory. It's a common mistake. Raise a more helpful error message as well."""
if isinstance(llm_or_chain_factory, Chain):
chain = llm_or_chain_factory
chain_class = chain.__class__.__name__
if llm_or_chain_factory.memory is not None:
memory_class = chain.memory.__class__.__name__
raise ValueError(
"Cannot directly evaluate a chain with stateful memory."
" To evaluate this chain, pass in a chain constructor"
" that initializes fresh memory each time it is called."
" This will safegaurd against information"
" leakage between dataset examples."
"\nFor example:\n\n"
"def chain_constructor():\n"
f" new_memory = {memory_class}(...)\n"
f" return {chain_class}"
"(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
logger.warning(
"Directly passing in a chain is not recommended as chains may have state."
" This can lead to unexpected behavior as the "
"same chain instance could be used across multiple datasets. Instead,"
" please pass a chain constructor that creates a new "
"chain with fresh memory each time it is called. This will safeguard"
" against information leakage between dataset examples. "
"\nFor example:\n\n"
"def chain_constructor():\n"
f" return {chain_class}(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
return lambda: chain
elif isinstance(llm_or_chain_factory, BaseLanguageModel):
return llm_or_chain_factory
elif callable(llm_or_chain_factory):
_model = llm_or_chain_factory()
if isinstance(_model, BaseLanguageModel):
return _model
return llm_or_chain_factory
return llm_or_chain_factory
def _first_example(examples: Iterator[Example]) -> Tuple[Example, Iterator[Example]]:
"""Get the first example while chaining it back and preserving the iterator."""
try:
example: Example = next(examples)
except StopIteration:
raise ValueError("No examples provided.")
return example, itertools.chain([example], examples)
def _get_prompt(inputs: Dict[str, Any]) -> str:
"""Get prompt from inputs.
Args:
inputs: The input dictionary.
Returns:
A string prompt.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
prompts = []
if "prompt" in inputs:
if not isinstance(inputs["prompt"], str):
raise InputFormatError(
"Expected string for 'prompt', got"
f" {type(inputs['prompt']).__name__}"
)
prompts = [inputs["prompt"]]
elif "prompts" in inputs:
if not isinstance(inputs["prompts"], list) or not all(
isinstance(i, str) for i in inputs["prompts"]
):
raise InputFormatError(
"Expected list of strings for 'prompts',"
f" got {type(inputs['prompts']).__name__}"
)
prompts = inputs["prompts"]
elif len(inputs) == 1:
prompt_ = next(iter(inputs.values()))
if isinstance(prompt_, str):
prompts = [prompt_]
elif isinstance(prompt_, list) and all(isinstance(i, str) for i in prompt_):
prompts = prompt_
else:
raise InputFormatError(f"LLM Run expects string prompt input. Got {inputs}")
else:
raise InputFormatError(
f"LLM Run expects 'prompt' or 'prompts' in inputs. Got {inputs}"
)
if len(prompts) == 1:
return prompts[0]
else:
raise InputFormatError(
f"LLM Run expects single prompt input. Got {len(prompts)} prompts."
)
def _get_messages(inputs: Dict[str, Any]) -> List[BaseMessage]:
"""Get Chat Messages from inputs.
Args:
inputs: The input dictionary.
Returns:
A list of chat messages.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
if "messages" in inputs:
single_input = inputs["messages"]
elif len(inputs) == 1:
single_input = next(iter(inputs.values()))
else:
raise InputFormatError(
f"Chat Run expects 'messages' in inputs when example has multiple"
f" input keys. Got {inputs}"
)
if isinstance(single_input, list) and all(
isinstance(i, dict) for i in single_input
):
raw_messages = [single_input]
elif isinstance(single_input, list) and all(
isinstance(i, list) for i in single_input
):
raw_messages = single_input
else:
raise InputFormatError(
f"Chat Run expects List[dict] or List[List[dict]] values for"
f" 'messages' key input. Got {inputs}"
)
if len(raw_messages) == 1:
return messages_from_dict(raw_messages[0])
else:
raise InputFormatError(
f"Chat Run expects single List[dict] or List[List[dict]] 'messages'"
f" input. Got {len(raw_messages)} messages from inputs {inputs}"
)
def _get_project_name(
project_name: Optional[str],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
) -> str:
"""
Get the project name.
Args:
project_name: The project name if manually specified.
llm_or_chain_factory: The Chain or language model constructor.
Returns:
The project name.
"""
if project_name is not None:
return project_name
if isinstance(llm_or_chain_factory, BaseLanguageModel):
model_name = llm_or_chain_factory.__class__.__name__
else:
model_name = llm_or_chain_factory().__class__.__name__
hex = uuid.uuid4().hex
return f"{hex}-{model_name}"
## Shared Validation Utilities
def _validate_example_inputs_for_language_model(
first_example: Example,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
if input_mapper:
prompt_input = input_mapper(first_example.inputs)
if not isinstance(prompt_input, str) and not (
isinstance(prompt_input, list)
and all(isinstance(msg, BaseMessage) for msg in prompt_input)
):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for an LLM or chat model, the output must a single string or"
" a list of chat messages."
f"\nGot: {prompt_input} of type {type(prompt_input)}."
)
else:
try:
_get_prompt(first_example.inputs)
except InputFormatError:
try:
_get_messages(first_example.inputs)
except InputFormatError:
raise InputFormatError(
"Example inputs do not match language model input format. "
"Expected a dictionary with messages or a single prompt."
f" Got: {first_example.inputs}"
" Please update your dataset OR provide an input_mapper"
" to convert the example.inputs to a compatible format"
" for the llm or chat model you wish to evaluate."
)
def _validate_example_inputs_for_chain(
first_example: Example,
chain: Chain,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs match the chain input keys."""
if input_mapper:
first_inputs = input_mapper(first_example.inputs)
if not isinstance(first_inputs, dict):
raise InputFormatError(
"When using an input_mapper to prepare dataset example"
" inputs for a chain, the mapped value must be a dictionary."
f"\nGot: {first_inputs} of type {type(first_inputs)}."
)
if not set(first_inputs.keys()) == set(chain.input_keys):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for a chain mapped value must have keys that match the chain's"
" expected input keys."
f"\nExpected: {chain.input_keys}. Got: {first_inputs.keys()}"
)
else:
first_inputs = first_example.inputs
if len(first_inputs) == 1 and len(chain.input_keys) == 1:
# We can pass this through the run method.
# Refrain from calling to validate.
pass
elif not set(first_inputs.keys()) == set(chain.input_keys):
raise InputFormatError(
"Example inputs do not match chain input keys."
" Please provide an input_mapper to convert the example.inputs"
" to a compatible format for the chain you wish to evaluate."
f"Expected: {chain.input_keys}. "
f"Got: {first_inputs.keys()}"
)
def _validate_example_inputs(
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
input_mapper: Optional[Callable[[Dict], Any]],
) -> Iterator[Example]:
"""Validate that the example inputs are valid for the model."""
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
_validate_example_inputs_for_language_model(first_example, input_mapper)
else:
chain = llm_or_chain_factory()
_validate_example_inputs_for_chain(first_example, chain, input_mapper)
return examples
## Shared Evaluator Setup Utilities
def _setup_evaluation(
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
examples: Iterator[Example],
evaluation: Optional[RunEvalConfig],
data_type: DataType,
) -> Tuple[Optional[List[RunEvaluator]], Iterator[Example]]:
"""Configure the evaluators to run on the results of the chain."""
if evaluation:
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
run_inputs, run_outputs = None, None
run_type = "llm"
else:
run_type = "chain"
if data_type in (DataType.chat, DataType.llm):
val = data_type.value if isinstance(data_type, Enum) else data_type
raise ValueError(
"Cannot evaluate a chain on dataset with "
f"data_type={val}. "
"Please specify a dataset with the default 'kv' data type."
)
chain = llm_or_chain_factory()
run_inputs = chain.input_keys
run_outputs = chain.output_keys
run_evaluators = _load_run_evaluators(
evaluation,
run_type,
data_type,
list(first_example.outputs) if first_example.outputs else None,
run_inputs,
run_outputs,
)
else:
# TODO: Create a default helpfulness evaluator
run_evaluators = None
return run_evaluators, examples
def _determine_input_key(
config: RunEvalConfig,
run_inputs: Optional[List[str]],
run_type: str,
) -> Optional[str]:
if config.input_key:
input_key = config.input_key
if run_inputs and input_key not in run_inputs:
raise ValueError(f"Input key {input_key} not in run inputs {run_inputs}")
elif run_type == "llm":
input_key = None
elif run_inputs and len(run_inputs) == 1:
input_key = run_inputs[0]
else:
raise ValueError(
f"Must specify input key for model with multiple inputs: {run_inputs}"
)
return input_key
def _determine_prediction_key(
config: RunEvalConfig,
run_outputs: Optional[List[str]],
run_type: str,
) -> Optional[str]:
if config.prediction_key:
prediction_key = config.prediction_key
if run_outputs and prediction_key not in run_outputs:
raise ValueError(
f"Prediction key {prediction_key} not in run outputs {run_outputs}"
)
elif run_type == "llm":
prediction_key = None
elif run_outputs and len(run_outputs) == 1:
prediction_key = run_outputs[0]
else:
raise ValueError(
f"Must specify prediction key for model"
f" with multiple outputs: {run_outputs}"
)
return prediction_key
def _determine_reference_key(
config: RunEvalConfig,
example_outputs: Optional[List[str]],
) -> Optional[str]:
if config.reference_key:
reference_key = config.reference_key
if example_outputs and reference_key not in example_outputs:
raise ValueError(
f"Reference key {reference_key} not in Dataset"
f" example outputs: {example_outputs}"
)
elif example_outputs and len(example_outputs) == 1:
reference_key = list(example_outputs)[0]
else:
reference_key = None
return reference_key
def _construct_run_evaluator(
eval_config: Union[EvaluatorType, EvalConfig],
eval_llm: BaseLanguageModel,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
reference_key: Optional[str],
input_key: Optional[str],
prediction_key: Optional[str],
) -> RunEvaluator:
if isinstance(eval_config, EvaluatorType):
evaluator_ = load_evaluator(eval_config, llm=eval_llm)
eval_type_tag = eval_config.value
else:
kwargs = {"llm": eval_llm, **eval_config.get_kwargs()}
evaluator_ = load_evaluator(eval_config.evaluator_type, **kwargs)
eval_type_tag = eval_config.evaluator_type.value
if isinstance(evaluator_, StringEvaluator):
if evaluator_.requires_reference and reference_key is None:
raise ValueError(
f"Must specify reference_key in RunEvalConfig to use"
f" evaluator of type {eval_type_tag} with"
f" dataset with multiple output keys: {example_outputs}."
)
run_evaluator = StringRunEvaluatorChain.from_run_and_data_type(
evaluator_,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
tags=[eval_type_tag],
)
else:
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented"
)
return run_evaluator
def _load_run_evaluators(
config: RunEvalConfig,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
) -> List[RunEvaluator]:
"""
Load run evaluators from a configuration.
Args:
config: Configuration for the run evaluators.
Returns:
A list of run evaluators.
"""
eval_llm = config.eval_llm or ChatOpenAI(model="gpt-4", temperature=0.0)
run_evaluators = []
input_key = _determine_input_key(config, run_inputs, run_type)
prediction_key = _determine_prediction_key(config, run_outputs, run_type)
reference_key = _determine_reference_key(config, example_outputs)
for eval_config in config.evaluators:
run_evaluator = _construct_run_evaluator(
eval_config,
eval_llm,
run_type,
data_type,
example_outputs,
reference_key,
input_key,
prediction_key,
)
run_evaluators.append(run_evaluator)
custom_evaluators = config.custom_evaluators or []
for custom_evaluator in custom_evaluators:
if isinstance(custom_evaluator, RunEvaluator):
run_evaluators.append(custom_evaluator)
elif isinstance(custom_evaluator, StringEvaluator):
run_evaluators.append(
StringRunEvaluatorChain.from_run_and_data_type(
custom_evaluator,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
)
)
else:
raise ValueError(
f"Unsupported custom evaluator: {custom_evaluator}."
f" Expected RunEvaluator or StringEvaluator."
)
return run_evaluators
### Async Helpers
async def _arun_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
*,
tags: Optional[List[str]] = None,
callbacks: Callbacks = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""Asynchronously run the language model.
Args:
llm: The language model to run.
inputs: The input dictionary.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map inputs to the expected format.
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
return await llm.apredict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
return await llm.apredict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format"
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
prompt = _get_prompt(inputs)
llm_output: Union[str, BaseMessage] = await llm.apredict(
prompt, callbacks=callbacks, tags=tags
)
except InputFormatError:
messages = _get_messages(inputs)
llm_output = await llm.apredict_messages(
messages, callbacks=callbacks, tags=tags
)
return llm_output
async def _arun_chain(
chain: Chain,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str]:
"""Run a chain asynchronously on inputs."""
if input_mapper is not None:
inputs_ = input_mapper(inputs)
output: Union[dict, str] = await chain.acall(
inputs_, callbacks=callbacks, tags=tags
)
else:
inputs_ = next(iter(inputs.values())) if len(inputs) == 1 else inputs
output = await chain.acall(inputs_, callbacks=callbacks, tags=tags)
return output
async def _arun_llm_or_chain(
example: Example,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
n_repetitions: int,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
"""Asynchronously run the Chain or language model.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
n_repetitions: The number of times to run the model on each example.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map the input to the expected format.
Returns:
A list of outputs.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
outputs = []
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
for _ in range(n_repetitions):
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = await _arun_llm(
llm_or_chain_factory,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = await _arun_chain(
chain,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
outputs.append(output)
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id}. Error: {e}"
)
outputs.append({"Error": str(e)})
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return outputs
async def _gather_with_concurrency(
n: int,
initializer: Callable[[], Coroutine[Any, Any, Any]],
*async_funcs: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
],
) -> List[Any]:
"""Run coroutines with a concurrency limit.
Args:
n: The maximum number of concurrent tasks.
initializer: A coroutine that initializes shared resources for the tasks.
async_funcs: The async_funcs to be run concurrently.
Returns:
A list of results from the coroutines.
"""
semaphore = asyncio.Semaphore(n)
job_state = {"num_processed": 0}
callback_queue: asyncio.Queue[Sequence[BaseCallbackHandler]] = asyncio.Queue()
for _ in range(n):
callback_queue.put_nowait(await initializer())
async def run_coroutine_with_semaphore(
async_func: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
]
) -> Any:
async with semaphore:
callbacks = await callback_queue.get()
try:
result = await async_func(callbacks, job_state)
finally:
callback_queue.put_nowait(callbacks)
return result
results = await asyncio.gather(
*(run_coroutine_with_semaphore(function) for function in async_funcs)
)
while callback_queue:
try:
callbacks = callback_queue.get_nowait()
except asyncio.QueueEmpty:
break
for callback in callbacks:
if isinstance(callback, (LangChainTracer, EvaluatorCallbackHandler)):
callback.wait_for_futures()
return results
async def _callbacks_initializer(
project_name: Optional[str],
client: Client,
run_evaluators: Sequence[RunEvaluator],
evaluation_handler_collector: List[EvaluatorCallbackHandler],
) -> List[BaseTracer]:
"""
Initialize a tracer to share across tasks.
Args:
project_name: The project name for the tracer.
client: The client to use for the tracer.
run_evaluators: The evaluators to run.
evaluation_handler_collector: A list to collect the evaluators.
Used to wait for the evaluators to finish.
Returns:
The callbacks for this thread.
"""
callbacks: List[BaseTracer] = []
if project_name:
callbacks.append(
LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
)
evaluator_project_name = f"{project_name}-evaluators" if project_name else None
if run_evaluators:
callback = EvaluatorCallbackHandler(
client=client,
evaluators=run_evaluators,
# We already have concurrency, don't want to overload the machine
max_workers=1,
project_name=evaluator_project_name,
)
callbacks.append(callback)
evaluation_handler_collector.append(callback)
return callbacks
async def _arun_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Asynchronously run the chain on examples and store traces
to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Project name to use when tracing runs.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
llm_or_chain_factory = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, llm_or_chain_factory)
run_evaluators, examples = _setup_evaluation(
llm_or_chain_factory, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, llm_or_chain_factory, input_mapper)
results: Dict[str, List[Any]] = {}
async def process_example(
example: Example, callbacks: List[BaseCallbackHandler], job_state: dict
) -> None:
"""Process a single example."""
result = await _arun_llm_or_chain(
example,
llm_or_chain_factory,
num_repetitions,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
results[str(example.id)] = result
job_state["num_processed"] += 1
if verbose:
print(
f"Processed examples: {job_state['num_processed']}",
end="\r",
flush=True,
)
evaluation_handlers: List[EvaluatorCallbackHandler] = []
await _gather_with_concurrency(
concurrency_level,
functools.partial(
_callbacks_initializer,
project_name=project_name,
client=client,
evaluation_handler_collector=evaluation_handlers,
run_evaluators=run_evaluators or [],
),
*(functools.partial(process_example, e) for e in examples),
)
for handler in evaluation_handlers:
handler.wait_for_futures()
return results
## Sync Utilities
def _run_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""
Run the language model on the example.
Args:
llm: The language model to run.
inputs: The input dictionary.
callbacks: The callbacks to use during the run.
tags: Optional tags to add to the run.
input_mapper: function to map to the inputs dictionary from an Example
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
llm_output: Union[str, BaseMessage] = llm.predict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
llm_output = llm.predict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format: "
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
llm_prompts = _get_prompt(inputs)
llm_output = llm.predict(llm_prompts, callbacks=callbacks, tags=tags)
except InputFormatError:
llm_messages = _get_messages(inputs)
llm_output = llm.predict_messages(llm_messages, callbacks=callbacks)
return llm_output
def _run_chain(
chain: Chain,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[Dict, str]:
"""Run a chain on inputs."""
if input_mapper is not None:
inputs_ = input_mapper(inputs)
output: Union[dict, str] = chain(inputs_, callbacks=callbacks, tags=tags)
else:
inputs_ = next(iter(inputs.values())) if len(inputs) == 1 else inputs
output = chain(inputs_, callbacks=callbacks, tags=tags)
return output
def _run_llm_or_chain(
example: Example,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
n_repetitions: int,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
"""
Run the Chain or language model synchronously.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
n_repetitions: The number of times to run the model on each example.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
Returns:
Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
The outputs of the model or chain.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
outputs = []
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
for _ in range(n_repetitions):
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = _run_llm(
llm_or_chain_factory,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = _run_chain(
chain,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
outputs.append(output)
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id}. Error: {e}"
)
outputs.append({"Error": str(e)})
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return outputs
def _run_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Run the Chain or language model on examples and store
traces to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
results: Dict[str, Any] = {}
llm_or_chain_factory = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, llm_or_chain_factory)
tracer = LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
evaluator_project_name = f"{project_name}-evaluators"
run_evaluators, examples = _setup_evaluation(
llm_or_chain_factory, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, llm_or_chain_factory, input_mapper)
evalution_handler = EvaluatorCallbackHandler(
evaluators=run_evaluators or [],
client=client,
project_name=evaluator_project_name,
)
callbacks: List[BaseCallbackHandler] = [tracer, evalution_handler]
for i, example in enumerate(examples):
result = _run_llm_or_chain(
example,
llm_or_chain_factory,
num_repetitions,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
if verbose:
print(f"{i+1} processed", flush=True, end="\r")
results[str(example.id)] = result
tracer.wait_for_futures()
evalution_handler.wait_for_futures()
return results
## Public API
def _prepare_eval_run(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: Optional[str],
) -> Tuple[MODEL_OR_CHAIN_FACTORY, str, Dataset, Iterator[Example]]:
llm_or_chain_factory = _wrap_in_chain_factory(llm_or_chain_factory, dataset_name)
project_name = _get_project_name(project_name, llm_or_chain_factory)
try:
project = client.create_project(project_name)
except ValueError as e:
if "already exists " not in str(e):
raise e
raise ValueError(
f"Project {project_name} already exists. Please use a different name."
)
project_url = _get_eval_project_url(client.api_url, project.id)
print(
f"View the evaluation results for project '{project_name}' at:\n{project_url}"
)
dataset = client.read_dataset(dataset_name=dataset_name)
examples = client.list_examples(dataset_id=str(dataset.id))
return llm_or_chain_factory, project_name, dataset, examples
async def arun_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Dict[str, Any]:
"""
Asynchronously run the Chain or language model on a dataset
and store traces to the specified project name.
Args:
client: LangSmith client to use to read the dataset, and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the
resulting model outputs.
For the synchronous version, see :func:`run_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, arun_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
llm_or_chain_factory, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
results = await _arun_on_examples(
client,
examples,
llm_or_chain_factory,
concurrency_level=concurrency_level,
num_repetitions=num_repetitions,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
return {
"project_name": project_name,
"results": results,
}
def run_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
num_repetitions: int = 1,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Dict[str, Any]:
"""
Run the Chain or language model on a dataset and store traces
to the specified project name.
Args:
client: LangSmith client to use to access the dataset and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Configuration for evaluators to run on the
results of the chain
num_repetitions: Number of times to run the model on each example.
This is useful when testing success rates or generating confidence
intervals.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the resulting model outputs.
For the (usually faster) async version of this function, see :func:`arun_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, run_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
llm_or_chain_factory, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
results = _run_on_examples(
client,
examples,
llm_or_chain_factory,
num_repetitions=num_repetitions,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
return {
"project_name": project_name,
"results": results,
}
| [
"langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type",
"langchain.evaluation.loading.load_evaluator",
"langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler",
"langchain.chat_models.openai.ChatOpenAI",
"langchain.schema.messages.messages_from_dict",
"langchain.callbacks.tracers.langchain.LangChainTracer"
] | [((1370, 1397), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1387, 1397), False, 'import logging\n'), ((1708, 1725), 'urllib.parse.urlparse', 'urlparse', (['api_url'], {}), '(api_url)\n', (1716, 1725), False, 'from urllib.parse import urlparse, urlunparse\n'), ((24648, 24668), 'asyncio.Semaphore', 'asyncio.Semaphore', (['n'], {}), '(n)\n', (24665, 24668), False, 'import asyncio\n'), ((24774, 24789), 'asyncio.Queue', 'asyncio.Queue', ([], {}), '()\n', (24787, 24789), False, 'import asyncio\n'), ((37766, 37844), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (37781, 37844), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((38145, 38258), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'evaluators': '(run_evaluators or [])', 'client': 'client', 'project_name': 'evaluator_project_name'}), '(evaluators=run_evaluators or [], client=client,\n project_name=evaluator_project_name)\n', (38169, 38258), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((4660, 4696), 'itertools.chain', 'itertools.chain', (['[example]', 'examples'], {}), '([example], examples)\n', (4675, 4696), False, 'import itertools\n'), ((7539, 7574), 'langchain.schema.messages.messages_from_dict', 'messages_from_dict', (['raw_messages[0]'], {}), '(raw_messages[0])\n', (7557, 7574), False, 'from langchain.schema.messages import BaseMessage, messages_from_dict\n'), ((8394, 8406), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (8404, 8406), False, 'import uuid\n'), ((16022, 16063), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config'], {'llm': 'eval_llm'}), '(eval_config, llm=eval_llm)\n', (16036, 16063), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((16200, 16252), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config.evaluator_type'], {}), '(eval_config.evaluator_type, **kwargs)\n', (16214, 16252), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((16698, 16888), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['evaluator_', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key', 'tags': '[eval_type_tag]'}), '(evaluator_, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key, tags=[eval_type_tag])\n', (16744, 16888), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((17574, 17616), 'langchain.chat_models.openai.ChatOpenAI', 'ChatOpenAI', ([], {'model': '"""gpt-4"""', 'temperature': '(0.0)'}), "(model='gpt-4', temperature=0.0)\n", (17584, 17616), False, 'from langchain.chat_models.openai import ChatOpenAI\n'), ((26719, 26841), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'client': 'client', 'evaluators': 'run_evaluators', 'max_workers': '(1)', 'project_name': 'evaluator_project_name'}), '(client=client, evaluators=run_evaluators,\n max_workers=1, project_name=evaluator_project_name)\n', (26743, 26841), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((26474, 26552), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (26489, 26552), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((30344, 30523), 'functools.partial', 'functools.partial', (['_callbacks_initializer'], {'project_name': 'project_name', 'client': 'client', 'evaluation_handler_collector': 'evaluation_handlers', 'run_evaluators': '(run_evaluators or [])'}), '(_callbacks_initializer, project_name=project_name, client\n =client, evaluation_handler_collector=evaluation_handlers,\n run_evaluators=run_evaluators or [])\n', (30361, 30523), False, 'import functools\n'), ((18522, 18696), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['custom_evaluator', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key'}), '(custom_evaluator, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key)\n', (18568, 18696), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((30597, 30634), 'functools.partial', 'functools.partial', (['process_example', 'e'], {}), '(process_example, e)\n', (30614, 30634), False, 'import functools\n')] |
"""
.. warning::
Beta Feature!
**Cache** provides an optional caching layer for LLMs.
Cache is useful for two reasons:
- It can save you money by reducing the number of API calls you make to the LLM
provider if you're often requesting the same completion multiple times.
- It can speed up your application by reducing the number of API calls you make
to the LLM provider.
Cache directly competes with Memory. See documentation for Pros and Cons.
**Class hierarchy:**
.. code-block::
BaseCache --> <name>Cache # Examples: InMemoryCache, RedisCache, GPTCache
"""
from __future__ import annotations
import hashlib
import inspect
import json
import logging
import warnings
from abc import ABC, abstractmethod
from datetime import timedelta
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
Optional,
Sequence,
Tuple,
Type,
Union,
cast,
)
from sqlalchemy import Column, Integer, String, create_engine, select
from sqlalchemy.engine.base import Engine
from sqlalchemy.orm import Session
from langchain.utils import get_from_env
try:
from sqlalchemy.orm import declarative_base
except ImportError:
from sqlalchemy.ext.declarative import declarative_base
from langchain.embeddings.base import Embeddings
from langchain.load.dump import dumps
from langchain.load.load import loads
from langchain.schema import ChatGeneration, Generation
from langchain.vectorstores.redis import Redis as RedisVectorstore
logger = logging.getLogger(__file__)
if TYPE_CHECKING:
import momento
RETURN_VAL_TYPE = Sequence[Generation]
def _hash(_input: str) -> str:
"""Use a deterministic hashing approach."""
return hashlib.md5(_input.encode()).hexdigest()
def _dump_generations_to_json(generations: RETURN_VAL_TYPE) -> str:
"""Dump generations to json.
Args:
generations (RETURN_VAL_TYPE): A list of language model generations.
Returns:
str: Json representing a list of generations.
"""
return json.dumps([generation.dict() for generation in generations])
def _load_generations_from_json(generations_json: str) -> RETURN_VAL_TYPE:
"""Load generations from json.
Args:
generations_json (str): A string of json representing a list of generations.
Raises:
ValueError: Could not decode json string to list of generations.
Returns:
RETURN_VAL_TYPE: A list of generations.
"""
try:
results = json.loads(generations_json)
return [Generation(**generation_dict) for generation_dict in results]
except json.JSONDecodeError:
raise ValueError(
f"Could not decode json to list of generations: {generations_json}"
)
class BaseCache(ABC):
"""Base interface for cache."""
@abstractmethod
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
@abstractmethod
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
@abstractmethod
def clear(self, **kwargs: Any) -> None:
"""Clear cache that can take additional keyword arguments."""
class InMemoryCache(BaseCache):
"""Cache that stores things in memory."""
def __init__(self) -> None:
"""Initialize with empty cache."""
self._cache: Dict[Tuple[str, str], RETURN_VAL_TYPE] = {}
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
return self._cache.get((prompt, llm_string), None)
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
self._cache[(prompt, llm_string)] = return_val
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
self._cache = {}
Base = declarative_base()
class FullLLMCache(Base): # type: ignore
"""SQLite table for full LLM Cache (all generations)."""
__tablename__ = "full_llm_cache"
prompt = Column(String, primary_key=True)
llm = Column(String, primary_key=True)
idx = Column(Integer, primary_key=True)
response = Column(String)
class SQLAlchemyCache(BaseCache):
"""Cache that uses SQAlchemy as a backend."""
def __init__(self, engine: Engine, cache_schema: Type[FullLLMCache] = FullLLMCache):
"""Initialize by creating all tables."""
self.engine = engine
self.cache_schema = cache_schema
self.cache_schema.metadata.create_all(self.engine)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
stmt = (
select(self.cache_schema.response)
.where(self.cache_schema.prompt == prompt) # type: ignore
.where(self.cache_schema.llm == llm_string)
.order_by(self.cache_schema.idx)
)
with Session(self.engine) as session:
rows = session.execute(stmt).fetchall()
if rows:
try:
return [loads(row[0]) for row in rows]
except Exception:
logger.warning(
"Retrieving a cache value that could not be deserialized "
"properly. This is likely due to the cache being in an "
"older format. Please recreate your cache to avoid this "
"error."
)
# In a previous life we stored the raw text directly
# in the table, so assume it's in that format.
return [Generation(text=row[0]) for row in rows]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update based on prompt and llm_string."""
items = [
self.cache_schema(prompt=prompt, llm=llm_string, response=dumps(gen), idx=i)
for i, gen in enumerate(return_val)
]
with Session(self.engine) as session, session.begin():
for item in items:
session.merge(item)
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
with Session(self.engine) as session:
session.query(self.cache_schema).delete()
session.commit()
class SQLiteCache(SQLAlchemyCache):
"""Cache that uses SQLite as a backend."""
def __init__(self, database_path: str = ".langchain.db"):
"""Initialize by creating the engine and all tables."""
engine = create_engine(f"sqlite:///{database_path}")
super().__init__(engine)
class RedisCache(BaseCache):
"""Cache that uses Redis as a backend."""
# TODO - implement a TTL policy in Redis
def __init__(self, redis_: Any):
"""Initialize by passing in Redis instance."""
try:
from redis import Redis
except ImportError:
raise ValueError(
"Could not import redis python package. "
"Please install it with `pip install redis`."
)
if not isinstance(redis_, Redis):
raise ValueError("Please pass in Redis object.")
self.redis = redis_
def _key(self, prompt: str, llm_string: str) -> str:
"""Compute key from prompt and llm_string"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
generations = []
# Read from a Redis HASH
results = self.redis.hgetall(self._key(prompt, llm_string))
if results:
for _, text in results.items():
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisCache does not"
" support caching ChatModel outputs."
)
return
# Write to a Redis HASH
key = self._key(prompt, llm_string)
self.redis.hset(
key,
mapping={
str(idx): generation.text for idx, generation in enumerate(return_val)
},
)
def clear(self, **kwargs: Any) -> None:
"""Clear cache. If `asynchronous` is True, flush asynchronously."""
asynchronous = kwargs.get("asynchronous", False)
self.redis.flushdb(asynchronous=asynchronous, **kwargs)
class RedisSemanticCache(BaseCache):
"""Cache that uses Redis as a vector-store backend."""
# TODO - implement a TTL policy in Redis
def __init__(
self, redis_url: str, embedding: Embeddings, score_threshold: float = 0.2
):
"""Initialize by passing in the `init` GPTCache func
Args:
redis_url (str): URL to connect to Redis.
embedding (Embedding): Embedding provider for semantic encoding and search.
score_threshold (float, 0.2):
Example:
.. code-block:: python
import langchain
from langchain.cache import RedisSemanticCache
from langchain.embeddings import OpenAIEmbeddings
langchain.llm_cache = RedisSemanticCache(
redis_url="redis://localhost:6379",
embedding=OpenAIEmbeddings()
)
"""
self._cache_dict: Dict[str, RedisVectorstore] = {}
self.redis_url = redis_url
self.embedding = embedding
self.score_threshold = score_threshold
def _index_name(self, llm_string: str) -> str:
hashed_index = _hash(llm_string)
return f"cache:{hashed_index}"
def _get_llm_cache(self, llm_string: str) -> RedisVectorstore:
index_name = self._index_name(llm_string)
# return vectorstore client for the specific llm string
if index_name in self._cache_dict:
return self._cache_dict[index_name]
# create new vectorstore client for the specific llm string
try:
self._cache_dict[index_name] = RedisVectorstore.from_existing_index(
embedding=self.embedding,
index_name=index_name,
redis_url=self.redis_url,
)
except ValueError:
redis = RedisVectorstore(
embedding_function=self.embedding.embed_query,
index_name=index_name,
redis_url=self.redis_url,
)
_embedding = self.embedding.embed_query(text="test")
redis._create_index(dim=len(_embedding))
self._cache_dict[index_name] = redis
return self._cache_dict[index_name]
def clear(self, **kwargs: Any) -> None:
"""Clear semantic cache for a given llm_string."""
index_name = self._index_name(kwargs["llm_string"])
if index_name in self._cache_dict:
self._cache_dict[index_name].drop_index(
index_name=index_name, delete_documents=True, redis_url=self.redis_url
)
del self._cache_dict[index_name]
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
llm_cache = self._get_llm_cache(llm_string)
generations = []
# Read from a Hash
results = llm_cache.similarity_search_limit_score(
query=prompt,
k=1,
score_threshold=self.score_threshold,
)
if results:
for document in results:
for text in document.metadata["return_val"]:
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisSemanticCache only supports caching of "
f"normal LLM generations, got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisSentimentCache does not"
" support caching ChatModel outputs."
)
return
llm_cache = self._get_llm_cache(llm_string)
# Write to vectorstore
metadata = {
"llm_string": llm_string,
"prompt": prompt,
"return_val": [generation.text for generation in return_val],
}
llm_cache.add_texts(texts=[prompt], metadatas=[metadata])
class GPTCache(BaseCache):
"""Cache that uses GPTCache as a backend."""
def __init__(
self,
init_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = None,
):
"""Initialize by passing in init function (default: `None`).
Args:
init_func (Optional[Callable[[Any], None]]): init `GPTCache` function
(default: `None`)
Example:
.. code-block:: python
# Initialize GPTCache with a custom init function
import gptcache
from gptcache.processor.pre import get_prompt
from gptcache.manager.factory import get_data_manager
# Avoid multiple caches using the same file,
causing different llm model caches to affect each other
def init_gptcache(cache_obj: gptcache.Cache, llm str):
cache_obj.init(
pre_embedding_func=get_prompt,
data_manager=manager_factory(
manager="map",
data_dir=f"map_cache_{llm}"
),
)
langchain.llm_cache = GPTCache(init_gptcache)
"""
try:
import gptcache # noqa: F401
except ImportError:
raise ImportError(
"Could not import gptcache python package. "
"Please install it with `pip install gptcache`."
)
self.init_gptcache_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = init_func
self.gptcache_dict: Dict[str, Any] = {}
def _new_gptcache(self, llm_string: str) -> Any:
"""New gptcache object"""
from gptcache import Cache
from gptcache.manager.factory import get_data_manager
from gptcache.processor.pre import get_prompt
_gptcache = Cache()
if self.init_gptcache_func is not None:
sig = inspect.signature(self.init_gptcache_func)
if len(sig.parameters) == 2:
self.init_gptcache_func(_gptcache, llm_string) # type: ignore[call-arg]
else:
self.init_gptcache_func(_gptcache) # type: ignore[call-arg]
else:
_gptcache.init(
pre_embedding_func=get_prompt,
data_manager=get_data_manager(data_path=llm_string),
)
self.gptcache_dict[llm_string] = _gptcache
return _gptcache
def _get_gptcache(self, llm_string: str) -> Any:
"""Get a cache object.
When the corresponding llm model cache does not exist, it will be created."""
_gptcache = self.gptcache_dict.get(llm_string, None)
if not _gptcache:
_gptcache = self._new_gptcache(llm_string)
return _gptcache
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up the cache data.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then retrieve the data from the cache based on the `prompt`.
"""
from gptcache.adapter.api import get
_gptcache = self._get_gptcache(llm_string)
res = get(prompt, cache_obj=_gptcache)
if res:
return [
Generation(**generation_dict) for generation_dict in json.loads(res)
]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then store the `prompt` and `return_val` in the cache object.
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"GPTCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
from gptcache.adapter.api import put
_gptcache = self._get_gptcache(llm_string)
handled_data = json.dumps([generation.dict() for generation in return_val])
put(prompt, handled_data, cache_obj=_gptcache)
return None
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
from gptcache import Cache
for gptcache_instance in self.gptcache_dict.values():
gptcache_instance = cast(Cache, gptcache_instance)
gptcache_instance.flush()
self.gptcache_dict.clear()
def _ensure_cache_exists(cache_client: momento.CacheClient, cache_name: str) -> None:
"""Create cache if it doesn't exist.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
from momento.responses import CreateCache
create_cache_response = cache_client.create_cache(cache_name)
if isinstance(create_cache_response, CreateCache.Success) or isinstance(
create_cache_response, CreateCache.CacheAlreadyExists
):
return None
elif isinstance(create_cache_response, CreateCache.Error):
raise create_cache_response.inner_exception
else:
raise Exception(f"Unexpected response cache creation: {create_cache_response}")
def _validate_ttl(ttl: Optional[timedelta]) -> None:
if ttl is not None and ttl <= timedelta(seconds=0):
raise ValueError(f"ttl must be positive but was {ttl}.")
class MomentoCache(BaseCache):
"""Cache that uses Momento as a backend. See https://gomomento.com/"""
def __init__(
self,
cache_client: momento.CacheClient,
cache_name: str,
*,
ttl: Optional[timedelta] = None,
ensure_cache_exists: bool = True,
):
"""Instantiate a prompt cache using Momento as a backend.
Note: to instantiate the cache client passed to MomentoCache,
you must have a Momento account. See https://gomomento.com/.
Args:
cache_client (CacheClient): The Momento cache client.
cache_name (str): The name of the cache to use to store the data.
ttl (Optional[timedelta], optional): The time to live for the cache items.
Defaults to None, ie use the client default TTL.
ensure_cache_exists (bool, optional): Create the cache if it doesn't
exist. Defaults to True.
Raises:
ImportError: Momento python package is not installed.
TypeError: cache_client is not of type momento.CacheClientObject
ValueError: ttl is non-null and non-negative
"""
try:
from momento import CacheClient
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if not isinstance(cache_client, CacheClient):
raise TypeError("cache_client must be a momento.CacheClient object.")
_validate_ttl(ttl)
if ensure_cache_exists:
_ensure_cache_exists(cache_client, cache_name)
self.cache_client = cache_client
self.cache_name = cache_name
self.ttl = ttl
@classmethod
def from_client_params(
cls,
cache_name: str,
ttl: timedelta,
*,
configuration: Optional[momento.config.Configuration] = None,
auth_token: Optional[str] = None,
**kwargs: Any,
) -> MomentoCache:
"""Construct cache from CacheClient parameters."""
try:
from momento import CacheClient, Configurations, CredentialProvider
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if configuration is None:
configuration = Configurations.Laptop.v1()
auth_token = auth_token or get_from_env("auth_token", "MOMENTO_AUTH_TOKEN")
credentials = CredentialProvider.from_string(auth_token)
cache_client = CacheClient(configuration, credentials, default_ttl=ttl)
return cls(cache_client, cache_name, ttl=ttl, **kwargs)
def __key(self, prompt: str, llm_string: str) -> str:
"""Compute cache key from prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Returns:
str: The cache key.
"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Lookup llm generations in cache by prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Raises:
SdkException: Momento service or network error
Returns:
Optional[RETURN_VAL_TYPE]: A list of language model generations.
"""
from momento.responses import CacheGet
generations: RETURN_VAL_TYPE = []
get_response = self.cache_client.get(
self.cache_name, self.__key(prompt, llm_string)
)
if isinstance(get_response, CacheGet.Hit):
value = get_response.value_string
generations = _load_generations_from_json(value)
elif isinstance(get_response, CacheGet.Miss):
pass
elif isinstance(get_response, CacheGet.Error):
raise get_response.inner_exception
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Store llm generations in cache.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model string.
return_val (RETURN_VAL_TYPE): A list of language model generations.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"Momento only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
key = self.__key(prompt, llm_string)
value = _dump_generations_to_json(return_val)
set_response = self.cache_client.set(self.cache_name, key, value, self.ttl)
from momento.responses import CacheSet
if isinstance(set_response, CacheSet.Success):
pass
elif isinstance(set_response, CacheSet.Error):
raise set_response.inner_exception
else:
raise Exception(f"Unexpected response: {set_response}")
def clear(self, **kwargs: Any) -> None:
"""Clear the cache.
Raises:
SdkException: Momento service or network error
"""
from momento.responses import CacheFlush
flush_response = self.cache_client.flush_cache(self.cache_name)
if isinstance(flush_response, CacheFlush.Success):
pass
elif isinstance(flush_response, CacheFlush.Error):
raise flush_response.inner_exception
| [
"langchain.schema.Generation",
"langchain.utils.get_from_env",
"langchain.load.dump.dumps",
"langchain.vectorstores.redis.Redis",
"langchain.vectorstores.redis.Redis.from_existing_index",
"langchain.load.load.loads"
] | [((1483, 1510), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (1500, 1510), False, 'import logging\n'), ((3955, 3973), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (3971, 3973), False, 'from sqlalchemy.ext.declarative import declarative_base\n'), ((4130, 4162), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (4136, 4162), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4173, 4205), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (4179, 4205), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4216, 4249), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (4222, 4249), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4265, 4279), 'sqlalchemy.Column', 'Column', (['String'], {}), '(String)\n', (4271, 4279), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((2453, 2481), 'json.loads', 'json.loads', (['generations_json'], {}), '(generations_json)\n', (2463, 2481), False, 'import json\n'), ((6683, 6726), 'sqlalchemy.create_engine', 'create_engine', (['f"""sqlite:///{database_path}"""'], {}), "(f'sqlite:///{database_path}')\n", (6696, 6726), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((15254, 15261), 'gptcache.Cache', 'Cache', ([], {}), '()\n', (15259, 15261), False, 'from gptcache import Cache\n'), ((16587, 16619), 'gptcache.adapter.api.get', 'get', (['prompt'], {'cache_obj': '_gptcache'}), '(prompt, cache_obj=_gptcache)\n', (16590, 16619), False, 'from gptcache.adapter.api import get\n'), ((17506, 17552), 'gptcache.adapter.api.put', 'put', (['prompt', 'handled_data'], {'cache_obj': '_gptcache'}), '(prompt, handled_data, cache_obj=_gptcache)\n', (17509, 17552), False, 'from gptcache.adapter.api import put\n'), ((21401, 21443), 'momento.CredentialProvider.from_string', 'CredentialProvider.from_string', (['auth_token'], {}), '(auth_token)\n', (21431, 21443), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((21467, 21523), 'momento.CacheClient', 'CacheClient', (['configuration', 'credentials'], {'default_ttl': 'ttl'}), '(configuration, credentials, default_ttl=ttl)\n', (21478, 21523), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((2498, 2527), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (2508, 2527), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((5029, 5049), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (5036, 5049), False, 'from sqlalchemy.orm import Session\n'), ((6136, 6156), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6143, 6156), False, 'from sqlalchemy.orm import Session\n'), ((6338, 6358), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6345, 6358), False, 'from sqlalchemy.orm import Session\n'), ((10691, 10807), 'langchain.vectorstores.redis.Redis.from_existing_index', 'RedisVectorstore.from_existing_index', ([], {'embedding': 'self.embedding', 'index_name': 'index_name', 'redis_url': 'self.redis_url'}), '(embedding=self.embedding, index_name=\n index_name, redis_url=self.redis_url)\n', (10727, 10807), True, 'from langchain.vectorstores.redis import Redis as RedisVectorstore\n'), ((15328, 15370), 'inspect.signature', 'inspect.signature', (['self.init_gptcache_func'], {}), '(self.init_gptcache_func)\n', (15345, 15370), False, 'import inspect\n'), ((17775, 17805), 'typing.cast', 'cast', (['Cache', 'gptcache_instance'], {}), '(Cache, gptcache_instance)\n', (17779, 17805), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Sequence, Tuple, Type, Union, cast\n'), ((18705, 18725), 'datetime.timedelta', 'timedelta', ([], {'seconds': '(0)'}), '(seconds=0)\n', (18714, 18725), False, 'from datetime import timedelta\n'), ((21268, 21294), 'momento.Configurations.Laptop.v1', 'Configurations.Laptop.v1', ([], {}), '()\n', (21292, 21294), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((21330, 21378), 'langchain.utils.get_from_env', 'get_from_env', (['"""auth_token"""', '"""MOMENTO_AUTH_TOKEN"""'], {}), "('auth_token', 'MOMENTO_AUTH_TOKEN')\n", (21342, 21378), False, 'from langchain.utils import get_from_env\n'), ((8403, 8522), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs.'\n )\n", (8416, 8522), False, 'import warnings\n'), ((10913, 11030), 'langchain.vectorstores.redis.Redis', 'RedisVectorstore', ([], {'embedding_function': 'self.embedding.embed_query', 'index_name': 'index_name', 'redis_url': 'self.redis_url'}), '(embedding_function=self.embedding.embed_query, index_name=\n index_name, redis_url=self.redis_url)\n', (10929, 11030), True, 'from langchain.vectorstores.redis import Redis as RedisVectorstore\n'), ((12815, 12943), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs.'\n )\n", (12828, 12943), False, 'import warnings\n'), ((16673, 16702), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (16683, 16702), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((6046, 6056), 'langchain.load.dump.dumps', 'dumps', (['gen'], {}), '(gen)\n', (6051, 6056), False, 'from langchain.load.dump import dumps\n'), ((7862, 7883), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (7872, 7883), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((15714, 15752), 'gptcache.manager.factory.get_data_manager', 'get_data_manager', ([], {'data_path': 'llm_string'}), '(data_path=llm_string)\n', (15730, 15752), False, 'from gptcache.manager.factory import get_data_manager\n'), ((16726, 16741), 'json.loads', 'json.loads', (['res'], {}), '(res)\n', (16736, 16741), False, 'import json\n'), ((5184, 5197), 'langchain.load.load.loads', 'loads', (['row[0]'], {}), '(row[0])\n', (5189, 5197), False, 'from langchain.load.load import loads\n'), ((12266, 12287), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (12276, 12287), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((5754, 5777), 'langchain.schema.Generation', 'Generation', ([], {'text': 'row[0]'}), '(text=row[0])\n', (5764, 5777), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((4799, 4833), 'sqlalchemy.select', 'select', (['self.cache_schema.response'], {}), '(self.cache_schema.response)\n', (4805, 4833), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n')] |
"""
.. warning::
Beta Feature!
**Cache** provides an optional caching layer for LLMs.
Cache is useful for two reasons:
- It can save you money by reducing the number of API calls you make to the LLM
provider if you're often requesting the same completion multiple times.
- It can speed up your application by reducing the number of API calls you make
to the LLM provider.
Cache directly competes with Memory. See documentation for Pros and Cons.
**Class hierarchy:**
.. code-block::
BaseCache --> <name>Cache # Examples: InMemoryCache, RedisCache, GPTCache
"""
from __future__ import annotations
import hashlib
import inspect
import json
import logging
import warnings
from abc import ABC, abstractmethod
from datetime import timedelta
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
Optional,
Sequence,
Tuple,
Type,
Union,
cast,
)
from sqlalchemy import Column, Integer, String, create_engine, select
from sqlalchemy.engine.base import Engine
from sqlalchemy.orm import Session
from langchain.utils import get_from_env
try:
from sqlalchemy.orm import declarative_base
except ImportError:
from sqlalchemy.ext.declarative import declarative_base
from langchain.embeddings.base import Embeddings
from langchain.load.dump import dumps
from langchain.load.load import loads
from langchain.schema import ChatGeneration, Generation
from langchain.vectorstores.redis import Redis as RedisVectorstore
logger = logging.getLogger(__file__)
if TYPE_CHECKING:
import momento
RETURN_VAL_TYPE = Sequence[Generation]
def _hash(_input: str) -> str:
"""Use a deterministic hashing approach."""
return hashlib.md5(_input.encode()).hexdigest()
def _dump_generations_to_json(generations: RETURN_VAL_TYPE) -> str:
"""Dump generations to json.
Args:
generations (RETURN_VAL_TYPE): A list of language model generations.
Returns:
str: Json representing a list of generations.
"""
return json.dumps([generation.dict() for generation in generations])
def _load_generations_from_json(generations_json: str) -> RETURN_VAL_TYPE:
"""Load generations from json.
Args:
generations_json (str): A string of json representing a list of generations.
Raises:
ValueError: Could not decode json string to list of generations.
Returns:
RETURN_VAL_TYPE: A list of generations.
"""
try:
results = json.loads(generations_json)
return [Generation(**generation_dict) for generation_dict in results]
except json.JSONDecodeError:
raise ValueError(
f"Could not decode json to list of generations: {generations_json}"
)
class BaseCache(ABC):
"""Base interface for cache."""
@abstractmethod
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
@abstractmethod
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
@abstractmethod
def clear(self, **kwargs: Any) -> None:
"""Clear cache that can take additional keyword arguments."""
class InMemoryCache(BaseCache):
"""Cache that stores things in memory."""
def __init__(self) -> None:
"""Initialize with empty cache."""
self._cache: Dict[Tuple[str, str], RETURN_VAL_TYPE] = {}
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
return self._cache.get((prompt, llm_string), None)
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
self._cache[(prompt, llm_string)] = return_val
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
self._cache = {}
Base = declarative_base()
class FullLLMCache(Base): # type: ignore
"""SQLite table for full LLM Cache (all generations)."""
__tablename__ = "full_llm_cache"
prompt = Column(String, primary_key=True)
llm = Column(String, primary_key=True)
idx = Column(Integer, primary_key=True)
response = Column(String)
class SQLAlchemyCache(BaseCache):
"""Cache that uses SQAlchemy as a backend."""
def __init__(self, engine: Engine, cache_schema: Type[FullLLMCache] = FullLLMCache):
"""Initialize by creating all tables."""
self.engine = engine
self.cache_schema = cache_schema
self.cache_schema.metadata.create_all(self.engine)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
stmt = (
select(self.cache_schema.response)
.where(self.cache_schema.prompt == prompt) # type: ignore
.where(self.cache_schema.llm == llm_string)
.order_by(self.cache_schema.idx)
)
with Session(self.engine) as session:
rows = session.execute(stmt).fetchall()
if rows:
try:
return [loads(row[0]) for row in rows]
except Exception:
logger.warning(
"Retrieving a cache value that could not be deserialized "
"properly. This is likely due to the cache being in an "
"older format. Please recreate your cache to avoid this "
"error."
)
# In a previous life we stored the raw text directly
# in the table, so assume it's in that format.
return [Generation(text=row[0]) for row in rows]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update based on prompt and llm_string."""
items = [
self.cache_schema(prompt=prompt, llm=llm_string, response=dumps(gen), idx=i)
for i, gen in enumerate(return_val)
]
with Session(self.engine) as session, session.begin():
for item in items:
session.merge(item)
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
with Session(self.engine) as session:
session.query(self.cache_schema).delete()
session.commit()
class SQLiteCache(SQLAlchemyCache):
"""Cache that uses SQLite as a backend."""
def __init__(self, database_path: str = ".langchain.db"):
"""Initialize by creating the engine and all tables."""
engine = create_engine(f"sqlite:///{database_path}")
super().__init__(engine)
class RedisCache(BaseCache):
"""Cache that uses Redis as a backend."""
# TODO - implement a TTL policy in Redis
def __init__(self, redis_: Any):
"""Initialize by passing in Redis instance."""
try:
from redis import Redis
except ImportError:
raise ValueError(
"Could not import redis python package. "
"Please install it with `pip install redis`."
)
if not isinstance(redis_, Redis):
raise ValueError("Please pass in Redis object.")
self.redis = redis_
def _key(self, prompt: str, llm_string: str) -> str:
"""Compute key from prompt and llm_string"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
generations = []
# Read from a Redis HASH
results = self.redis.hgetall(self._key(prompt, llm_string))
if results:
for _, text in results.items():
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisCache does not"
" support caching ChatModel outputs."
)
return
# Write to a Redis HASH
key = self._key(prompt, llm_string)
self.redis.hset(
key,
mapping={
str(idx): generation.text for idx, generation in enumerate(return_val)
},
)
def clear(self, **kwargs: Any) -> None:
"""Clear cache. If `asynchronous` is True, flush asynchronously."""
asynchronous = kwargs.get("asynchronous", False)
self.redis.flushdb(asynchronous=asynchronous, **kwargs)
class RedisSemanticCache(BaseCache):
"""Cache that uses Redis as a vector-store backend."""
# TODO - implement a TTL policy in Redis
def __init__(
self, redis_url: str, embedding: Embeddings, score_threshold: float = 0.2
):
"""Initialize by passing in the `init` GPTCache func
Args:
redis_url (str): URL to connect to Redis.
embedding (Embedding): Embedding provider for semantic encoding and search.
score_threshold (float, 0.2):
Example:
.. code-block:: python
import langchain
from langchain.cache import RedisSemanticCache
from langchain.embeddings import OpenAIEmbeddings
langchain.llm_cache = RedisSemanticCache(
redis_url="redis://localhost:6379",
embedding=OpenAIEmbeddings()
)
"""
self._cache_dict: Dict[str, RedisVectorstore] = {}
self.redis_url = redis_url
self.embedding = embedding
self.score_threshold = score_threshold
def _index_name(self, llm_string: str) -> str:
hashed_index = _hash(llm_string)
return f"cache:{hashed_index}"
def _get_llm_cache(self, llm_string: str) -> RedisVectorstore:
index_name = self._index_name(llm_string)
# return vectorstore client for the specific llm string
if index_name in self._cache_dict:
return self._cache_dict[index_name]
# create new vectorstore client for the specific llm string
try:
self._cache_dict[index_name] = RedisVectorstore.from_existing_index(
embedding=self.embedding,
index_name=index_name,
redis_url=self.redis_url,
)
except ValueError:
redis = RedisVectorstore(
embedding_function=self.embedding.embed_query,
index_name=index_name,
redis_url=self.redis_url,
)
_embedding = self.embedding.embed_query(text="test")
redis._create_index(dim=len(_embedding))
self._cache_dict[index_name] = redis
return self._cache_dict[index_name]
def clear(self, **kwargs: Any) -> None:
"""Clear semantic cache for a given llm_string."""
index_name = self._index_name(kwargs["llm_string"])
if index_name in self._cache_dict:
self._cache_dict[index_name].drop_index(
index_name=index_name, delete_documents=True, redis_url=self.redis_url
)
del self._cache_dict[index_name]
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
llm_cache = self._get_llm_cache(llm_string)
generations = []
# Read from a Hash
results = llm_cache.similarity_search_limit_score(
query=prompt,
k=1,
score_threshold=self.score_threshold,
)
if results:
for document in results:
for text in document.metadata["return_val"]:
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisSemanticCache only supports caching of "
f"normal LLM generations, got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisSentimentCache does not"
" support caching ChatModel outputs."
)
return
llm_cache = self._get_llm_cache(llm_string)
# Write to vectorstore
metadata = {
"llm_string": llm_string,
"prompt": prompt,
"return_val": [generation.text for generation in return_val],
}
llm_cache.add_texts(texts=[prompt], metadatas=[metadata])
class GPTCache(BaseCache):
"""Cache that uses GPTCache as a backend."""
def __init__(
self,
init_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = None,
):
"""Initialize by passing in init function (default: `None`).
Args:
init_func (Optional[Callable[[Any], None]]): init `GPTCache` function
(default: `None`)
Example:
.. code-block:: python
# Initialize GPTCache with a custom init function
import gptcache
from gptcache.processor.pre import get_prompt
from gptcache.manager.factory import get_data_manager
# Avoid multiple caches using the same file,
causing different llm model caches to affect each other
def init_gptcache(cache_obj: gptcache.Cache, llm str):
cache_obj.init(
pre_embedding_func=get_prompt,
data_manager=manager_factory(
manager="map",
data_dir=f"map_cache_{llm}"
),
)
langchain.llm_cache = GPTCache(init_gptcache)
"""
try:
import gptcache # noqa: F401
except ImportError:
raise ImportError(
"Could not import gptcache python package. "
"Please install it with `pip install gptcache`."
)
self.init_gptcache_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = init_func
self.gptcache_dict: Dict[str, Any] = {}
def _new_gptcache(self, llm_string: str) -> Any:
"""New gptcache object"""
from gptcache import Cache
from gptcache.manager.factory import get_data_manager
from gptcache.processor.pre import get_prompt
_gptcache = Cache()
if self.init_gptcache_func is not None:
sig = inspect.signature(self.init_gptcache_func)
if len(sig.parameters) == 2:
self.init_gptcache_func(_gptcache, llm_string) # type: ignore[call-arg]
else:
self.init_gptcache_func(_gptcache) # type: ignore[call-arg]
else:
_gptcache.init(
pre_embedding_func=get_prompt,
data_manager=get_data_manager(data_path=llm_string),
)
self.gptcache_dict[llm_string] = _gptcache
return _gptcache
def _get_gptcache(self, llm_string: str) -> Any:
"""Get a cache object.
When the corresponding llm model cache does not exist, it will be created."""
_gptcache = self.gptcache_dict.get(llm_string, None)
if not _gptcache:
_gptcache = self._new_gptcache(llm_string)
return _gptcache
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up the cache data.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then retrieve the data from the cache based on the `prompt`.
"""
from gptcache.adapter.api import get
_gptcache = self._get_gptcache(llm_string)
res = get(prompt, cache_obj=_gptcache)
if res:
return [
Generation(**generation_dict) for generation_dict in json.loads(res)
]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then store the `prompt` and `return_val` in the cache object.
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"GPTCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
from gptcache.adapter.api import put
_gptcache = self._get_gptcache(llm_string)
handled_data = json.dumps([generation.dict() for generation in return_val])
put(prompt, handled_data, cache_obj=_gptcache)
return None
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
from gptcache import Cache
for gptcache_instance in self.gptcache_dict.values():
gptcache_instance = cast(Cache, gptcache_instance)
gptcache_instance.flush()
self.gptcache_dict.clear()
def _ensure_cache_exists(cache_client: momento.CacheClient, cache_name: str) -> None:
"""Create cache if it doesn't exist.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
from momento.responses import CreateCache
create_cache_response = cache_client.create_cache(cache_name)
if isinstance(create_cache_response, CreateCache.Success) or isinstance(
create_cache_response, CreateCache.CacheAlreadyExists
):
return None
elif isinstance(create_cache_response, CreateCache.Error):
raise create_cache_response.inner_exception
else:
raise Exception(f"Unexpected response cache creation: {create_cache_response}")
def _validate_ttl(ttl: Optional[timedelta]) -> None:
if ttl is not None and ttl <= timedelta(seconds=0):
raise ValueError(f"ttl must be positive but was {ttl}.")
class MomentoCache(BaseCache):
"""Cache that uses Momento as a backend. See https://gomomento.com/"""
def __init__(
self,
cache_client: momento.CacheClient,
cache_name: str,
*,
ttl: Optional[timedelta] = None,
ensure_cache_exists: bool = True,
):
"""Instantiate a prompt cache using Momento as a backend.
Note: to instantiate the cache client passed to MomentoCache,
you must have a Momento account. See https://gomomento.com/.
Args:
cache_client (CacheClient): The Momento cache client.
cache_name (str): The name of the cache to use to store the data.
ttl (Optional[timedelta], optional): The time to live for the cache items.
Defaults to None, ie use the client default TTL.
ensure_cache_exists (bool, optional): Create the cache if it doesn't
exist. Defaults to True.
Raises:
ImportError: Momento python package is not installed.
TypeError: cache_client is not of type momento.CacheClientObject
ValueError: ttl is non-null and non-negative
"""
try:
from momento import CacheClient
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if not isinstance(cache_client, CacheClient):
raise TypeError("cache_client must be a momento.CacheClient object.")
_validate_ttl(ttl)
if ensure_cache_exists:
_ensure_cache_exists(cache_client, cache_name)
self.cache_client = cache_client
self.cache_name = cache_name
self.ttl = ttl
@classmethod
def from_client_params(
cls,
cache_name: str,
ttl: timedelta,
*,
configuration: Optional[momento.config.Configuration] = None,
auth_token: Optional[str] = None,
**kwargs: Any,
) -> MomentoCache:
"""Construct cache from CacheClient parameters."""
try:
from momento import CacheClient, Configurations, CredentialProvider
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if configuration is None:
configuration = Configurations.Laptop.v1()
auth_token = auth_token or get_from_env("auth_token", "MOMENTO_AUTH_TOKEN")
credentials = CredentialProvider.from_string(auth_token)
cache_client = CacheClient(configuration, credentials, default_ttl=ttl)
return cls(cache_client, cache_name, ttl=ttl, **kwargs)
def __key(self, prompt: str, llm_string: str) -> str:
"""Compute cache key from prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Returns:
str: The cache key.
"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Lookup llm generations in cache by prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Raises:
SdkException: Momento service or network error
Returns:
Optional[RETURN_VAL_TYPE]: A list of language model generations.
"""
from momento.responses import CacheGet
generations: RETURN_VAL_TYPE = []
get_response = self.cache_client.get(
self.cache_name, self.__key(prompt, llm_string)
)
if isinstance(get_response, CacheGet.Hit):
value = get_response.value_string
generations = _load_generations_from_json(value)
elif isinstance(get_response, CacheGet.Miss):
pass
elif isinstance(get_response, CacheGet.Error):
raise get_response.inner_exception
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Store llm generations in cache.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model string.
return_val (RETURN_VAL_TYPE): A list of language model generations.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"Momento only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
key = self.__key(prompt, llm_string)
value = _dump_generations_to_json(return_val)
set_response = self.cache_client.set(self.cache_name, key, value, self.ttl)
from momento.responses import CacheSet
if isinstance(set_response, CacheSet.Success):
pass
elif isinstance(set_response, CacheSet.Error):
raise set_response.inner_exception
else:
raise Exception(f"Unexpected response: {set_response}")
def clear(self, **kwargs: Any) -> None:
"""Clear the cache.
Raises:
SdkException: Momento service or network error
"""
from momento.responses import CacheFlush
flush_response = self.cache_client.flush_cache(self.cache_name)
if isinstance(flush_response, CacheFlush.Success):
pass
elif isinstance(flush_response, CacheFlush.Error):
raise flush_response.inner_exception
| [
"langchain.schema.Generation",
"langchain.utils.get_from_env",
"langchain.load.dump.dumps",
"langchain.vectorstores.redis.Redis",
"langchain.vectorstores.redis.Redis.from_existing_index",
"langchain.load.load.loads"
] | [((1483, 1510), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (1500, 1510), False, 'import logging\n'), ((3955, 3973), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (3971, 3973), False, 'from sqlalchemy.ext.declarative import declarative_base\n'), ((4130, 4162), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (4136, 4162), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4173, 4205), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (4179, 4205), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4216, 4249), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (4222, 4249), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4265, 4279), 'sqlalchemy.Column', 'Column', (['String'], {}), '(String)\n', (4271, 4279), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((2453, 2481), 'json.loads', 'json.loads', (['generations_json'], {}), '(generations_json)\n', (2463, 2481), False, 'import json\n'), ((6683, 6726), 'sqlalchemy.create_engine', 'create_engine', (['f"""sqlite:///{database_path}"""'], {}), "(f'sqlite:///{database_path}')\n", (6696, 6726), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((15254, 15261), 'gptcache.Cache', 'Cache', ([], {}), '()\n', (15259, 15261), False, 'from gptcache import Cache\n'), ((16587, 16619), 'gptcache.adapter.api.get', 'get', (['prompt'], {'cache_obj': '_gptcache'}), '(prompt, cache_obj=_gptcache)\n', (16590, 16619), False, 'from gptcache.adapter.api import get\n'), ((17506, 17552), 'gptcache.adapter.api.put', 'put', (['prompt', 'handled_data'], {'cache_obj': '_gptcache'}), '(prompt, handled_data, cache_obj=_gptcache)\n', (17509, 17552), False, 'from gptcache.adapter.api import put\n'), ((21401, 21443), 'momento.CredentialProvider.from_string', 'CredentialProvider.from_string', (['auth_token'], {}), '(auth_token)\n', (21431, 21443), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((21467, 21523), 'momento.CacheClient', 'CacheClient', (['configuration', 'credentials'], {'default_ttl': 'ttl'}), '(configuration, credentials, default_ttl=ttl)\n', (21478, 21523), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((2498, 2527), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (2508, 2527), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((5029, 5049), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (5036, 5049), False, 'from sqlalchemy.orm import Session\n'), ((6136, 6156), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6143, 6156), False, 'from sqlalchemy.orm import Session\n'), ((6338, 6358), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6345, 6358), False, 'from sqlalchemy.orm import Session\n'), ((10691, 10807), 'langchain.vectorstores.redis.Redis.from_existing_index', 'RedisVectorstore.from_existing_index', ([], {'embedding': 'self.embedding', 'index_name': 'index_name', 'redis_url': 'self.redis_url'}), '(embedding=self.embedding, index_name=\n index_name, redis_url=self.redis_url)\n', (10727, 10807), True, 'from langchain.vectorstores.redis import Redis as RedisVectorstore\n'), ((15328, 15370), 'inspect.signature', 'inspect.signature', (['self.init_gptcache_func'], {}), '(self.init_gptcache_func)\n', (15345, 15370), False, 'import inspect\n'), ((17775, 17805), 'typing.cast', 'cast', (['Cache', 'gptcache_instance'], {}), '(Cache, gptcache_instance)\n', (17779, 17805), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Sequence, Tuple, Type, Union, cast\n'), ((18705, 18725), 'datetime.timedelta', 'timedelta', ([], {'seconds': '(0)'}), '(seconds=0)\n', (18714, 18725), False, 'from datetime import timedelta\n'), ((21268, 21294), 'momento.Configurations.Laptop.v1', 'Configurations.Laptop.v1', ([], {}), '()\n', (21292, 21294), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((21330, 21378), 'langchain.utils.get_from_env', 'get_from_env', (['"""auth_token"""', '"""MOMENTO_AUTH_TOKEN"""'], {}), "('auth_token', 'MOMENTO_AUTH_TOKEN')\n", (21342, 21378), False, 'from langchain.utils import get_from_env\n'), ((8403, 8522), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs.'\n )\n", (8416, 8522), False, 'import warnings\n'), ((10913, 11030), 'langchain.vectorstores.redis.Redis', 'RedisVectorstore', ([], {'embedding_function': 'self.embedding.embed_query', 'index_name': 'index_name', 'redis_url': 'self.redis_url'}), '(embedding_function=self.embedding.embed_query, index_name=\n index_name, redis_url=self.redis_url)\n', (10929, 11030), True, 'from langchain.vectorstores.redis import Redis as RedisVectorstore\n'), ((12815, 12943), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs.'\n )\n", (12828, 12943), False, 'import warnings\n'), ((16673, 16702), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (16683, 16702), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((6046, 6056), 'langchain.load.dump.dumps', 'dumps', (['gen'], {}), '(gen)\n', (6051, 6056), False, 'from langchain.load.dump import dumps\n'), ((7862, 7883), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (7872, 7883), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((15714, 15752), 'gptcache.manager.factory.get_data_manager', 'get_data_manager', ([], {'data_path': 'llm_string'}), '(data_path=llm_string)\n', (15730, 15752), False, 'from gptcache.manager.factory import get_data_manager\n'), ((16726, 16741), 'json.loads', 'json.loads', (['res'], {}), '(res)\n', (16736, 16741), False, 'import json\n'), ((5184, 5197), 'langchain.load.load.loads', 'loads', (['row[0]'], {}), '(row[0])\n', (5189, 5197), False, 'from langchain.load.load import loads\n'), ((12266, 12287), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (12276, 12287), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((5754, 5777), 'langchain.schema.Generation', 'Generation', ([], {'text': 'row[0]'}), '(text=row[0])\n', (5764, 5777), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((4799, 4833), 'sqlalchemy.select', 'select', (['self.cache_schema.response'], {}), '(self.cache_schema.response)\n', (4805, 4833), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n')] |
"""
.. warning::
Beta Feature!
**Cache** provides an optional caching layer for LLMs.
Cache is useful for two reasons:
- It can save you money by reducing the number of API calls you make to the LLM
provider if you're often requesting the same completion multiple times.
- It can speed up your application by reducing the number of API calls you make
to the LLM provider.
Cache directly competes with Memory. See documentation for Pros and Cons.
**Class hierarchy:**
.. code-block::
BaseCache --> <name>Cache # Examples: InMemoryCache, RedisCache, GPTCache
"""
from __future__ import annotations
import hashlib
import inspect
import json
import logging
import warnings
from abc import ABC, abstractmethod
from datetime import timedelta
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
Optional,
Sequence,
Tuple,
Type,
Union,
cast,
)
from sqlalchemy import Column, Integer, String, create_engine, select
from sqlalchemy.engine.base import Engine
from sqlalchemy.orm import Session
from langchain.utils import get_from_env
try:
from sqlalchemy.orm import declarative_base
except ImportError:
from sqlalchemy.ext.declarative import declarative_base
from langchain.embeddings.base import Embeddings
from langchain.load.dump import dumps
from langchain.load.load import loads
from langchain.schema import ChatGeneration, Generation
from langchain.vectorstores.redis import Redis as RedisVectorstore
logger = logging.getLogger(__file__)
if TYPE_CHECKING:
import momento
RETURN_VAL_TYPE = Sequence[Generation]
def _hash(_input: str) -> str:
"""Use a deterministic hashing approach."""
return hashlib.md5(_input.encode()).hexdigest()
def _dump_generations_to_json(generations: RETURN_VAL_TYPE) -> str:
"""Dump generations to json.
Args:
generations (RETURN_VAL_TYPE): A list of language model generations.
Returns:
str: Json representing a list of generations.
"""
return json.dumps([generation.dict() for generation in generations])
def _load_generations_from_json(generations_json: str) -> RETURN_VAL_TYPE:
"""Load generations from json.
Args:
generations_json (str): A string of json representing a list of generations.
Raises:
ValueError: Could not decode json string to list of generations.
Returns:
RETURN_VAL_TYPE: A list of generations.
"""
try:
results = json.loads(generations_json)
return [Generation(**generation_dict) for generation_dict in results]
except json.JSONDecodeError:
raise ValueError(
f"Could not decode json to list of generations: {generations_json}"
)
class BaseCache(ABC):
"""Base interface for cache."""
@abstractmethod
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
@abstractmethod
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
@abstractmethod
def clear(self, **kwargs: Any) -> None:
"""Clear cache that can take additional keyword arguments."""
class InMemoryCache(BaseCache):
"""Cache that stores things in memory."""
def __init__(self) -> None:
"""Initialize with empty cache."""
self._cache: Dict[Tuple[str, str], RETURN_VAL_TYPE] = {}
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
return self._cache.get((prompt, llm_string), None)
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
self._cache[(prompt, llm_string)] = return_val
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
self._cache = {}
Base = declarative_base()
class FullLLMCache(Base): # type: ignore
"""SQLite table for full LLM Cache (all generations)."""
__tablename__ = "full_llm_cache"
prompt = Column(String, primary_key=True)
llm = Column(String, primary_key=True)
idx = Column(Integer, primary_key=True)
response = Column(String)
class SQLAlchemyCache(BaseCache):
"""Cache that uses SQAlchemy as a backend."""
def __init__(self, engine: Engine, cache_schema: Type[FullLLMCache] = FullLLMCache):
"""Initialize by creating all tables."""
self.engine = engine
self.cache_schema = cache_schema
self.cache_schema.metadata.create_all(self.engine)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
stmt = (
select(self.cache_schema.response)
.where(self.cache_schema.prompt == prompt) # type: ignore
.where(self.cache_schema.llm == llm_string)
.order_by(self.cache_schema.idx)
)
with Session(self.engine) as session:
rows = session.execute(stmt).fetchall()
if rows:
try:
return [loads(row[0]) for row in rows]
except Exception:
logger.warning(
"Retrieving a cache value that could not be deserialized "
"properly. This is likely due to the cache being in an "
"older format. Please recreate your cache to avoid this "
"error."
)
# In a previous life we stored the raw text directly
# in the table, so assume it's in that format.
return [Generation(text=row[0]) for row in rows]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update based on prompt and llm_string."""
items = [
self.cache_schema(prompt=prompt, llm=llm_string, response=dumps(gen), idx=i)
for i, gen in enumerate(return_val)
]
with Session(self.engine) as session, session.begin():
for item in items:
session.merge(item)
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
with Session(self.engine) as session:
session.query(self.cache_schema).delete()
session.commit()
class SQLiteCache(SQLAlchemyCache):
"""Cache that uses SQLite as a backend."""
def __init__(self, database_path: str = ".langchain.db"):
"""Initialize by creating the engine and all tables."""
engine = create_engine(f"sqlite:///{database_path}")
super().__init__(engine)
class RedisCache(BaseCache):
"""Cache that uses Redis as a backend."""
# TODO - implement a TTL policy in Redis
def __init__(self, redis_: Any):
"""Initialize by passing in Redis instance."""
try:
from redis import Redis
except ImportError:
raise ValueError(
"Could not import redis python package. "
"Please install it with `pip install redis`."
)
if not isinstance(redis_, Redis):
raise ValueError("Please pass in Redis object.")
self.redis = redis_
def _key(self, prompt: str, llm_string: str) -> str:
"""Compute key from prompt and llm_string"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
generations = []
# Read from a Redis HASH
results = self.redis.hgetall(self._key(prompt, llm_string))
if results:
for _, text in results.items():
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisCache does not"
" support caching ChatModel outputs."
)
return
# Write to a Redis HASH
key = self._key(prompt, llm_string)
self.redis.hset(
key,
mapping={
str(idx): generation.text for idx, generation in enumerate(return_val)
},
)
def clear(self, **kwargs: Any) -> None:
"""Clear cache. If `asynchronous` is True, flush asynchronously."""
asynchronous = kwargs.get("asynchronous", False)
self.redis.flushdb(asynchronous=asynchronous, **kwargs)
class RedisSemanticCache(BaseCache):
"""Cache that uses Redis as a vector-store backend."""
# TODO - implement a TTL policy in Redis
def __init__(
self, redis_url: str, embedding: Embeddings, score_threshold: float = 0.2
):
"""Initialize by passing in the `init` GPTCache func
Args:
redis_url (str): URL to connect to Redis.
embedding (Embedding): Embedding provider for semantic encoding and search.
score_threshold (float, 0.2):
Example:
.. code-block:: python
import langchain
from langchain.cache import RedisSemanticCache
from langchain.embeddings import OpenAIEmbeddings
langchain.llm_cache = RedisSemanticCache(
redis_url="redis://localhost:6379",
embedding=OpenAIEmbeddings()
)
"""
self._cache_dict: Dict[str, RedisVectorstore] = {}
self.redis_url = redis_url
self.embedding = embedding
self.score_threshold = score_threshold
def _index_name(self, llm_string: str) -> str:
hashed_index = _hash(llm_string)
return f"cache:{hashed_index}"
def _get_llm_cache(self, llm_string: str) -> RedisVectorstore:
index_name = self._index_name(llm_string)
# return vectorstore client for the specific llm string
if index_name in self._cache_dict:
return self._cache_dict[index_name]
# create new vectorstore client for the specific llm string
try:
self._cache_dict[index_name] = RedisVectorstore.from_existing_index(
embedding=self.embedding,
index_name=index_name,
redis_url=self.redis_url,
)
except ValueError:
redis = RedisVectorstore(
embedding_function=self.embedding.embed_query,
index_name=index_name,
redis_url=self.redis_url,
)
_embedding = self.embedding.embed_query(text="test")
redis._create_index(dim=len(_embedding))
self._cache_dict[index_name] = redis
return self._cache_dict[index_name]
def clear(self, **kwargs: Any) -> None:
"""Clear semantic cache for a given llm_string."""
index_name = self._index_name(kwargs["llm_string"])
if index_name in self._cache_dict:
self._cache_dict[index_name].drop_index(
index_name=index_name, delete_documents=True, redis_url=self.redis_url
)
del self._cache_dict[index_name]
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up based on prompt and llm_string."""
llm_cache = self._get_llm_cache(llm_string)
generations = []
# Read from a Hash
results = llm_cache.similarity_search_limit_score(
query=prompt,
k=1,
score_threshold=self.score_threshold,
)
if results:
for document in results:
for text in document.metadata["return_val"]:
generations.append(Generation(text=text))
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache based on prompt and llm_string."""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"RedisSemanticCache only supports caching of "
f"normal LLM generations, got {type(gen)}"
)
if isinstance(gen, ChatGeneration):
warnings.warn(
"NOTE: Generation has not been cached. RedisSentimentCache does not"
" support caching ChatModel outputs."
)
return
llm_cache = self._get_llm_cache(llm_string)
# Write to vectorstore
metadata = {
"llm_string": llm_string,
"prompt": prompt,
"return_val": [generation.text for generation in return_val],
}
llm_cache.add_texts(texts=[prompt], metadatas=[metadata])
class GPTCache(BaseCache):
"""Cache that uses GPTCache as a backend."""
def __init__(
self,
init_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = None,
):
"""Initialize by passing in init function (default: `None`).
Args:
init_func (Optional[Callable[[Any], None]]): init `GPTCache` function
(default: `None`)
Example:
.. code-block:: python
# Initialize GPTCache with a custom init function
import gptcache
from gptcache.processor.pre import get_prompt
from gptcache.manager.factory import get_data_manager
# Avoid multiple caches using the same file,
causing different llm model caches to affect each other
def init_gptcache(cache_obj: gptcache.Cache, llm str):
cache_obj.init(
pre_embedding_func=get_prompt,
data_manager=manager_factory(
manager="map",
data_dir=f"map_cache_{llm}"
),
)
langchain.llm_cache = GPTCache(init_gptcache)
"""
try:
import gptcache # noqa: F401
except ImportError:
raise ImportError(
"Could not import gptcache python package. "
"Please install it with `pip install gptcache`."
)
self.init_gptcache_func: Union[
Callable[[Any, str], None], Callable[[Any], None], None
] = init_func
self.gptcache_dict: Dict[str, Any] = {}
def _new_gptcache(self, llm_string: str) -> Any:
"""New gptcache object"""
from gptcache import Cache
from gptcache.manager.factory import get_data_manager
from gptcache.processor.pre import get_prompt
_gptcache = Cache()
if self.init_gptcache_func is not None:
sig = inspect.signature(self.init_gptcache_func)
if len(sig.parameters) == 2:
self.init_gptcache_func(_gptcache, llm_string) # type: ignore[call-arg]
else:
self.init_gptcache_func(_gptcache) # type: ignore[call-arg]
else:
_gptcache.init(
pre_embedding_func=get_prompt,
data_manager=get_data_manager(data_path=llm_string),
)
self.gptcache_dict[llm_string] = _gptcache
return _gptcache
def _get_gptcache(self, llm_string: str) -> Any:
"""Get a cache object.
When the corresponding llm model cache does not exist, it will be created."""
_gptcache = self.gptcache_dict.get(llm_string, None)
if not _gptcache:
_gptcache = self._new_gptcache(llm_string)
return _gptcache
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Look up the cache data.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then retrieve the data from the cache based on the `prompt`.
"""
from gptcache.adapter.api import get
_gptcache = self._get_gptcache(llm_string)
res = get(prompt, cache_obj=_gptcache)
if res:
return [
Generation(**generation_dict) for generation_dict in json.loads(res)
]
return None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Update cache.
First, retrieve the corresponding cache object using the `llm_string` parameter,
and then store the `prompt` and `return_val` in the cache object.
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"GPTCache only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
from gptcache.adapter.api import put
_gptcache = self._get_gptcache(llm_string)
handled_data = json.dumps([generation.dict() for generation in return_val])
put(prompt, handled_data, cache_obj=_gptcache)
return None
def clear(self, **kwargs: Any) -> None:
"""Clear cache."""
from gptcache import Cache
for gptcache_instance in self.gptcache_dict.values():
gptcache_instance = cast(Cache, gptcache_instance)
gptcache_instance.flush()
self.gptcache_dict.clear()
def _ensure_cache_exists(cache_client: momento.CacheClient, cache_name: str) -> None:
"""Create cache if it doesn't exist.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
from momento.responses import CreateCache
create_cache_response = cache_client.create_cache(cache_name)
if isinstance(create_cache_response, CreateCache.Success) or isinstance(
create_cache_response, CreateCache.CacheAlreadyExists
):
return None
elif isinstance(create_cache_response, CreateCache.Error):
raise create_cache_response.inner_exception
else:
raise Exception(f"Unexpected response cache creation: {create_cache_response}")
def _validate_ttl(ttl: Optional[timedelta]) -> None:
if ttl is not None and ttl <= timedelta(seconds=0):
raise ValueError(f"ttl must be positive but was {ttl}.")
class MomentoCache(BaseCache):
"""Cache that uses Momento as a backend. See https://gomomento.com/"""
def __init__(
self,
cache_client: momento.CacheClient,
cache_name: str,
*,
ttl: Optional[timedelta] = None,
ensure_cache_exists: bool = True,
):
"""Instantiate a prompt cache using Momento as a backend.
Note: to instantiate the cache client passed to MomentoCache,
you must have a Momento account. See https://gomomento.com/.
Args:
cache_client (CacheClient): The Momento cache client.
cache_name (str): The name of the cache to use to store the data.
ttl (Optional[timedelta], optional): The time to live for the cache items.
Defaults to None, ie use the client default TTL.
ensure_cache_exists (bool, optional): Create the cache if it doesn't
exist. Defaults to True.
Raises:
ImportError: Momento python package is not installed.
TypeError: cache_client is not of type momento.CacheClientObject
ValueError: ttl is non-null and non-negative
"""
try:
from momento import CacheClient
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if not isinstance(cache_client, CacheClient):
raise TypeError("cache_client must be a momento.CacheClient object.")
_validate_ttl(ttl)
if ensure_cache_exists:
_ensure_cache_exists(cache_client, cache_name)
self.cache_client = cache_client
self.cache_name = cache_name
self.ttl = ttl
@classmethod
def from_client_params(
cls,
cache_name: str,
ttl: timedelta,
*,
configuration: Optional[momento.config.Configuration] = None,
auth_token: Optional[str] = None,
**kwargs: Any,
) -> MomentoCache:
"""Construct cache from CacheClient parameters."""
try:
from momento import CacheClient, Configurations, CredentialProvider
except ImportError:
raise ImportError(
"Could not import momento python package. "
"Please install it with `pip install momento`."
)
if configuration is None:
configuration = Configurations.Laptop.v1()
auth_token = auth_token or get_from_env("auth_token", "MOMENTO_AUTH_TOKEN")
credentials = CredentialProvider.from_string(auth_token)
cache_client = CacheClient(configuration, credentials, default_ttl=ttl)
return cls(cache_client, cache_name, ttl=ttl, **kwargs)
def __key(self, prompt: str, llm_string: str) -> str:
"""Compute cache key from prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Returns:
str: The cache key.
"""
return _hash(prompt + llm_string)
def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
"""Lookup llm generations in cache by prompt and associated model and settings.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model version and settings.
Raises:
SdkException: Momento service or network error
Returns:
Optional[RETURN_VAL_TYPE]: A list of language model generations.
"""
from momento.responses import CacheGet
generations: RETURN_VAL_TYPE = []
get_response = self.cache_client.get(
self.cache_name, self.__key(prompt, llm_string)
)
if isinstance(get_response, CacheGet.Hit):
value = get_response.value_string
generations = _load_generations_from_json(value)
elif isinstance(get_response, CacheGet.Miss):
pass
elif isinstance(get_response, CacheGet.Error):
raise get_response.inner_exception
return generations if generations else None
def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
"""Store llm generations in cache.
Args:
prompt (str): The prompt run through the language model.
llm_string (str): The language model string.
return_val (RETURN_VAL_TYPE): A list of language model generations.
Raises:
SdkException: Momento service or network error
Exception: Unexpected response
"""
for gen in return_val:
if not isinstance(gen, Generation):
raise ValueError(
"Momento only supports caching of normal LLM generations, "
f"got {type(gen)}"
)
key = self.__key(prompt, llm_string)
value = _dump_generations_to_json(return_val)
set_response = self.cache_client.set(self.cache_name, key, value, self.ttl)
from momento.responses import CacheSet
if isinstance(set_response, CacheSet.Success):
pass
elif isinstance(set_response, CacheSet.Error):
raise set_response.inner_exception
else:
raise Exception(f"Unexpected response: {set_response}")
def clear(self, **kwargs: Any) -> None:
"""Clear the cache.
Raises:
SdkException: Momento service or network error
"""
from momento.responses import CacheFlush
flush_response = self.cache_client.flush_cache(self.cache_name)
if isinstance(flush_response, CacheFlush.Success):
pass
elif isinstance(flush_response, CacheFlush.Error):
raise flush_response.inner_exception
| [
"langchain.schema.Generation",
"langchain.utils.get_from_env",
"langchain.load.dump.dumps",
"langchain.vectorstores.redis.Redis",
"langchain.vectorstores.redis.Redis.from_existing_index",
"langchain.load.load.loads"
] | [((1483, 1510), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (1500, 1510), False, 'import logging\n'), ((3955, 3973), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (3971, 3973), False, 'from sqlalchemy.ext.declarative import declarative_base\n'), ((4130, 4162), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (4136, 4162), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4173, 4205), 'sqlalchemy.Column', 'Column', (['String'], {'primary_key': '(True)'}), '(String, primary_key=True)\n', (4179, 4205), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4216, 4249), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (4222, 4249), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((4265, 4279), 'sqlalchemy.Column', 'Column', (['String'], {}), '(String)\n', (4271, 4279), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((2453, 2481), 'json.loads', 'json.loads', (['generations_json'], {}), '(generations_json)\n', (2463, 2481), False, 'import json\n'), ((6683, 6726), 'sqlalchemy.create_engine', 'create_engine', (['f"""sqlite:///{database_path}"""'], {}), "(f'sqlite:///{database_path}')\n", (6696, 6726), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n'), ((15254, 15261), 'gptcache.Cache', 'Cache', ([], {}), '()\n', (15259, 15261), False, 'from gptcache import Cache\n'), ((16587, 16619), 'gptcache.adapter.api.get', 'get', (['prompt'], {'cache_obj': '_gptcache'}), '(prompt, cache_obj=_gptcache)\n', (16590, 16619), False, 'from gptcache.adapter.api import get\n'), ((17506, 17552), 'gptcache.adapter.api.put', 'put', (['prompt', 'handled_data'], {'cache_obj': '_gptcache'}), '(prompt, handled_data, cache_obj=_gptcache)\n', (17509, 17552), False, 'from gptcache.adapter.api import put\n'), ((21401, 21443), 'momento.CredentialProvider.from_string', 'CredentialProvider.from_string', (['auth_token'], {}), '(auth_token)\n', (21431, 21443), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((21467, 21523), 'momento.CacheClient', 'CacheClient', (['configuration', 'credentials'], {'default_ttl': 'ttl'}), '(configuration, credentials, default_ttl=ttl)\n', (21478, 21523), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((2498, 2527), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (2508, 2527), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((5029, 5049), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (5036, 5049), False, 'from sqlalchemy.orm import Session\n'), ((6136, 6156), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6143, 6156), False, 'from sqlalchemy.orm import Session\n'), ((6338, 6358), 'sqlalchemy.orm.Session', 'Session', (['self.engine'], {}), '(self.engine)\n', (6345, 6358), False, 'from sqlalchemy.orm import Session\n'), ((10691, 10807), 'langchain.vectorstores.redis.Redis.from_existing_index', 'RedisVectorstore.from_existing_index', ([], {'embedding': 'self.embedding', 'index_name': 'index_name', 'redis_url': 'self.redis_url'}), '(embedding=self.embedding, index_name=\n index_name, redis_url=self.redis_url)\n', (10727, 10807), True, 'from langchain.vectorstores.redis import Redis as RedisVectorstore\n'), ((15328, 15370), 'inspect.signature', 'inspect.signature', (['self.init_gptcache_func'], {}), '(self.init_gptcache_func)\n', (15345, 15370), False, 'import inspect\n'), ((17775, 17805), 'typing.cast', 'cast', (['Cache', 'gptcache_instance'], {}), '(Cache, gptcache_instance)\n', (17779, 17805), False, 'from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Sequence, Tuple, Type, Union, cast\n'), ((18705, 18725), 'datetime.timedelta', 'timedelta', ([], {'seconds': '(0)'}), '(seconds=0)\n', (18714, 18725), False, 'from datetime import timedelta\n'), ((21268, 21294), 'momento.Configurations.Laptop.v1', 'Configurations.Laptop.v1', ([], {}), '()\n', (21292, 21294), False, 'from momento import CacheClient, Configurations, CredentialProvider\n'), ((21330, 21378), 'langchain.utils.get_from_env', 'get_from_env', (['"""auth_token"""', '"""MOMENTO_AUTH_TOKEN"""'], {}), "('auth_token', 'MOMENTO_AUTH_TOKEN')\n", (21342, 21378), False, 'from langchain.utils import get_from_env\n'), ((8403, 8522), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisCache does not support caching ChatModel outputs.'\n )\n", (8416, 8522), False, 'import warnings\n'), ((10913, 11030), 'langchain.vectorstores.redis.Redis', 'RedisVectorstore', ([], {'embedding_function': 'self.embedding.embed_query', 'index_name': 'index_name', 'redis_url': 'self.redis_url'}), '(embedding_function=self.embedding.embed_query, index_name=\n index_name, redis_url=self.redis_url)\n', (10929, 11030), True, 'from langchain.vectorstores.redis import Redis as RedisVectorstore\n'), ((12815, 12943), 'warnings.warn', 'warnings.warn', (['"""NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs."""'], {}), "(\n 'NOTE: Generation has not been cached. RedisSentimentCache does not support caching ChatModel outputs.'\n )\n", (12828, 12943), False, 'import warnings\n'), ((16673, 16702), 'langchain.schema.Generation', 'Generation', ([], {}), '(**generation_dict)\n', (16683, 16702), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((6046, 6056), 'langchain.load.dump.dumps', 'dumps', (['gen'], {}), '(gen)\n', (6051, 6056), False, 'from langchain.load.dump import dumps\n'), ((7862, 7883), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (7872, 7883), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((15714, 15752), 'gptcache.manager.factory.get_data_manager', 'get_data_manager', ([], {'data_path': 'llm_string'}), '(data_path=llm_string)\n', (15730, 15752), False, 'from gptcache.manager.factory import get_data_manager\n'), ((16726, 16741), 'json.loads', 'json.loads', (['res'], {}), '(res)\n', (16736, 16741), False, 'import json\n'), ((5184, 5197), 'langchain.load.load.loads', 'loads', (['row[0]'], {}), '(row[0])\n', (5189, 5197), False, 'from langchain.load.load import loads\n'), ((12266, 12287), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (12276, 12287), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((5754, 5777), 'langchain.schema.Generation', 'Generation', ([], {'text': 'row[0]'}), '(text=row[0])\n', (5764, 5777), False, 'from langchain.schema import ChatGeneration, Generation\n'), ((4799, 4833), 'sqlalchemy.select', 'select', (['self.cache_schema.response'], {}), '(self.cache_schema.response)\n', (4805, 4833), False, 'from sqlalchemy import Column, Integer, String, create_engine, select\n')] |
"""Utilities for running language models or Chains over datasets."""
from __future__ import annotations
import asyncio
import functools
import inspect
import itertools
import logging
import uuid
import warnings
from enum import Enum
from typing import (
TYPE_CHECKING,
Any,
Callable,
Coroutine,
Dict,
Iterator,
List,
Optional,
Sequence,
Tuple,
Union,
cast,
)
from urllib.parse import urlparse, urlunparse
from langsmith import Client, RunEvaluator
from langsmith.schemas import Dataset, DataType, Example
from langchain.callbacks.base import BaseCallbackHandler
from langchain.callbacks.manager import Callbacks
from langchain.callbacks.tracers.base import BaseTracer
from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler
from langchain.callbacks.tracers.langchain import LangChainTracer
from langchain.chains.base import Chain
from langchain.evaluation.loading import load_evaluator
from langchain.evaluation.schema import EvaluatorType, StringEvaluator
from langchain.schema import ChatResult, LLMResult
from langchain.schema.language_model import BaseLanguageModel
from langchain.schema.messages import BaseMessage, messages_from_dict
from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda
from langchain.smith.evaluation.config import EvalConfig, RunEvalConfig
from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain
if TYPE_CHECKING:
import pandas as pd
logger = logging.getLogger(__name__)
MODEL_OR_CHAIN_FACTORY = Union[
Callable[[], Union[Chain, Runnable]],
BaseLanguageModel,
Callable[[dict], Any],
Runnable,
Chain,
]
MCF = Union[Callable[[], Union[Chain, Runnable]], BaseLanguageModel]
class InputFormatError(Exception):
"""Raised when the input format is invalid."""
## Shared Utilities
class TestResult(dict):
"""A dictionary of the results of a single test run."""
def to_dataframe(self) -> pd.DataFrame:
"""Convert the results to a dataframe."""
try:
import pandas as pd
except ImportError as e:
raise ImportError(
"Pandas is required to convert the results to a dataframe."
" to install pandas, run `pip install pandas`."
) from e
indices = []
records = []
for example_id, result in self["results"].items():
feedback = result["feedback"]
records.append(
{**{f.key: f.score for f in feedback}, "output": result["output"]}
)
indices.append(example_id)
return pd.DataFrame(records, index=indices)
def _get_eval_project_url(api_url: str, project_id: str) -> str:
"""Get the project url from the api url."""
parsed = urlparse(api_url)
hostname = parsed.hostname or ""
if "api." in hostname:
hostname = hostname.replace("api.", "", 1)
if "localhost" in hostname:
# Remove the port
hostname = "localhost"
url = urlunparse(parsed._replace(netloc=hostname))
return f"{url}/projects/p/{project_id}?eval=true"
def _wrap_in_chain_factory(
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
dataset_name: str = "<my_dataset>",
) -> MCF:
"""Forgive the user if they pass in a chain without memory instead of a chain
factory. It's a common mistake. Raise a more helpful error message as well."""
if isinstance(llm_or_chain_factory, Chain):
chain = llm_or_chain_factory
chain_class = chain.__class__.__name__
if llm_or_chain_factory.memory is not None:
memory_class = chain.memory.__class__.__name__
raise ValueError(
"Cannot directly evaluate a chain with stateful memory."
" To evaluate this chain, pass in a chain constructor"
" that initializes fresh memory each time it is called."
" This will safegaurd against information"
" leakage between dataset examples."
"\nFor example:\n\n"
"def chain_constructor():\n"
f" new_memory = {memory_class}(...)\n"
f" return {chain_class}"
"(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
logger.warning(
"Directly passing in a chain is not recommended as chains may have state."
" This can lead to unexpected behavior as the "
"same chain instance could be used across multiple datasets. Instead,"
" please pass a chain constructor that creates a new "
"chain with fresh memory each time it is called. This will safeguard"
" against information leakage between dataset examples. "
"\nFor example:\n\n"
"def chain_constructor():\n"
f" return {chain_class}(memory=new_memory, ...)\n\n"
f'run_on_dataset("{dataset_name}", chain_constructor, ...)'
)
return lambda: chain
elif isinstance(llm_or_chain_factory, BaseLanguageModel):
return llm_or_chain_factory
elif isinstance(llm_or_chain_factory, Runnable):
# Memory may exist here, but it's not elegant to check all those cases.
lcf = llm_or_chain_factory
return lambda: lcf
elif callable(llm_or_chain_factory):
try:
_model = llm_or_chain_factory() # type: ignore[call-arg]
except TypeError:
# It's an arbitrary function, wrap it in a RunnableLambda
user_func = cast(Callable, llm_or_chain_factory)
sig = inspect.signature(user_func)
logger.info(f"Wrapping function {sig} as RunnableLambda.")
wrapped = RunnableLambda(user_func)
return lambda: wrapped
constructor = cast(Callable, llm_or_chain_factory)
if isinstance(_model, BaseLanguageModel):
# It's not uncommon to do an LLM constructor instead of raw LLM,
# so we'll unpack it for the user.
return _model
elif not isinstance(_model, Runnable):
# This is unlikely to happen - a constructor for a model function
return lambda: RunnableLambda(constructor)
else:
# Typical correct case
return constructor # noqa
return llm_or_chain_factory
def _first_example(examples: Iterator[Example]) -> Tuple[Example, Iterator[Example]]:
"""Get the first example while chaining it back and preserving the iterator."""
try:
example: Example = next(examples)
except StopIteration:
raise ValueError("No examples provided.")
return example, itertools.chain([example], examples)
def _get_prompt(inputs: Dict[str, Any]) -> str:
"""Get prompt from inputs.
Args:
inputs: The input dictionary.
Returns:
A string prompt.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
prompts = []
if "prompt" in inputs:
if not isinstance(inputs["prompt"], str):
raise InputFormatError(
"Expected string for 'prompt', got"
f" {type(inputs['prompt']).__name__}"
)
prompts = [inputs["prompt"]]
elif "prompts" in inputs:
if not isinstance(inputs["prompts"], list) or not all(
isinstance(i, str) for i in inputs["prompts"]
):
raise InputFormatError(
"Expected list of strings for 'prompts',"
f" got {type(inputs['prompts']).__name__}"
)
prompts = inputs["prompts"]
elif len(inputs) == 1:
prompt_ = next(iter(inputs.values()))
if isinstance(prompt_, str):
prompts = [prompt_]
elif isinstance(prompt_, list) and all(isinstance(i, str) for i in prompt_):
prompts = prompt_
else:
raise InputFormatError(f"LLM Run expects string prompt input. Got {inputs}")
else:
raise InputFormatError(
f"LLM Run expects 'prompt' or 'prompts' in inputs. Got {inputs}"
)
if len(prompts) == 1:
return prompts[0]
else:
raise InputFormatError(
f"LLM Run expects single prompt input. Got {len(prompts)} prompts."
)
def _get_messages(inputs: Dict[str, Any]) -> List[BaseMessage]:
"""Get Chat Messages from inputs.
Args:
inputs: The input dictionary.
Returns:
A list of chat messages.
Raises:
InputFormatError: If the input format is invalid.
"""
if not inputs:
raise InputFormatError("Inputs should not be empty.")
if "messages" in inputs:
single_input = inputs["messages"]
elif len(inputs) == 1:
single_input = next(iter(inputs.values()))
else:
raise InputFormatError(
f"Chat Run expects 'messages' in inputs when example has multiple"
f" input keys. Got {inputs}"
)
if isinstance(single_input, list) and all(
isinstance(i, dict) for i in single_input
):
raw_messages = [single_input]
elif isinstance(single_input, list) and all(
isinstance(i, list) for i in single_input
):
raw_messages = single_input
else:
raise InputFormatError(
f"Chat Run expects List[dict] or List[List[dict]] values for"
f" 'messages' key input. Got {inputs}"
)
if len(raw_messages) == 1:
return messages_from_dict(raw_messages[0])
else:
raise InputFormatError(
f"Chat Run expects single List[dict] or List[List[dict]] 'messages'"
f" input. Got {len(raw_messages)} messages from inputs {inputs}"
)
def _get_project_name(
project_name: Optional[str],
llm_or_chain_factory: MCF,
) -> str:
"""
Get the project name.
Args:
project_name: The project name if manually specified.
llm_or_chain_factory: The Chain or language model constructor.
Returns:
The project name.
"""
if project_name is not None:
return project_name
if isinstance(llm_or_chain_factory, BaseLanguageModel):
model_name = llm_or_chain_factory.__class__.__name__
else:
model_name = llm_or_chain_factory().__class__.__name__
hex = uuid.uuid4().hex
return f"{hex}-{model_name}"
## Shared Validation Utilities
def _validate_example_inputs_for_language_model(
first_example: Example,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
if input_mapper:
prompt_input = input_mapper(first_example.inputs)
if not isinstance(prompt_input, str) and not (
isinstance(prompt_input, list)
and all(isinstance(msg, BaseMessage) for msg in prompt_input)
):
raise InputFormatError(
"When using an input_mapper to prepare dataset example inputs"
" for an LLM or chat model, the output must a single string or"
" a list of chat messages."
f"\nGot: {prompt_input} of type {type(prompt_input)}."
)
else:
try:
_get_prompt(first_example.inputs)
except InputFormatError:
try:
_get_messages(first_example.inputs)
except InputFormatError:
raise InputFormatError(
"Example inputs do not match language model input format. "
"Expected a dictionary with messages or a single prompt."
f" Got: {first_example.inputs}"
" Please update your dataset OR provide an input_mapper"
" to convert the example.inputs to a compatible format"
" for the llm or chat model you wish to evaluate."
)
def _validate_example_inputs_for_chain(
first_example: Example,
chain: Chain,
input_mapper: Optional[Callable[[Dict], Any]],
) -> None:
"""Validate that the example inputs match the chain input keys."""
if input_mapper:
first_inputs = input_mapper(first_example.inputs)
missing_keys = set(chain.input_keys).difference(first_inputs)
if not isinstance(first_inputs, dict):
raise InputFormatError(
"When using an input_mapper to prepare dataset example"
" inputs for a chain, the mapped value must be a dictionary."
f"\nGot: {first_inputs} of type {type(first_inputs)}."
)
if missing_keys:
raise InputFormatError(
"Missing keys after loading example using input_mapper."
f"\nExpected: {chain.input_keys}. Got: {first_inputs.keys()}"
)
else:
first_inputs = first_example.inputs
missing_keys = set(chain.input_keys).difference(first_inputs)
if len(first_inputs) == 1 and len(chain.input_keys) == 1:
# We can pass this through the run method.
# Refrain from calling to validate.
pass
elif missing_keys:
raise InputFormatError(
"Example inputs missing expected chain input keys."
" Please provide an input_mapper to convert the example.inputs"
" to a compatible format for the chain you wish to evaluate."
f"Expected: {chain.input_keys}. "
f"Got: {first_inputs.keys()}"
)
def _validate_example_inputs(
examples: Iterator[Example],
llm_or_chain_factory: MCF,
input_mapper: Optional[Callable[[Dict], Any]],
) -> Iterator[Example]:
"""Validate that the example inputs are valid for the model."""
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
_validate_example_inputs_for_language_model(first_example, input_mapper)
else:
chain = llm_or_chain_factory()
if isinstance(chain, Chain):
# Otherwise it's a runnable
_validate_example_inputs_for_chain(first_example, chain, input_mapper)
elif isinstance(chain, Runnable):
logger.debug(f"Skipping input validation for {chain}")
return examples
## Shared Evaluator Setup Utilities
def _setup_evaluation(
llm_or_chain_factory: MCF,
examples: Iterator[Example],
evaluation: Optional[RunEvalConfig],
data_type: DataType,
) -> Tuple[Optional[List[RunEvaluator]], Iterator[Example]]:
"""Configure the evaluators to run on the results of the chain."""
if evaluation:
first_example, examples = _first_example(examples)
if isinstance(llm_or_chain_factory, BaseLanguageModel):
run_inputs, run_outputs = None, None
run_type = "llm"
else:
run_type = "chain"
if data_type in (DataType.chat, DataType.llm):
val = data_type.value if isinstance(data_type, Enum) else data_type
raise ValueError(
"Cannot evaluate a chain on dataset with "
f"data_type={val}. "
"Please specify a dataset with the default 'kv' data type."
)
chain = llm_or_chain_factory()
run_inputs = chain.input_keys if isinstance(chain, Chain) else None
run_outputs = chain.output_keys if isinstance(chain, Chain) else None
run_evaluators = _load_run_evaluators(
evaluation,
run_type,
data_type,
list(first_example.outputs) if first_example.outputs else None,
run_inputs,
run_outputs,
)
else:
# TODO: Create a default helpfulness evaluator
run_evaluators = None
return run_evaluators, examples
def _determine_input_key(
config: RunEvalConfig,
run_inputs: Optional[List[str]],
) -> Optional[str]:
input_key = None
if config.input_key:
input_key = config.input_key
if run_inputs and input_key not in run_inputs:
raise ValueError(f"Input key {input_key} not in run inputs {run_inputs}")
elif run_inputs and len(run_inputs) == 1:
input_key = run_inputs[0]
elif run_inputs is not None and len(run_inputs) > 1:
raise ValueError(
f"Must specify input key for model with multiple inputs: {run_inputs}"
)
return input_key
def _determine_prediction_key(
config: RunEvalConfig,
run_outputs: Optional[List[str]],
) -> Optional[str]:
prediction_key = None
if config.prediction_key:
prediction_key = config.prediction_key
if run_outputs and prediction_key not in run_outputs:
raise ValueError(
f"Prediction key {prediction_key} not in run outputs {run_outputs}"
)
elif run_outputs and len(run_outputs) == 1:
prediction_key = run_outputs[0]
elif run_outputs is not None and len(run_outputs) > 1:
raise ValueError(
f"Must specify prediction key for model"
f" with multiple outputs: {run_outputs}"
)
return prediction_key
def _determine_reference_key(
config: RunEvalConfig,
example_outputs: Optional[List[str]],
) -> Optional[str]:
if config.reference_key:
reference_key = config.reference_key
if example_outputs and reference_key not in example_outputs:
raise ValueError(
f"Reference key {reference_key} not in Dataset"
f" example outputs: {example_outputs}"
)
elif example_outputs and len(example_outputs) == 1:
reference_key = list(example_outputs)[0]
else:
reference_key = None
return reference_key
def _construct_run_evaluator(
eval_config: Union[EvaluatorType, str, EvalConfig],
eval_llm: Optional[BaseLanguageModel],
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
reference_key: Optional[str],
input_key: Optional[str],
prediction_key: Optional[str],
) -> RunEvaluator:
if isinstance(eval_config, (EvaluatorType, str)):
if not isinstance(eval_config, EvaluatorType):
eval_config = EvaluatorType(eval_config)
evaluator_ = load_evaluator(eval_config, llm=eval_llm)
eval_type_tag = eval_config.value
else:
kwargs = {"llm": eval_llm, **eval_config.get_kwargs()}
evaluator_ = load_evaluator(eval_config.evaluator_type, **kwargs)
eval_type_tag = eval_config.evaluator_type.value
if isinstance(evaluator_, StringEvaluator):
if evaluator_.requires_reference and reference_key is None:
raise ValueError(
f"Must specify reference_key in RunEvalConfig to use"
f" evaluator of type {eval_type_tag} with"
f" dataset with multiple output keys: {example_outputs}."
)
run_evaluator = StringRunEvaluatorChain.from_run_and_data_type(
evaluator_,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
tags=[eval_type_tag],
)
else:
raise NotImplementedError(
f"Run evaluator for {eval_type_tag} is not implemented"
)
return run_evaluator
def _get_keys(
config: RunEvalConfig,
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
example_outputs: Optional[List[str]],
) -> Tuple[Optional[str], Optional[str], Optional[str]]:
input_key = _determine_input_key(config, run_inputs)
prediction_key = _determine_prediction_key(config, run_outputs)
reference_key = _determine_reference_key(config, example_outputs)
return input_key, prediction_key, reference_key
def _load_run_evaluators(
config: RunEvalConfig,
run_type: str,
data_type: DataType,
example_outputs: Optional[List[str]],
run_inputs: Optional[List[str]],
run_outputs: Optional[List[str]],
) -> List[RunEvaluator]:
"""
Load run evaluators from a configuration.
Args:
config: Configuration for the run evaluators.
Returns:
A list of run evaluators.
"""
run_evaluators = []
input_key, prediction_key, reference_key = None, None, None
if (
config.evaluators
or any([isinstance(e, EvaluatorType) for e in config.evaluators])
or (
config.custom_evaluators
and any([isinstance(e, StringEvaluator) for e in config.custom_evaluators])
)
):
input_key, prediction_key, reference_key = _get_keys(
config, run_inputs, run_outputs, example_outputs
)
for eval_config in config.evaluators:
run_evaluator = _construct_run_evaluator(
eval_config,
config.eval_llm,
run_type,
data_type,
example_outputs,
reference_key,
input_key,
prediction_key,
)
run_evaluators.append(run_evaluator)
custom_evaluators = config.custom_evaluators or []
for custom_evaluator in custom_evaluators:
if isinstance(custom_evaluator, RunEvaluator):
run_evaluators.append(custom_evaluator)
elif isinstance(custom_evaluator, StringEvaluator):
run_evaluators.append(
StringRunEvaluatorChain.from_run_and_data_type(
custom_evaluator,
run_type,
data_type,
input_key=input_key,
prediction_key=prediction_key,
reference_key=reference_key,
)
)
else:
raise ValueError(
f"Unsupported custom evaluator: {custom_evaluator}."
f" Expected RunEvaluator or StringEvaluator."
)
return run_evaluators
### Async Helpers
async def _arun_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
*,
tags: Optional[List[str]] = None,
callbacks: Callbacks = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""Asynchronously run the language model.
Args:
llm: The language model to run.
inputs: The input dictionary.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map inputs to the expected format.
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
return await llm.apredict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
return await llm.apredict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format"
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
prompt = _get_prompt(inputs)
llm_output: Union[str, BaseMessage] = await llm.apredict(
prompt, callbacks=callbacks, tags=tags
)
except InputFormatError:
messages = _get_messages(inputs)
llm_output = await llm.apredict_messages(
messages, callbacks=callbacks, tags=tags
)
return llm_output
async def _arun_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str]:
"""Run a chain asynchronously on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if isinstance(chain, Chain):
if isinstance(inputs_, dict) and len(inputs_) == 1:
val = next(iter(inputs_.values()))
output = await chain.acall(val, callbacks=callbacks, tags=tags)
else:
output = await chain.acall(inputs_, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = await chain.ainvoke(inputs_, config=runnable_config)
return output
async def _arun_llm_or_chain(
example: Example,
llm_or_chain_factory: MCF,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""Asynchronously run the Chain or language model.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
input_mapper: Optional function to map the input to the expected format.
Returns:
A list of outputs.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = await _arun_llm(
llm_or_chain_factory,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = await _arun_chain(
chain,
example.inputs,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
result = output
except Exception as e:
logger.warning(f"{chain_or_llm} failed for example {example.id}. Error: {e}")
result = {"Error": str(e)}
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return result
async def _gather_with_concurrency(
n: int,
initializer: Callable[[], Coroutine[Any, Any, Any]],
*async_funcs: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
],
) -> List[Any]:
"""Run coroutines with a concurrency limit.
Args:
n: The maximum number of concurrent tasks.
initializer: A coroutine that initializes shared resources for the tasks.
async_funcs: The async_funcs to be run concurrently.
Returns:
A list of results from the coroutines.
"""
semaphore = asyncio.Semaphore(n)
job_state = {"num_processed": 0}
callback_queue: asyncio.Queue[Sequence[BaseCallbackHandler]] = asyncio.Queue()
for _ in range(n):
callback_queue.put_nowait(await initializer())
async def run_coroutine_with_semaphore(
async_func: Callable[
[Sequence[BaseCallbackHandler], Dict], Coroutine[Any, Any, Any]
]
) -> Any:
async with semaphore:
callbacks = await callback_queue.get()
try:
result = await async_func(callbacks, job_state)
finally:
callback_queue.put_nowait(callbacks)
return result
results = await asyncio.gather(
*(run_coroutine_with_semaphore(function) for function in async_funcs)
)
while callback_queue:
try:
callbacks = callback_queue.get_nowait()
except asyncio.QueueEmpty:
break
for callback in callbacks:
if isinstance(callback, (LangChainTracer, EvaluatorCallbackHandler)):
callback.wait_for_futures()
return results
async def _callbacks_initializer(
project_name: Optional[str],
client: Client,
run_evaluators: Sequence[RunEvaluator],
evaluation_handler_collector: List[EvaluatorCallbackHandler],
) -> List[BaseTracer]:
"""
Initialize a tracer to share across tasks.
Args:
project_name: The project name for the tracer.
client: The client to use for the tracer.
run_evaluators: The evaluators to run.
evaluation_handler_collector: A list to collect the evaluators.
Used to wait for the evaluators to finish.
Returns:
The callbacks for this thread.
"""
callbacks: List[BaseTracer] = []
if project_name:
callbacks.append(
LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
)
if run_evaluators:
callback = EvaluatorCallbackHandler(
client=client,
evaluators=run_evaluators,
# We already have concurrency, don't want to overload the machine
max_workers=1,
)
callbacks.append(callback)
evaluation_handler_collector.append(callback)
return callbacks
async def _arun_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Asynchronously run the chain on examples and store traces
to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
project_name: Project name to use when tracing runs.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, wrapped_model)
run_evaluators, examples = _setup_evaluation(
wrapped_model, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, wrapped_model, input_mapper)
results: Dict[str, dict] = {}
async def process_example(
example: Example, callbacks: List[BaseCallbackHandler], job_state: dict
) -> None:
"""Process a single example."""
result = await _arun_llm_or_chain(
example,
wrapped_model,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
results[str(example.id)] = {"output": result}
job_state["num_processed"] += 1
if verbose:
print(
f"Processed examples: {job_state['num_processed']}",
end="\r",
flush=True,
)
evaluation_handlers: List[EvaluatorCallbackHandler] = []
await _gather_with_concurrency(
concurrency_level,
functools.partial(
_callbacks_initializer,
project_name=project_name,
client=client,
evaluation_handler_collector=evaluation_handlers,
run_evaluators=run_evaluators or [],
),
*(functools.partial(process_example, e) for e in examples),
)
all_feedback = {}
for handler in evaluation_handlers:
handler.wait_for_futures()
all_feedback.update(handler.logged_feedback)
# join the results and feedback on the example id
for example_id, output_dict in results.items():
feedback = all_feedback.get(example_id, [])
output_dict["feedback"] = feedback
return results
## Sync Utilities
def _run_llm(
llm: BaseLanguageModel,
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[str, BaseMessage]:
"""
Run the language model on the example.
Args:
llm: The language model to run.
inputs: The input dictionary.
callbacks: The callbacks to use during the run.
tags: Optional tags to add to the run.
input_mapper: function to map to the inputs dictionary from an Example
Returns:
The LLMResult or ChatResult.
Raises:
ValueError: If the LLM type is unsupported.
InputFormatError: If the input format is invalid.
"""
if input_mapper is not None:
prompt_or_messages = input_mapper(inputs)
if isinstance(prompt_or_messages, str):
llm_output: Union[str, BaseMessage] = llm.predict(
prompt_or_messages, callbacks=callbacks, tags=tags
)
elif isinstance(prompt_or_messages, list) and all(
isinstance(msg, BaseMessage) for msg in prompt_or_messages
):
llm_output = llm.predict_messages(
prompt_or_messages, callbacks=callbacks, tags=tags
)
else:
raise InputFormatError(
"Input mapper returned invalid format: "
f" {prompt_or_messages}"
"\nExpected a single string or list of chat messages."
)
else:
try:
llm_prompts = _get_prompt(inputs)
llm_output = llm.predict(llm_prompts, callbacks=callbacks, tags=tags)
except InputFormatError:
llm_messages = _get_messages(inputs)
llm_output = llm.predict_messages(llm_messages, callbacks=callbacks)
return llm_output
def _run_chain(
chain: Union[Chain, Runnable],
inputs: Dict[str, Any],
callbacks: Callbacks,
*,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[Dict, str]:
"""Run a chain on inputs."""
inputs_ = inputs if input_mapper is None else input_mapper(inputs)
if isinstance(chain, Chain):
if isinstance(inputs_, dict) and len(inputs_) == 1:
val = next(iter(inputs_.values()))
output = chain(val, callbacks=callbacks, tags=tags)
else:
output = chain(inputs_, callbacks=callbacks, tags=tags)
else:
runnable_config = RunnableConfig(tags=tags or [], callbacks=callbacks)
output = chain.invoke(inputs_, config=runnable_config)
return output
def _run_llm_or_chain(
example: Example,
llm_or_chain_factory: MCF,
*,
tags: Optional[List[str]] = None,
callbacks: Optional[List[BaseCallbackHandler]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
) -> Union[dict, str, LLMResult, ChatResult]:
"""
Run the Chain or language model synchronously.
Args:
example: The example to run.
llm_or_chain_factory: The Chain or language model constructor to run.
tags: Optional tags to add to the run.
callbacks: Optional callbacks to use during the run.
Returns:
Union[List[dict], List[str], List[LLMResult], List[ChatResult]]:
The outputs of the model or chain.
"""
if callbacks:
previous_example_ids = [
getattr(tracer, "example_id", None) for tracer in callbacks
]
for tracer in callbacks:
if hasattr(tracer, "example_id"):
tracer.example_id = example.id
else:
previous_example_ids = None
chain_or_llm = (
"LLM" if isinstance(llm_or_chain_factory, BaseLanguageModel) else "Chain"
)
result = None
try:
if isinstance(llm_or_chain_factory, BaseLanguageModel):
output: Any = _run_llm(
llm_or_chain_factory,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
else:
chain = llm_or_chain_factory()
output = _run_chain(
chain,
example.inputs,
callbacks,
tags=tags,
input_mapper=input_mapper,
)
result = output
except Exception as e:
logger.warning(
f"{chain_or_llm} failed for example {example.id} with inputs:"
f" {example.inputs}.\nError: {e}",
)
result = {"Error": str(e)}
if callbacks and previous_example_ids:
for example_id, tracer in zip(previous_example_ids, callbacks):
if hasattr(tracer, "example_id"):
tracer.example_id = example_id
return result
def _run_on_examples(
client: Client,
examples: Iterator[Example],
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
data_type: DataType = DataType.kv,
) -> Dict[str, Any]:
"""
Run the Chain or language model on examples and store
traces to the specified project name.
Args:
client: LangSmith client to use to log feedback and runs.
examples: Examples to run the model or chain over.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
data_type: The dataset's data type. This is used to determine determine
how to deserialize the reference data and model compatibility.
Returns:
A dictionary mapping example ids to the model outputs.
"""
results: Dict[str, dict] = {}
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory)
project_name = _get_project_name(project_name, wrapped_model)
tracer = LangChainTracer(
project_name=project_name, client=client, use_threading=False
)
run_evaluators, examples = _setup_evaluation(
wrapped_model, examples, evaluation, data_type
)
examples = _validate_example_inputs(examples, wrapped_model, input_mapper)
evaluation_handler = EvaluatorCallbackHandler(
evaluators=run_evaluators or [],
client=client,
)
callbacks: List[BaseCallbackHandler] = [tracer, evaluation_handler]
for i, example in enumerate(examples):
result = _run_llm_or_chain(
example,
wrapped_model,
tags=tags,
callbacks=callbacks,
input_mapper=input_mapper,
)
if verbose:
print(f"{i+1} processed", flush=True, end="\r")
results[str(example.id)] = {"output": result}
tracer.wait_for_futures()
evaluation_handler.wait_for_futures()
all_feedback = evaluation_handler.logged_feedback
# join the results and feedback on the example id
for example_id, output_dict in results.items():
feedback = all_feedback.get(example_id, [])
output_dict["feedback"] = feedback
return results
## Public API
def _prepare_eval_run(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
project_name: Optional[str],
) -> Tuple[MCF, str, Dataset, Iterator[Example]]:
wrapped_model = _wrap_in_chain_factory(llm_or_chain_factory, dataset_name)
project_name = _get_project_name(project_name, wrapped_model)
try:
project = client.create_project(project_name)
except ValueError as e:
if "already exists " not in str(e):
raise e
raise ValueError(
f"Project {project_name} already exists. Please use a different name."
)
project_url = _get_eval_project_url(client.api_url, project.id)
print(
f"View the evaluation results for project '{project_name}' at:\n{project_url}"
)
dataset = client.read_dataset(dataset_name=dataset_name)
examples = client.list_examples(dataset_id=str(dataset.id))
return wrapped_model, project_name, dataset, examples
async def arun_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
"""
Asynchronously run the Chain or language model on a dataset
and store traces to the specified project name.
Args:
client: LangSmith client to use to read the dataset, and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Optional evaluation configuration to use when evaluating
concurrency_level: The number of async tasks to run concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the
resulting model outputs.
For the synchronous version, see :func:`run_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, arun_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
await arun_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
if kwargs:
warnings.warn(
"The following arguments are deprecated and will "
"be removed in a future release: "
f"{kwargs.keys()}.",
DeprecationWarning,
)
wrapped_model, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
results = await _arun_on_examples(
client,
examples,
wrapped_model,
concurrency_level=concurrency_level,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
return TestResult(
project_name=project_name,
results=results,
)
def _handle_coroutine(coro: Coroutine) -> Any:
"""
Handles a coroutine from a sync context.
Args:
coro (asyncio.coroutine): The coroutine to be handled.
Returns:
any: The result of the executed coroutine.
"""
# Check if there's a running event loop
try:
loop = asyncio.get_event_loop()
except RuntimeError: # No event loop
return asyncio.run(coro)
if loop.is_running():
return loop.run_until_complete(coro)
else:
return asyncio.run(coro)
def run_on_dataset(
client: Client,
dataset_name: str,
llm_or_chain_factory: MODEL_OR_CHAIN_FACTORY,
*,
evaluation: Optional[RunEvalConfig] = None,
concurrency_level: int = 5,
project_name: Optional[str] = None,
verbose: bool = False,
tags: Optional[List[str]] = None,
input_mapper: Optional[Callable[[Dict], Any]] = None,
**kwargs: Any,
) -> Dict[str, Any]:
"""
Run the Chain or language model on a dataset and store traces
to the specified project name.
Args:
client: LangSmith client to use to access the dataset and to
log feedback and run traces.
dataset_name: Name of the dataset to run the chain on.
llm_or_chain_factory: Language model or Chain constructor to run
over the dataset. The Chain constructor is used to permit
independent calls on each example without carrying over state.
evaluation: Configuration for evaluators to run on the
results of the chain
concurrency_level: The number of async tasks to run concurrently.
project_name: Name of the project to store the traces in.
Defaults to {dataset_name}-{chain class name}-{datetime}.
verbose: Whether to print progress.
tags: Tags to add to each run in the project.
input_mapper: A function to map to the inputs dictionary from an Example
to the format expected by the model to be evaluated. This is useful if
your model needs to deserialize more complex schema or if your dataset
has inputs with keys that differ from what is expected by your chain
or agent.
Returns:
A dictionary containing the run's project name and the resulting model outputs.
For the (usually faster) async version of this function, see :func:`arun_on_dataset`.
Examples
--------
.. code-block:: python
from langsmith import Client
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
from langchain.smith import RunEvalConfig, run_on_dataset
# Chains may have memory. Passing in a constructor function lets the
# evaluation framework avoid cross-contamination between runs.
def construct_chain():
llm = ChatOpenAI(temperature=0)
chain = LLMChain.from_string(
llm,
"What's the answer to {your_input_key}"
)
return chain
# Load off-the-shelf evaluators via config or the EvaluatorType (string or enum)
evaluation_config = RunEvalConfig(
evaluators=[
"qa", # "Correctness" against a reference answer
"embedding_distance",
RunEvalConfig.Criteria("helpfulness"),
RunEvalConfig.Criteria({
"fifth-grader-score": "Do you have to be smarter than a fifth grader to answer this question?"
}),
]
)
client = Client()
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
You can also create custom evaluators by subclassing the
:class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`
or LangSmith's `RunEvaluator` classes.
.. code-block:: python
from typing import Optional
from langchain.evaluation import StringEvaluator
class MyStringEvaluator(StringEvaluator):
@property
def requires_input(self) -> bool:
return False
@property
def requires_reference(self) -> bool:
return True
@property
def evaluation_name(self) -> str:
return "exact_match"
def _evaluate_strings(self, prediction, reference=None, input=None, **kwargs) -> dict:
return {"score": prediction == reference}
evaluation_config = RunEvalConfig(
custom_evaluators = [MyStringEvaluator()],
)
run_on_dataset(
client,
"<my_dataset_name>",
construct_chain,
evaluation=evaluation_config,
)
""" # noqa: E501
if kwargs:
warnings.warn(
"The following arguments are deprecated and "
"will be removed in a future release: "
f"{kwargs.keys()}.",
DeprecationWarning,
)
wrapped_model, project_name, dataset, examples = _prepare_eval_run(
client, dataset_name, llm_or_chain_factory, project_name
)
if concurrency_level in (0, 1):
results = _run_on_examples(
client,
examples,
wrapped_model,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
else:
# TODO: Use runnables and the batch method
coro = _arun_on_examples(
client,
examples,
wrapped_model,
concurrency_level=concurrency_level,
project_name=project_name,
verbose=verbose,
tags=tags,
evaluation=evaluation,
input_mapper=input_mapper,
data_type=dataset.data_type,
)
results = _handle_coroutine(coro)
return TestResult(
project_name=project_name,
results=results,
)
| [
"langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type",
"langchain.evaluation.loading.load_evaluator",
"langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler",
"langchain.schema.runnable.RunnableConfig",
"langchain.schema.messages.messages_from_dict",
"langchain.evaluation.schema.EvaluatorType",
"langchain.callbacks.tracers.langchain.LangChainTracer",
"langchain.schema.runnable.RunnableLambda"
] | [((1500, 1527), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1517, 1527), False, 'import logging\n'), ((2799, 2816), 'urllib.parse.urlparse', 'urlparse', (['api_url'], {}), '(api_url)\n', (2807, 2816), False, 'from urllib.parse import urlparse, urlunparse\n'), ((27519, 27539), 'asyncio.Semaphore', 'asyncio.Semaphore', (['n'], {}), '(n)\n', (27536, 27539), False, 'import asyncio\n'), ((27645, 27660), 'asyncio.Queue', 'asyncio.Queue', ([], {}), '()\n', (27658, 27660), False, 'import asyncio\n'), ((40275, 40353), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (40290, 40353), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((40583, 40655), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'evaluators': '(run_evaluators or [])', 'client': 'client'}), '(evaluators=run_evaluators or [], client=client)\n', (40607, 40655), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((2634, 2670), 'pandas.DataFrame', 'pd.DataFrame', (['records'], {'index': 'indices'}), '(records, index=indices)\n', (2646, 2670), True, 'import pandas as pd\n'), ((6729, 6765), 'itertools.chain', 'itertools.chain', (['[example]', 'examples'], {}), '([example], examples)\n', (6744, 6765), False, 'import itertools\n'), ((9608, 9643), 'langchain.schema.messages.messages_from_dict', 'messages_from_dict', (['raw_messages[0]'], {}), '(raw_messages[0])\n', (9626, 9643), False, 'from langchain.schema.messages import BaseMessage, messages_from_dict\n'), ((10444, 10456), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (10454, 10456), False, 'import uuid\n'), ((18358, 18399), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config'], {'llm': 'eval_llm'}), '(eval_config, llm=eval_llm)\n', (18372, 18399), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((18536, 18588), 'langchain.evaluation.loading.load_evaluator', 'load_evaluator', (['eval_config.evaluator_type'], {}), '(eval_config.evaluator_type, **kwargs)\n', (18550, 18588), False, 'from langchain.evaluation.loading import load_evaluator\n'), ((19034, 19224), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['evaluator_', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key', 'tags': '[eval_type_tag]'}), '(evaluator_, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key, tags=[eval_type_tag])\n', (19080, 19224), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((24688, 24740), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (24702, 24740), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((29506, 29591), 'langchain.callbacks.tracers.evaluation.EvaluatorCallbackHandler', 'EvaluatorCallbackHandler', ([], {'client': 'client', 'evaluators': 'run_evaluators', 'max_workers': '(1)'}), '(client=client, evaluators=run_evaluators,\n max_workers=1)\n', (29530, 29591), False, 'from langchain.callbacks.tracers.evaluation import EvaluatorCallbackHandler\n'), ((36030, 36082), 'langchain.schema.runnable.RunnableConfig', 'RunnableConfig', ([], {'tags': '(tags or [])', 'callbacks': 'callbacks'}), '(tags=tags or [], callbacks=callbacks)\n', (36044, 36082), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((47863, 47887), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (47885, 47887), False, 'import asyncio\n'), ((48059, 48076), 'asyncio.run', 'asyncio.run', (['coro'], {}), '(coro)\n', (48070, 48076), False, 'import asyncio\n'), ((18310, 18336), 'langchain.evaluation.schema.EvaluatorType', 'EvaluatorType', (['eval_config'], {}), '(eval_config)\n', (18323, 18336), False, 'from langchain.evaluation.schema import EvaluatorType, StringEvaluator\n'), ((29345, 29423), 'langchain.callbacks.tracers.langchain.LangChainTracer', 'LangChainTracer', ([], {'project_name': 'project_name', 'client': 'client', 'use_threading': '(False)'}), '(project_name=project_name, client=client, use_threading=False)\n', (29360, 29423), False, 'from langchain.callbacks.tracers.langchain import LangChainTracer\n'), ((32818, 32997), 'functools.partial', 'functools.partial', (['_callbacks_initializer'], {'project_name': 'project_name', 'client': 'client', 'evaluation_handler_collector': 'evaluation_handlers', 'run_evaluators': '(run_evaluators or [])'}), '(_callbacks_initializer, project_name=project_name, client\n =client, evaluation_handler_collector=evaluation_handlers,\n run_evaluators=run_evaluators or [])\n', (32835, 32997), False, 'import functools\n'), ((47945, 47962), 'asyncio.run', 'asyncio.run', (['coro'], {}), '(coro)\n', (47956, 47962), False, 'import asyncio\n'), ((5873, 5909), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5877, 5909), False, 'from typing import TYPE_CHECKING, Any, Callable, Coroutine, Dict, Iterator, List, Optional, Sequence, Tuple, Union, cast\n'), ((21499, 21673), 'langchain.smith.evaluation.string_run_evaluator.StringRunEvaluatorChain.from_run_and_data_type', 'StringRunEvaluatorChain.from_run_and_data_type', (['custom_evaluator', 'run_type', 'data_type'], {'input_key': 'input_key', 'prediction_key': 'prediction_key', 'reference_key': 'reference_key'}), '(custom_evaluator, run_type,\n data_type, input_key=input_key, prediction_key=prediction_key,\n reference_key=reference_key)\n', (21545, 21673), False, 'from langchain.smith.evaluation.string_run_evaluator import StringRunEvaluatorChain\n'), ((33071, 33108), 'functools.partial', 'functools.partial', (['process_example', 'e'], {}), '(process_example, e)\n', (33088, 33108), False, 'import functools\n'), ((5613, 5649), 'typing.cast', 'cast', (['Callable', 'llm_or_chain_factory'], {}), '(Callable, llm_or_chain_factory)\n', (5617, 5649), False, 'from typing import TYPE_CHECKING, Any, Callable, Coroutine, Dict, Iterator, List, Optional, Sequence, Tuple, Union, cast\n'), ((5668, 5696), 'inspect.signature', 'inspect.signature', (['user_func'], {}), '(user_func)\n', (5685, 5696), False, 'import inspect\n'), ((5790, 5815), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['user_func'], {}), '(user_func)\n', (5804, 5815), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n'), ((6262, 6289), 'langchain.schema.runnable.RunnableLambda', 'RunnableLambda', (['constructor'], {}), '(constructor)\n', (6276, 6289), False, 'from langchain.schema.runnable import Runnable, RunnableConfig, RunnableLambda\n')] |
"""Base interface that all chains should implement."""
import json
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import BaseModel, Field, validator
import langchain
from langchain.callbacks import get_callback_manager
from langchain.callbacks.base import BaseCallbackManager
from langchain.schema import BaseMemory
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(BaseModel, ABC):
"""Base interface that all chains should implement."""
memory: Optional[BaseMemory] = None
callback_manager: BaseCallbackManager = Field(
default_factory=get_callback_manager, exclude=True
)
verbose: bool = Field(
default_factory=_get_verbosity
) # Whether to print the response text
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@validator("callback_manager", pre=True, always=True)
def set_callback_manager(
cls, callback_manager: Optional[BaseCallbackManager]
) -> BaseCallbackManager:
"""If callback manager is None, set it.
This allows users to pass in None as callback manager, which is a nice UX.
"""
return callback_manager or get_callback_manager()
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Input keys this chain expects."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Output keys this chain expects."""
def _validate_inputs(self, inputs: Dict[str, str]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, str]) -> None:
if set(outputs) != set(self.output_keys):
raise ValueError(
f"Did not get output keys that were expected. "
f"Got: {set(outputs)}. Expected: {set(self.output_keys)}."
)
@abstractmethod
def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
async def _acall(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = self._call(inputs)
except (KeyboardInterrupt, Exception) as e:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
async def acall(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
if self.callback_manager.is_async:
await self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
else:
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = await self._acall(inputs)
except (KeyboardInterrupt, Exception) as e:
if self.callback_manager.is_async:
await self.callback_manager.on_chain_error(e, verbose=self.verbose)
else:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
if self.callback_manager.is_async:
await self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
else:
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prep outputs."""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prep inputs."""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
def apply(self, input_list: List[Dict[str, Any]]) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs) for inputs in input_list]
def run(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0])[self.output_keys[0]]
if kwargs and not args:
return self(kwargs)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (await self.acall(args[0]))[self.output_keys[0]]
if kwargs and not args:
return (await self.acall(kwargs))[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain."""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict()
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
| [
"langchain.callbacks.get_callback_manager"
] | [((646, 703), 'pydantic.Field', 'Field', ([], {'default_factory': 'get_callback_manager', 'exclude': '(True)'}), '(default_factory=get_callback_manager, exclude=True)\n', (651, 703), False, 'from pydantic import BaseModel, Field, validator\n'), ((738, 775), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (743, 775), False, 'from pydantic import BaseModel, Field, validator\n'), ((1075, 1127), 'pydantic.validator', 'validator', (['"""callback_manager"""'], {'pre': '(True)', 'always': '(True)'}), "('callback_manager', pre=True, always=True)\n", (1084, 1127), False, 'from pydantic import BaseModel, Field, validator\n'), ((1457, 1500), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (1466, 1500), False, 'from pydantic import BaseModel, Field, validator\n'), ((1428, 1450), 'langchain.callbacks.get_callback_manager', 'get_callback_manager', ([], {}), '()\n', (1448, 1450), False, 'from langchain.callbacks import get_callback_manager\n'), ((10078, 10093), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (10082, 10093), False, 'from pathlib import Path\n'), ((10413, 10447), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (10422, 10447), False, 'import json\n'), ((10550, 10600), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (10559, 10600), False, 'import yaml\n')] |
"""Base interface that all chains should implement."""
import json
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import BaseModel, Field, validator
import langchain
from langchain.callbacks import get_callback_manager
from langchain.callbacks.base import BaseCallbackManager
from langchain.schema import BaseMemory
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(BaseModel, ABC):
"""Base interface that all chains should implement."""
memory: Optional[BaseMemory] = None
callback_manager: BaseCallbackManager = Field(
default_factory=get_callback_manager, exclude=True
)
verbose: bool = Field(
default_factory=_get_verbosity
) # Whether to print the response text
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@validator("callback_manager", pre=True, always=True)
def set_callback_manager(
cls, callback_manager: Optional[BaseCallbackManager]
) -> BaseCallbackManager:
"""If callback manager is None, set it.
This allows users to pass in None as callback manager, which is a nice UX.
"""
return callback_manager or get_callback_manager()
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Input keys this chain expects."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Output keys this chain expects."""
def _validate_inputs(self, inputs: Dict[str, str]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, str]) -> None:
if set(outputs) != set(self.output_keys):
raise ValueError(
f"Did not get output keys that were expected. "
f"Got: {set(outputs)}. Expected: {set(self.output_keys)}."
)
@abstractmethod
def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
async def _acall(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = self._call(inputs)
except (KeyboardInterrupt, Exception) as e:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
async def acall(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
if self.callback_manager.is_async:
await self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
else:
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = await self._acall(inputs)
except (KeyboardInterrupt, Exception) as e:
if self.callback_manager.is_async:
await self.callback_manager.on_chain_error(e, verbose=self.verbose)
else:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
if self.callback_manager.is_async:
await self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
else:
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prep outputs."""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prep inputs."""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
def apply(self, input_list: List[Dict[str, Any]]) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs) for inputs in input_list]
def run(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0])[self.output_keys[0]]
if kwargs and not args:
return self(kwargs)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (await self.acall(args[0]))[self.output_keys[0]]
if kwargs and not args:
return (await self.acall(kwargs))[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain."""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict()
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
| [
"langchain.callbacks.get_callback_manager"
] | [((646, 703), 'pydantic.Field', 'Field', ([], {'default_factory': 'get_callback_manager', 'exclude': '(True)'}), '(default_factory=get_callback_manager, exclude=True)\n', (651, 703), False, 'from pydantic import BaseModel, Field, validator\n'), ((738, 775), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (743, 775), False, 'from pydantic import BaseModel, Field, validator\n'), ((1075, 1127), 'pydantic.validator', 'validator', (['"""callback_manager"""'], {'pre': '(True)', 'always': '(True)'}), "('callback_manager', pre=True, always=True)\n", (1084, 1127), False, 'from pydantic import BaseModel, Field, validator\n'), ((1457, 1500), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (1466, 1500), False, 'from pydantic import BaseModel, Field, validator\n'), ((1428, 1450), 'langchain.callbacks.get_callback_manager', 'get_callback_manager', ([], {}), '()\n', (1448, 1450), False, 'from langchain.callbacks import get_callback_manager\n'), ((10078, 10093), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (10082, 10093), False, 'from pathlib import Path\n'), ((10413, 10447), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (10422, 10447), False, 'import json\n'), ((10550, 10600), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (10559, 10600), False, 'import yaml\n')] |
"""Base interface that all chains should implement."""
import json
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import BaseModel, Field, validator
import langchain
from langchain.callbacks import get_callback_manager
from langchain.callbacks.base import BaseCallbackManager
from langchain.schema import BaseMemory
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(BaseModel, ABC):
"""Base interface that all chains should implement."""
memory: Optional[BaseMemory] = None
callback_manager: BaseCallbackManager = Field(
default_factory=get_callback_manager, exclude=True
)
verbose: bool = Field(
default_factory=_get_verbosity
) # Whether to print the response text
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@validator("callback_manager", pre=True, always=True)
def set_callback_manager(
cls, callback_manager: Optional[BaseCallbackManager]
) -> BaseCallbackManager:
"""If callback manager is None, set it.
This allows users to pass in None as callback manager, which is a nice UX.
"""
return callback_manager or get_callback_manager()
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Input keys this chain expects."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Output keys this chain expects."""
def _validate_inputs(self, inputs: Dict[str, str]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, str]) -> None:
if set(outputs) != set(self.output_keys):
raise ValueError(
f"Did not get output keys that were expected. "
f"Got: {set(outputs)}. Expected: {set(self.output_keys)}."
)
@abstractmethod
def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
async def _acall(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = self._call(inputs)
except (KeyboardInterrupt, Exception) as e:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
async def acall(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
if self.callback_manager.is_async:
await self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
else:
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = await self._acall(inputs)
except (KeyboardInterrupt, Exception) as e:
if self.callback_manager.is_async:
await self.callback_manager.on_chain_error(e, verbose=self.verbose)
else:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
if self.callback_manager.is_async:
await self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
else:
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prep outputs."""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prep inputs."""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
def apply(self, input_list: List[Dict[str, Any]]) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs) for inputs in input_list]
def run(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0])[self.output_keys[0]]
if kwargs and not args:
return self(kwargs)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (await self.acall(args[0]))[self.output_keys[0]]
if kwargs and not args:
return (await self.acall(kwargs))[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain."""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict()
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
| [
"langchain.callbacks.get_callback_manager"
] | [((646, 703), 'pydantic.Field', 'Field', ([], {'default_factory': 'get_callback_manager', 'exclude': '(True)'}), '(default_factory=get_callback_manager, exclude=True)\n', (651, 703), False, 'from pydantic import BaseModel, Field, validator\n'), ((738, 775), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (743, 775), False, 'from pydantic import BaseModel, Field, validator\n'), ((1075, 1127), 'pydantic.validator', 'validator', (['"""callback_manager"""'], {'pre': '(True)', 'always': '(True)'}), "('callback_manager', pre=True, always=True)\n", (1084, 1127), False, 'from pydantic import BaseModel, Field, validator\n'), ((1457, 1500), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (1466, 1500), False, 'from pydantic import BaseModel, Field, validator\n'), ((1428, 1450), 'langchain.callbacks.get_callback_manager', 'get_callback_manager', ([], {}), '()\n', (1448, 1450), False, 'from langchain.callbacks import get_callback_manager\n'), ((10078, 10093), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (10082, 10093), False, 'from pathlib import Path\n'), ((10413, 10447), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (10422, 10447), False, 'import json\n'), ((10550, 10600), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (10559, 10600), False, 'import yaml\n')] |
"""Base interface that all chains should implement."""
import json
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
import yaml
from pydantic import BaseModel, Field, validator
import langchain
from langchain.callbacks import get_callback_manager
from langchain.callbacks.base import BaseCallbackManager
from langchain.schema import BaseMemory
def _get_verbosity() -> bool:
return langchain.verbose
class Chain(BaseModel, ABC):
"""Base interface that all chains should implement."""
memory: Optional[BaseMemory] = None
callback_manager: BaseCallbackManager = Field(
default_factory=get_callback_manager, exclude=True
)
verbose: bool = Field(
default_factory=_get_verbosity
) # Whether to print the response text
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@property
def _chain_type(self) -> str:
raise NotImplementedError("Saving not supported for this chain type.")
@validator("callback_manager", pre=True, always=True)
def set_callback_manager(
cls, callback_manager: Optional[BaseCallbackManager]
) -> BaseCallbackManager:
"""If callback manager is None, set it.
This allows users to pass in None as callback manager, which is a nice UX.
"""
return callback_manager or get_callback_manager()
@validator("verbose", pre=True, always=True)
def set_verbose(cls, verbose: Optional[bool]) -> bool:
"""If verbose is None, set it.
This allows users to pass in None as verbose to access the global setting.
"""
if verbose is None:
return _get_verbosity()
else:
return verbose
@property
@abstractmethod
def input_keys(self) -> List[str]:
"""Input keys this chain expects."""
@property
@abstractmethod
def output_keys(self) -> List[str]:
"""Output keys this chain expects."""
def _validate_inputs(self, inputs: Dict[str, str]) -> None:
"""Check that all inputs are present."""
missing_keys = set(self.input_keys).difference(inputs)
if missing_keys:
raise ValueError(f"Missing some input keys: {missing_keys}")
def _validate_outputs(self, outputs: Dict[str, str]) -> None:
if set(outputs) != set(self.output_keys):
raise ValueError(
f"Did not get output keys that were expected. "
f"Got: {set(outputs)}. Expected: {set(self.output_keys)}."
)
@abstractmethod
def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
async def _acall(self, inputs: Dict[str, str]) -> Dict[str, str]:
"""Run the logic of this chain and return the output."""
raise NotImplementedError("Async call not supported for this chain type.")
def __call__(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = self._call(inputs)
except (KeyboardInterrupt, Exception) as e:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
async def acall(
self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
) -> Dict[str, Any]:
"""Run the logic of this chain and add to output if desired.
Args:
inputs: Dictionary of inputs, or single input if chain expects
only one param.
return_only_outputs: boolean for whether to return only outputs in the
response. If True, only new keys generated by this chain will be
returned. If False, both input keys and new keys generated by this
chain will be returned. Defaults to False.
"""
inputs = self.prep_inputs(inputs)
if self.callback_manager.is_async:
await self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
else:
self.callback_manager.on_chain_start(
{"name": self.__class__.__name__},
inputs,
verbose=self.verbose,
)
try:
outputs = await self._acall(inputs)
except (KeyboardInterrupt, Exception) as e:
if self.callback_manager.is_async:
await self.callback_manager.on_chain_error(e, verbose=self.verbose)
else:
self.callback_manager.on_chain_error(e, verbose=self.verbose)
raise e
if self.callback_manager.is_async:
await self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
else:
self.callback_manager.on_chain_end(outputs, verbose=self.verbose)
return self.prep_outputs(inputs, outputs, return_only_outputs)
def prep_outputs(
self,
inputs: Dict[str, str],
outputs: Dict[str, str],
return_only_outputs: bool = False,
) -> Dict[str, str]:
"""Validate and prep outputs."""
self._validate_outputs(outputs)
if self.memory is not None:
self.memory.save_context(inputs, outputs)
if return_only_outputs:
return outputs
else:
return {**inputs, **outputs}
def prep_inputs(self, inputs: Union[Dict[str, Any], Any]) -> Dict[str, str]:
"""Validate and prep inputs."""
if not isinstance(inputs, dict):
_input_keys = set(self.input_keys)
if self.memory is not None:
# If there are multiple input keys, but some get set by memory so that
# only one is not set, we can still figure out which key it is.
_input_keys = _input_keys.difference(self.memory.memory_variables)
if len(_input_keys) != 1:
raise ValueError(
f"A single string input was passed in, but this chain expects "
f"multiple inputs ({_input_keys}). When a chain expects "
f"multiple inputs, please call it by passing in a dictionary, "
"eg `chain({'foo': 1, 'bar': 2})`"
)
inputs = {list(_input_keys)[0]: inputs}
if self.memory is not None:
external_context = self.memory.load_memory_variables(inputs)
inputs = dict(inputs, **external_context)
self._validate_inputs(inputs)
return inputs
def apply(self, input_list: List[Dict[str, Any]]) -> List[Dict[str, str]]:
"""Call the chain on all inputs in the list."""
return [self(inputs) for inputs in input_list]
def run(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return self(args[0])[self.output_keys[0]]
if kwargs and not args:
return self(kwargs)[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
async def arun(self, *args: Any, **kwargs: Any) -> str:
"""Run the chain as text in, text out or multiple variables, text out."""
if len(self.output_keys) != 1:
raise ValueError(
f"`run` not supported when there is not exactly "
f"one output key. Got {self.output_keys}."
)
if args and not kwargs:
if len(args) != 1:
raise ValueError("`run` supports only one positional argument.")
return (await self.acall(args[0]))[self.output_keys[0]]
if kwargs and not args:
return (await self.acall(kwargs))[self.output_keys[0]]
raise ValueError(
f"`run` supported with either positional arguments or keyword arguments"
f" but not both. Got args: {args} and kwargs: {kwargs}."
)
def dict(self, **kwargs: Any) -> Dict:
"""Return dictionary representation of chain."""
if self.memory is not None:
raise ValueError("Saving of memory is not yet supported.")
_dict = super().dict()
_dict["_type"] = self._chain_type
return _dict
def save(self, file_path: Union[Path, str]) -> None:
"""Save the chain.
Args:
file_path: Path to file to save the chain to.
Example:
.. code-block:: python
chain.save(file_path="path/chain.yaml")
"""
# Convert file to Path object.
if isinstance(file_path, str):
save_path = Path(file_path)
else:
save_path = file_path
directory_path = save_path.parent
directory_path.mkdir(parents=True, exist_ok=True)
# Fetch dictionary to save
chain_dict = self.dict()
if save_path.suffix == ".json":
with open(file_path, "w") as f:
json.dump(chain_dict, f, indent=4)
elif save_path.suffix == ".yaml":
with open(file_path, "w") as f:
yaml.dump(chain_dict, f, default_flow_style=False)
else:
raise ValueError(f"{save_path} must be json or yaml")
| [
"langchain.callbacks.get_callback_manager"
] | [((646, 703), 'pydantic.Field', 'Field', ([], {'default_factory': 'get_callback_manager', 'exclude': '(True)'}), '(default_factory=get_callback_manager, exclude=True)\n', (651, 703), False, 'from pydantic import BaseModel, Field, validator\n'), ((738, 775), 'pydantic.Field', 'Field', ([], {'default_factory': '_get_verbosity'}), '(default_factory=_get_verbosity)\n', (743, 775), False, 'from pydantic import BaseModel, Field, validator\n'), ((1075, 1127), 'pydantic.validator', 'validator', (['"""callback_manager"""'], {'pre': '(True)', 'always': '(True)'}), "('callback_manager', pre=True, always=True)\n", (1084, 1127), False, 'from pydantic import BaseModel, Field, validator\n'), ((1457, 1500), 'pydantic.validator', 'validator', (['"""verbose"""'], {'pre': '(True)', 'always': '(True)'}), "('verbose', pre=True, always=True)\n", (1466, 1500), False, 'from pydantic import BaseModel, Field, validator\n'), ((1428, 1450), 'langchain.callbacks.get_callback_manager', 'get_callback_manager', ([], {}), '()\n', (1448, 1450), False, 'from langchain.callbacks import get_callback_manager\n'), ((10078, 10093), 'pathlib.Path', 'Path', (['file_path'], {}), '(file_path)\n', (10082, 10093), False, 'from pathlib import Path\n'), ((10413, 10447), 'json.dump', 'json.dump', (['chain_dict', 'f'], {'indent': '(4)'}), '(chain_dict, f, indent=4)\n', (10422, 10447), False, 'import json\n'), ((10550, 10600), 'yaml.dump', 'yaml.dump', (['chain_dict', 'f'], {'default_flow_style': '(False)'}), '(chain_dict, f, default_flow_style=False)\n', (10559, 10600), False, 'import yaml\n')] |
from typing import Dict, List, Optional
from langchain.agents.load_tools import (
_EXTRA_LLM_TOOLS,
_EXTRA_OPTIONAL_TOOLS,
_LLM_TOOLS,
)
from langflow.custom import customs
from langflow.interface.base import LangChainTypeCreator
from langflow.interface.tools.constants import (
ALL_TOOLS_NAMES,
CUSTOM_TOOLS,
FILE_TOOLS,
OTHER_TOOLS,
)
from langflow.interface.tools.util import get_tool_params
from langflow.services.utils import get_settings_manager
from langflow.template.field.base import TemplateField
from langflow.template.template.base import Template
from langflow.utils import util
from langflow.utils.util import build_template_from_class
TOOL_INPUTS = {
"str": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
placeholder="",
value="",
),
"llm": TemplateField(
field_type="BaseLanguageModel", required=True, is_list=False, show=True
),
"func": TemplateField(
field_type="function",
required=True,
is_list=False,
show=True,
multiline=True,
),
"code": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
value="",
multiline=True,
),
"path": TemplateField(
field_type="file",
required=True,
is_list=False,
show=True,
value="",
suffixes=[".json", ".yaml", ".yml"],
file_types=["json", "yaml", "yml"],
),
}
class ToolCreator(LangChainTypeCreator):
type_name: str = "tools"
tools_dict: Optional[Dict] = None
@property
def type_to_loader_dict(self) -> Dict:
settings_manager = get_settings_manager()
if self.tools_dict is None:
all_tools = {}
for tool, tool_fcn in ALL_TOOLS_NAMES.items():
tool_params = get_tool_params(tool_fcn)
tool_name = tool_params.get("name") or tool
if (
tool_name in settings_manager.settings.TOOLS
or settings_manager.settings.DEV
):
if tool_name == "JsonSpec":
tool_params["path"] = tool_params.pop("dict_") # type: ignore
all_tools[tool_name] = {
"type": tool,
"params": tool_params,
"fcn": tool_fcn,
}
self.tools_dict = all_tools
return self.tools_dict
def get_signature(self, name: str) -> Optional[Dict]:
"""Get the signature of a tool."""
base_classes = ["Tool", "BaseTool"]
fields = []
params = []
tool_params = {}
# Raise error if name is not in tools
if name not in self.type_to_loader_dict.keys():
raise ValueError("Tool not found")
tool_type: str = self.type_to_loader_dict[name]["type"] # type: ignore
# if tool_type in _BASE_TOOLS.keys():
# params = []
if tool_type in _LLM_TOOLS.keys():
params = ["llm"]
elif tool_type in _EXTRA_LLM_TOOLS.keys():
extra_keys = _EXTRA_LLM_TOOLS[tool_type][1]
params = ["llm"] + extra_keys
elif tool_type in _EXTRA_OPTIONAL_TOOLS.keys():
extra_keys = _EXTRA_OPTIONAL_TOOLS[tool_type][1]
params = extra_keys
# elif tool_type == "Tool":
# params = ["name", "description", "func"]
elif tool_type in CUSTOM_TOOLS:
# Get custom tool params
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes = ["function"]
if node := customs.get_custom_nodes("tools").get(tool_type):
return node
elif tool_type in FILE_TOOLS:
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes += [name]
elif tool_type in OTHER_TOOLS:
tool_dict = build_template_from_class(tool_type, OTHER_TOOLS)
fields = tool_dict["template"]
# Pop unnecessary fields and add name
fields.pop("_type") # type: ignore
fields.pop("return_direct") # type: ignore
fields.pop("verbose") # type: ignore
tool_params = {
"name": fields.pop("name")["value"], # type: ignore
"description": fields.pop("description")["value"], # type: ignore
}
fields = [
TemplateField(name=name, field_type=field["type"], **field)
for name, field in fields.items() # type: ignore
]
base_classes += tool_dict["base_classes"]
# Copy the field and add the name
for param in params:
field = TOOL_INPUTS.get(param, TOOL_INPUTS["str"]).copy()
field.name = param
field.advanced = False
if param == "aiosession":
field.show = False
field.required = False
fields.append(field)
template = Template(fields=fields, type_name=tool_type)
tool_params = {**tool_params, **self.type_to_loader_dict[name]["params"]}
return {
"template": util.format_dict(template.to_dict()),
**tool_params,
"base_classes": base_classes,
}
def to_list(self) -> List[str]:
"""List all load tools"""
return list(self.type_to_loader_dict.keys())
tool_creator = ToolCreator()
| [
"langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys",
"langchain.agents.load_tools._LLM_TOOLS.keys",
"langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys"
] | [((709, 811), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'placeholder': '""""""', 'value': '""""""'}), "(field_type='str', required=True, is_list=False, show=True,\n placeholder='', value='')\n", (722, 811), False, 'from langflow.template.field.base import TemplateField\n'), ((875, 965), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""BaseLanguageModel"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)'}), "(field_type='BaseLanguageModel', required=True, is_list=False,\n show=True)\n", (888, 965), False, 'from langflow.template.field.base import TemplateField\n'), ((989, 1087), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""function"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'multiline': '(True)'}), "(field_type='function', required=True, is_list=False, show=\n True, multiline=True)\n", (1002, 1087), False, 'from langflow.template.field.base import TemplateField\n'), ((1143, 1245), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'multiline': '(True)'}), "(field_type='str', required=True, is_list=False, show=True,\n value='', multiline=True)\n", (1156, 1245), False, 'from langflow.template.field.base import TemplateField\n'), ((1310, 1474), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""file"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'suffixes': "['.json', '.yaml', '.yml']", 'file_types': "['json', 'yaml', 'yml']"}), "(field_type='file', required=True, is_list=False, show=True,\n value='', suffixes=['.json', '.yaml', '.yml'], file_types=['json',\n 'yaml', 'yml'])\n", (1323, 1474), False, 'from langflow.template.field.base import TemplateField\n'), ((1728, 1750), 'langflow.services.utils.get_settings_manager', 'get_settings_manager', ([], {}), '()\n', (1748, 1750), False, 'from langflow.services.utils import get_settings_manager\n'), ((5139, 5183), 'langflow.template.template.base.Template', 'Template', ([], {'fields': 'fields', 'type_name': 'tool_type'}), '(fields=fields, type_name=tool_type)\n', (5147, 5183), False, 'from langflow.template.template.base import Template\n'), ((1849, 1872), 'langflow.interface.tools.constants.ALL_TOOLS_NAMES.items', 'ALL_TOOLS_NAMES.items', ([], {}), '()\n', (1870, 1872), False, 'from langflow.interface.tools.constants import ALL_TOOLS_NAMES, CUSTOM_TOOLS, FILE_TOOLS, OTHER_TOOLS\n'), ((3091, 3108), 'langchain.agents.load_tools._LLM_TOOLS.keys', '_LLM_TOOLS.keys', ([], {}), '()\n', (3106, 3108), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((1904, 1929), 'langflow.interface.tools.util.get_tool_params', 'get_tool_params', (['tool_fcn'], {}), '(tool_fcn)\n', (1919, 1929), False, 'from langflow.interface.tools.util import get_tool_params\n'), ((3165, 3188), 'langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys', '_EXTRA_LLM_TOOLS.keys', ([], {}), '()\n', (3186, 3188), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((3314, 3342), 'langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys', '_EXTRA_OPTIONAL_TOOLS.keys', ([], {}), '()\n', (3340, 3342), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((4038, 4087), 'langflow.utils.util.build_template_from_class', 'build_template_from_class', (['tool_type', 'OTHER_TOOLS'], {}), '(tool_type, OTHER_TOOLS)\n', (4063, 4087), False, 'from langflow.utils.util import build_template_from_class\n'), ((3746, 3779), 'langflow.custom.customs.get_custom_nodes', 'customs.get_custom_nodes', (['"""tools"""'], {}), "('tools')\n", (3770, 3779), False, 'from langflow.custom import customs\n'), ((4571, 4630), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'name': 'name', 'field_type': "field['type']"}), "(name=name, field_type=field['type'], **field)\n", (4584, 4630), False, 'from langflow.template.field.base import TemplateField\n')] |
from typing import Dict, List, Optional
from langchain.agents.load_tools import (
_EXTRA_LLM_TOOLS,
_EXTRA_OPTIONAL_TOOLS,
_LLM_TOOLS,
)
from langflow.custom import customs
from langflow.interface.base import LangChainTypeCreator
from langflow.interface.tools.constants import (
ALL_TOOLS_NAMES,
CUSTOM_TOOLS,
FILE_TOOLS,
OTHER_TOOLS,
)
from langflow.interface.tools.util import get_tool_params
from langflow.services.utils import get_settings_manager
from langflow.template.field.base import TemplateField
from langflow.template.template.base import Template
from langflow.utils import util
from langflow.utils.util import build_template_from_class
TOOL_INPUTS = {
"str": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
placeholder="",
value="",
),
"llm": TemplateField(
field_type="BaseLanguageModel", required=True, is_list=False, show=True
),
"func": TemplateField(
field_type="function",
required=True,
is_list=False,
show=True,
multiline=True,
),
"code": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
value="",
multiline=True,
),
"path": TemplateField(
field_type="file",
required=True,
is_list=False,
show=True,
value="",
suffixes=[".json", ".yaml", ".yml"],
file_types=["json", "yaml", "yml"],
),
}
class ToolCreator(LangChainTypeCreator):
type_name: str = "tools"
tools_dict: Optional[Dict] = None
@property
def type_to_loader_dict(self) -> Dict:
settings_manager = get_settings_manager()
if self.tools_dict is None:
all_tools = {}
for tool, tool_fcn in ALL_TOOLS_NAMES.items():
tool_params = get_tool_params(tool_fcn)
tool_name = tool_params.get("name") or tool
if (
tool_name in settings_manager.settings.TOOLS
or settings_manager.settings.DEV
):
if tool_name == "JsonSpec":
tool_params["path"] = tool_params.pop("dict_") # type: ignore
all_tools[tool_name] = {
"type": tool,
"params": tool_params,
"fcn": tool_fcn,
}
self.tools_dict = all_tools
return self.tools_dict
def get_signature(self, name: str) -> Optional[Dict]:
"""Get the signature of a tool."""
base_classes = ["Tool", "BaseTool"]
fields = []
params = []
tool_params = {}
# Raise error if name is not in tools
if name not in self.type_to_loader_dict.keys():
raise ValueError("Tool not found")
tool_type: str = self.type_to_loader_dict[name]["type"] # type: ignore
# if tool_type in _BASE_TOOLS.keys():
# params = []
if tool_type in _LLM_TOOLS.keys():
params = ["llm"]
elif tool_type in _EXTRA_LLM_TOOLS.keys():
extra_keys = _EXTRA_LLM_TOOLS[tool_type][1]
params = ["llm"] + extra_keys
elif tool_type in _EXTRA_OPTIONAL_TOOLS.keys():
extra_keys = _EXTRA_OPTIONAL_TOOLS[tool_type][1]
params = extra_keys
# elif tool_type == "Tool":
# params = ["name", "description", "func"]
elif tool_type in CUSTOM_TOOLS:
# Get custom tool params
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes = ["function"]
if node := customs.get_custom_nodes("tools").get(tool_type):
return node
elif tool_type in FILE_TOOLS:
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes += [name]
elif tool_type in OTHER_TOOLS:
tool_dict = build_template_from_class(tool_type, OTHER_TOOLS)
fields = tool_dict["template"]
# Pop unnecessary fields and add name
fields.pop("_type") # type: ignore
fields.pop("return_direct") # type: ignore
fields.pop("verbose") # type: ignore
tool_params = {
"name": fields.pop("name")["value"], # type: ignore
"description": fields.pop("description")["value"], # type: ignore
}
fields = [
TemplateField(name=name, field_type=field["type"], **field)
for name, field in fields.items() # type: ignore
]
base_classes += tool_dict["base_classes"]
# Copy the field and add the name
for param in params:
field = TOOL_INPUTS.get(param, TOOL_INPUTS["str"]).copy()
field.name = param
field.advanced = False
if param == "aiosession":
field.show = False
field.required = False
fields.append(field)
template = Template(fields=fields, type_name=tool_type)
tool_params = {**tool_params, **self.type_to_loader_dict[name]["params"]}
return {
"template": util.format_dict(template.to_dict()),
**tool_params,
"base_classes": base_classes,
}
def to_list(self) -> List[str]:
"""List all load tools"""
return list(self.type_to_loader_dict.keys())
tool_creator = ToolCreator()
| [
"langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys",
"langchain.agents.load_tools._LLM_TOOLS.keys",
"langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys"
] | [((709, 811), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'placeholder': '""""""', 'value': '""""""'}), "(field_type='str', required=True, is_list=False, show=True,\n placeholder='', value='')\n", (722, 811), False, 'from langflow.template.field.base import TemplateField\n'), ((875, 965), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""BaseLanguageModel"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)'}), "(field_type='BaseLanguageModel', required=True, is_list=False,\n show=True)\n", (888, 965), False, 'from langflow.template.field.base import TemplateField\n'), ((989, 1087), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""function"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'multiline': '(True)'}), "(field_type='function', required=True, is_list=False, show=\n True, multiline=True)\n", (1002, 1087), False, 'from langflow.template.field.base import TemplateField\n'), ((1143, 1245), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'multiline': '(True)'}), "(field_type='str', required=True, is_list=False, show=True,\n value='', multiline=True)\n", (1156, 1245), False, 'from langflow.template.field.base import TemplateField\n'), ((1310, 1474), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""file"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'suffixes': "['.json', '.yaml', '.yml']", 'file_types': "['json', 'yaml', 'yml']"}), "(field_type='file', required=True, is_list=False, show=True,\n value='', suffixes=['.json', '.yaml', '.yml'], file_types=['json',\n 'yaml', 'yml'])\n", (1323, 1474), False, 'from langflow.template.field.base import TemplateField\n'), ((1728, 1750), 'langflow.services.utils.get_settings_manager', 'get_settings_manager', ([], {}), '()\n', (1748, 1750), False, 'from langflow.services.utils import get_settings_manager\n'), ((5139, 5183), 'langflow.template.template.base.Template', 'Template', ([], {'fields': 'fields', 'type_name': 'tool_type'}), '(fields=fields, type_name=tool_type)\n', (5147, 5183), False, 'from langflow.template.template.base import Template\n'), ((1849, 1872), 'langflow.interface.tools.constants.ALL_TOOLS_NAMES.items', 'ALL_TOOLS_NAMES.items', ([], {}), '()\n', (1870, 1872), False, 'from langflow.interface.tools.constants import ALL_TOOLS_NAMES, CUSTOM_TOOLS, FILE_TOOLS, OTHER_TOOLS\n'), ((3091, 3108), 'langchain.agents.load_tools._LLM_TOOLS.keys', '_LLM_TOOLS.keys', ([], {}), '()\n', (3106, 3108), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((1904, 1929), 'langflow.interface.tools.util.get_tool_params', 'get_tool_params', (['tool_fcn'], {}), '(tool_fcn)\n', (1919, 1929), False, 'from langflow.interface.tools.util import get_tool_params\n'), ((3165, 3188), 'langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys', '_EXTRA_LLM_TOOLS.keys', ([], {}), '()\n', (3186, 3188), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((3314, 3342), 'langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys', '_EXTRA_OPTIONAL_TOOLS.keys', ([], {}), '()\n', (3340, 3342), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((4038, 4087), 'langflow.utils.util.build_template_from_class', 'build_template_from_class', (['tool_type', 'OTHER_TOOLS'], {}), '(tool_type, OTHER_TOOLS)\n', (4063, 4087), False, 'from langflow.utils.util import build_template_from_class\n'), ((3746, 3779), 'langflow.custom.customs.get_custom_nodes', 'customs.get_custom_nodes', (['"""tools"""'], {}), "('tools')\n", (3770, 3779), False, 'from langflow.custom import customs\n'), ((4571, 4630), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'name': 'name', 'field_type': "field['type']"}), "(name=name, field_type=field['type'], **field)\n", (4584, 4630), False, 'from langflow.template.field.base import TemplateField\n')] |
from typing import Dict, List, Optional
from langchain.agents.load_tools import (
_EXTRA_LLM_TOOLS,
_EXTRA_OPTIONAL_TOOLS,
_LLM_TOOLS,
)
from langflow.custom import customs
from langflow.interface.base import LangChainTypeCreator
from langflow.interface.tools.constants import (
ALL_TOOLS_NAMES,
CUSTOM_TOOLS,
FILE_TOOLS,
OTHER_TOOLS,
)
from langflow.interface.tools.util import get_tool_params
from langflow.services.utils import get_settings_manager
from langflow.template.field.base import TemplateField
from langflow.template.template.base import Template
from langflow.utils import util
from langflow.utils.util import build_template_from_class
TOOL_INPUTS = {
"str": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
placeholder="",
value="",
),
"llm": TemplateField(
field_type="BaseLanguageModel", required=True, is_list=False, show=True
),
"func": TemplateField(
field_type="function",
required=True,
is_list=False,
show=True,
multiline=True,
),
"code": TemplateField(
field_type="str",
required=True,
is_list=False,
show=True,
value="",
multiline=True,
),
"path": TemplateField(
field_type="file",
required=True,
is_list=False,
show=True,
value="",
suffixes=[".json", ".yaml", ".yml"],
file_types=["json", "yaml", "yml"],
),
}
class ToolCreator(LangChainTypeCreator):
type_name: str = "tools"
tools_dict: Optional[Dict] = None
@property
def type_to_loader_dict(self) -> Dict:
settings_manager = get_settings_manager()
if self.tools_dict is None:
all_tools = {}
for tool, tool_fcn in ALL_TOOLS_NAMES.items():
tool_params = get_tool_params(tool_fcn)
tool_name = tool_params.get("name") or tool
if (
tool_name in settings_manager.settings.TOOLS
or settings_manager.settings.DEV
):
if tool_name == "JsonSpec":
tool_params["path"] = tool_params.pop("dict_") # type: ignore
all_tools[tool_name] = {
"type": tool,
"params": tool_params,
"fcn": tool_fcn,
}
self.tools_dict = all_tools
return self.tools_dict
def get_signature(self, name: str) -> Optional[Dict]:
"""Get the signature of a tool."""
base_classes = ["Tool", "BaseTool"]
fields = []
params = []
tool_params = {}
# Raise error if name is not in tools
if name not in self.type_to_loader_dict.keys():
raise ValueError("Tool not found")
tool_type: str = self.type_to_loader_dict[name]["type"] # type: ignore
# if tool_type in _BASE_TOOLS.keys():
# params = []
if tool_type in _LLM_TOOLS.keys():
params = ["llm"]
elif tool_type in _EXTRA_LLM_TOOLS.keys():
extra_keys = _EXTRA_LLM_TOOLS[tool_type][1]
params = ["llm"] + extra_keys
elif tool_type in _EXTRA_OPTIONAL_TOOLS.keys():
extra_keys = _EXTRA_OPTIONAL_TOOLS[tool_type][1]
params = extra_keys
# elif tool_type == "Tool":
# params = ["name", "description", "func"]
elif tool_type in CUSTOM_TOOLS:
# Get custom tool params
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes = ["function"]
if node := customs.get_custom_nodes("tools").get(tool_type):
return node
elif tool_type in FILE_TOOLS:
params = self.type_to_loader_dict[name]["params"] # type: ignore
base_classes += [name]
elif tool_type in OTHER_TOOLS:
tool_dict = build_template_from_class(tool_type, OTHER_TOOLS)
fields = tool_dict["template"]
# Pop unnecessary fields and add name
fields.pop("_type") # type: ignore
fields.pop("return_direct") # type: ignore
fields.pop("verbose") # type: ignore
tool_params = {
"name": fields.pop("name")["value"], # type: ignore
"description": fields.pop("description")["value"], # type: ignore
}
fields = [
TemplateField(name=name, field_type=field["type"], **field)
for name, field in fields.items() # type: ignore
]
base_classes += tool_dict["base_classes"]
# Copy the field and add the name
for param in params:
field = TOOL_INPUTS.get(param, TOOL_INPUTS["str"]).copy()
field.name = param
field.advanced = False
if param == "aiosession":
field.show = False
field.required = False
fields.append(field)
template = Template(fields=fields, type_name=tool_type)
tool_params = {**tool_params, **self.type_to_loader_dict[name]["params"]}
return {
"template": util.format_dict(template.to_dict()),
**tool_params,
"base_classes": base_classes,
}
def to_list(self) -> List[str]:
"""List all load tools"""
return list(self.type_to_loader_dict.keys())
tool_creator = ToolCreator()
| [
"langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys",
"langchain.agents.load_tools._LLM_TOOLS.keys",
"langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys"
] | [((709, 811), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'placeholder': '""""""', 'value': '""""""'}), "(field_type='str', required=True, is_list=False, show=True,\n placeholder='', value='')\n", (722, 811), False, 'from langflow.template.field.base import TemplateField\n'), ((875, 965), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""BaseLanguageModel"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)'}), "(field_type='BaseLanguageModel', required=True, is_list=False,\n show=True)\n", (888, 965), False, 'from langflow.template.field.base import TemplateField\n'), ((989, 1087), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""function"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'multiline': '(True)'}), "(field_type='function', required=True, is_list=False, show=\n True, multiline=True)\n", (1002, 1087), False, 'from langflow.template.field.base import TemplateField\n'), ((1143, 1245), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""str"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'multiline': '(True)'}), "(field_type='str', required=True, is_list=False, show=True,\n value='', multiline=True)\n", (1156, 1245), False, 'from langflow.template.field.base import TemplateField\n'), ((1310, 1474), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'field_type': '"""file"""', 'required': '(True)', 'is_list': '(False)', 'show': '(True)', 'value': '""""""', 'suffixes': "['.json', '.yaml', '.yml']", 'file_types': "['json', 'yaml', 'yml']"}), "(field_type='file', required=True, is_list=False, show=True,\n value='', suffixes=['.json', '.yaml', '.yml'], file_types=['json',\n 'yaml', 'yml'])\n", (1323, 1474), False, 'from langflow.template.field.base import TemplateField\n'), ((1728, 1750), 'langflow.services.utils.get_settings_manager', 'get_settings_manager', ([], {}), '()\n', (1748, 1750), False, 'from langflow.services.utils import get_settings_manager\n'), ((5139, 5183), 'langflow.template.template.base.Template', 'Template', ([], {'fields': 'fields', 'type_name': 'tool_type'}), '(fields=fields, type_name=tool_type)\n', (5147, 5183), False, 'from langflow.template.template.base import Template\n'), ((1849, 1872), 'langflow.interface.tools.constants.ALL_TOOLS_NAMES.items', 'ALL_TOOLS_NAMES.items', ([], {}), '()\n', (1870, 1872), False, 'from langflow.interface.tools.constants import ALL_TOOLS_NAMES, CUSTOM_TOOLS, FILE_TOOLS, OTHER_TOOLS\n'), ((3091, 3108), 'langchain.agents.load_tools._LLM_TOOLS.keys', '_LLM_TOOLS.keys', ([], {}), '()\n', (3106, 3108), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((1904, 1929), 'langflow.interface.tools.util.get_tool_params', 'get_tool_params', (['tool_fcn'], {}), '(tool_fcn)\n', (1919, 1929), False, 'from langflow.interface.tools.util import get_tool_params\n'), ((3165, 3188), 'langchain.agents.load_tools._EXTRA_LLM_TOOLS.keys', '_EXTRA_LLM_TOOLS.keys', ([], {}), '()\n', (3186, 3188), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((3314, 3342), 'langchain.agents.load_tools._EXTRA_OPTIONAL_TOOLS.keys', '_EXTRA_OPTIONAL_TOOLS.keys', ([], {}), '()\n', (3340, 3342), False, 'from langchain.agents.load_tools import _EXTRA_LLM_TOOLS, _EXTRA_OPTIONAL_TOOLS, _LLM_TOOLS\n'), ((4038, 4087), 'langflow.utils.util.build_template_from_class', 'build_template_from_class', (['tool_type', 'OTHER_TOOLS'], {}), '(tool_type, OTHER_TOOLS)\n', (4063, 4087), False, 'from langflow.utils.util import build_template_from_class\n'), ((3746, 3779), 'langflow.custom.customs.get_custom_nodes', 'customs.get_custom_nodes', (['"""tools"""'], {}), "('tools')\n", (3770, 3779), False, 'from langflow.custom import customs\n'), ((4571, 4630), 'langflow.template.field.base.TemplateField', 'TemplateField', ([], {'name': 'name', 'field_type': "field['type']"}), "(name=name, field_type=field['type'], **field)\n", (4584, 4630), False, 'from langflow.template.field.base import TemplateField\n')] |
import langchain_visualizer # isort:skip # noqa: F401
import asyncio
import vcr_langchain as vcr
from fvalues import FValue
from langchain import PromptTemplate
from langchain.llms import OpenAI
# ========================== Start of langchain example code ==========================
# https://langchain.readthedocs.io/en/latest/modules/prompts/getting_started.html
# An example prompt with one input variable
one_input_prompt = PromptTemplate(
input_variables=["adjective"], template="Tell me a {adjective} joke."
)
prompt = one_input_prompt.format(adjective="funny")
# ================================== Execute example ==================================
def test_prompt():
assert prompt.parts == (
"Tell me a ",
FValue(source="adjective", value="funny", formatted="funny"),
" joke.",
)
@vcr.use_cassette()
async def one_input_prompt_demo():
agent = OpenAI(model_name="text-ada-001", temperature=0)
return agent(prompt)
def test_llm_usage_succeeds():
"""
Check that it works like a regular prompt.
Also, record playback for easy visualization.
"""
result = asyncio.get_event_loop().run_until_complete(one_input_prompt_demo())
assert result.strip().startswith("Why did the chicken cross the road?")
if __name__ == "__main__":
from langchain_visualizer import visualize
visualize(one_input_prompt_demo)
| [
"langchain_visualizer.visualize",
"langchain.llms.OpenAI",
"langchain.PromptTemplate"
] | [((434, 524), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['adjective']", 'template': '"""Tell me a {adjective} joke."""'}), "(input_variables=['adjective'], template=\n 'Tell me a {adjective} joke.')\n", (448, 524), False, 'from langchain import PromptTemplate\n'), ((837, 855), 'vcr_langchain.use_cassette', 'vcr.use_cassette', ([], {}), '()\n', (853, 855), True, 'import vcr_langchain as vcr\n'), ((903, 951), 'langchain.llms.OpenAI', 'OpenAI', ([], {'model_name': '"""text-ada-001"""', 'temperature': '(0)'}), "(model_name='text-ada-001', temperature=0)\n", (909, 951), False, 'from langchain.llms import OpenAI\n'), ((1362, 1394), 'langchain_visualizer.visualize', 'visualize', (['one_input_prompt_demo'], {}), '(one_input_prompt_demo)\n', (1371, 1394), False, 'from langchain_visualizer import visualize\n'), ((748, 808), 'fvalues.FValue', 'FValue', ([], {'source': '"""adjective"""', 'value': '"""funny"""', 'formatted': '"""funny"""'}), "(source='adjective', value='funny', formatted='funny')\n", (754, 808), False, 'from fvalues import FValue\n'), ((1136, 1160), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (1158, 1160), False, 'import asyncio\n')] |
# coding=utf-8
import json
import hashlib
from datetime import datetime
import os
import time
import openai
import flet as ft
import re
import shutil
from flet import (
ElevatedButton,
FilePicker,
FilePickerResultEvent,
Page,
Row,
Text,
icons,
)
from prompt_engineering import *
import codecs
# 赋值固定的api_key
# 测试用
openai.api_key = None
openai.api_key = read_APIKEY()
'''
每一行对话的类
在调用的同时，会将数据存入聊天记录文件
'''
class chat_row(ft.UserControl):
def __init__(self, role, content):
super(chat_row, self).__init__()
self.role = role
self.content = content
self.hash = save_now_chat(
chat_json_path=chat_json_path,
role=self.role,
content=self.content)
def build(self):
self.role_dropdown = ft.Dropdown(
value=self.role,
width=150,
options=[
ft.dropdown.Option("system"),
ft.dropdown.Option("user"),
ft.dropdown.Option("assistant"),
],
on_change=self.role_change
)
self.content_textfield = ft.TextField(
label="消息内容",
value=self.content,
filled=True,
expand=True,
multiline=True,
on_change=self.content_change
)
self.generalize_btn = ft.ElevatedButton(
'概括本消息',
on_click=self.sum_change
)
self.sum_field = ft.TextField (
visible=False,
label="概括内容",
value='概括中',
filled=True,
expand=True,
multiline=True,
# on_change=self.content_change
)
self.one_chat_row = ft.Row (
[
self.role_dropdown,
self.content_textfield,
self.generalize_btn,
self.sum_field,
]
)
return self.one_chat_row
def sum_change(self,e):
self.generalize_btn.disabled = True
self.update()
self.one_chat_row.controls.append(self.sum_field)
self.update()
self.summary = chatGPT_sum(self.content)
renew_now_chat (
chat_json_path=chat_json_path,
hash_val=self.hash,
summary=self.summary )
self.sum_field.visible = True
self.sum_field.value = self.summary
self.generalize_btn.disabled = False
self.update ()
return self.one_chat_row
def role_change(self, e):
self.role = self.role_dropdown.value
renew_now_chat(
chat_json_path=chat_json_path,
hash_val=self.hash,
role=self.role)
def content_change(self, e):
self.content = self.content_textfield.value
renew_now_chat(
chat_json_path=chat_json_path,
hash_val=self.hash,
content=self.content)
'''
调用chatGPT获取关键词和概括的函数
'''
# 文本切块成
def split_text(text, divide_length):
return [text[i:i+divide_length] for i in range(0, len(text), divide_length)]
# 获取概括文本
def chatGPT_sum_old(content):
divided_content = split_text(content,divide_length=1000)
chain_summary = []
for single_content in divided_content:
composition_analysis_message = [{"role" : "user",
"content" : f'''为以下文本创建概括:
{content}
概括内容:'''}]
chatGPT_raw_response = openai.ChatCompletion.create (
model="gpt-3.5-turbo",
messages=composition_analysis_message
)
summary = decode_chr ( chatGPT_raw_response.choices[0].message['content'].strip () )
chain_summary.append(summary)
print(summary)
chain_summary_long = '\n'.join ( chain_summary )
return chain_summary_long
def chatGPT_sum(content,chain_type='map_reduce'):
try:
# 试图用langchain但无法打包
import langchain
from langchain.llms import OpenAI
from langchain.chains.summarize import load_summarize_chain
from langchain.chains import AnalyzeDocumentChain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import UnstructuredFileLoader
from langchain.docstore.document import Document
from langchain.prompts import PromptTemplate
'''
准备步骤
'''
# 创建文本分块器，每块长度为1000
text_splitter = RecursiveCharacterTextSplitter ( chunk_size=1000, chunk_overlap=0 )
# 创建大语言模型，将温度拉到最低以提高精确性
llm = OpenAI ( temperature=0, openai_api_key=openai.api_key )
'''
加载需要概括的内容
'''
# 加载外部文件
# loader = UnstructuredFileLoader ( 'game_log_conversation.txt' )
# docs = loader.load ()
# split_docs = text_splitter.split_documents(docs)
# 加载函数输入的字符串
split_content = text_splitter.split_text ( content )
split_docs = [Document ( page_content=t ) for t in split_content]
'''
总结文本
'''
# 创建prompt模板
prompt_template = """为以下文本创建概括:
{text}
概括内容:"""
PROMPT = PromptTemplate ( template=prompt_template, input_variables=["text"] )
# 创建总结链，模式为map_reduce
# 第一种
# 有模板的总结链
summary_chain = load_summarize_chain ( llm, chain_type="map_reduce", return_intermediate_steps=True,
map_prompt=PROMPT, combine_prompt=PROMPT ,verbose=True)
# 带参数带模板总结
chain_summary = summary_chain (
{"input_documents" : split_docs},
# return_only_outputs=True,
)
# 第二种
# 无模板的总结链
# summary_chain = load_summarize_chain ( llm, chain_type=chain_type, verbose=True )
# 直接总结
# chain_summary = summary_chain.run ( split_docs )
chain_summary_long = '\n'.join(chain_summary['intermediate_steps'])
return chain_summary_long
except Exception as error:
print(error)
return chatGPT_sum_old(content)
# 获取关键词（还是用jieba吧）
def chatGPT_getkeyword(content):
chatGPT_raw_response = openai.Completion.create (
model="text-ada-001",
prompt=f"你要总结这一文本的关键词，并以python列表的形式返回数个关键词字符串:{content}。",
temperature=0
)
keyword = decode_chr ( chatGPT_raw_response.choices[0]['text'].strip () )
print(keyword)
return keyword
# 获取关键词（还是用jieba吧）
def chatGPT_getsummary(content):
chatGPT_raw_response = openai.Completion.create (
model="text-ada-001",
prompt=f"你要在10字以内概括这段文本:{content}。",
temperature=0
)
keyword = decode_chr ( chatGPT_raw_response.choices[0]['text'].strip () )
print(keyword)
return keyword
'''
读写chatlog的相关函数
'''
# 创建chat数据记录的方法，将聊天数据结构基于 JSON 文件进行存储
def create_chat_json(save_path='./chatlog'):
# 如果保存目录不存在，则创建目录
if not os.path.exists(save_path):
os.makedirs(save_path)
# 获取当前时间并格式化为文件名格式
now = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
chat_json_name = f"chat_{now}.json"
# 如果文件不存在，则创建文件
chat_json_path = os.path.join(save_path, chat_json_name)
if not os.path.exists(chat_json_path):
with open(chat_json_path, 'w') as f:
json.dump([], f, default=str)
return chat_json_path
# 储存现有的每一句聊天信息
def save_now_chat(chat_json_path: str, role: str, content: str) -> str:
'''
将每一段聊天信息储存到一个 JSON 文件中。以哈希值作为唯一标识符
:param chat_json_path: 聊天文件的路径
:param role: 发言者
:param content: 发言内容
:return hash_val: 哈希值
'''
now = datetime.now().timestamp()
str_to_hash = str(now) + role + content
hash_obj = hashlib.blake2b(str_to_hash.encode('utf-8'), digest_size=8)
hash_val = hash_obj.hexdigest()
# 读取之前的内容
try:
with open(chat_json_path, 'r') as f:
chats = json.load(f)
except FileNotFoundError:
chats = []
# 添加新的聊天信息
message = {
'role': role,
'content': content,
'keyword': [],
'summary': ''
}
chats.append({
'chat_seq': len(chats) + 1,
'hash': hash_val,
'created_time': now,
'altered_time': None,
'message': message
})
# 将新的聊天信息写入文件
with open(chat_json_path, 'w') as f:
json.dump(chats, f, default=str,indent=4)
return hash_val
# 根据聊天信息的哈希值，更新现有历史聊天列表
def renew_now_chat(chat_json_path: str, hash_val: str,
role: str = None, content: str = None , summary=None) -> None:
'''
根据聊天信息的哈希值，更新现有历史聊天列表
:param chat_json_path: 聊天文件的路径
:param hash_val: 聊天信息的哈希值
:param role: 更新后的发言者（可选）
:param content: 更新后的发言内容（可选）
:return: None
'''
# 读取chat_renew_data.json文件
with open(chat_json_path, 'r') as f:
data = json.load(f)
# 找出哈希值相同的键值对，并更新它们的role和content
for chat_item in data:
if hash_val == chat_item['hash']:
if role:
chat_item['message']['role'] = role
if content:
chat_item['message']['content'] = content
if summary :
chat_item['message']['summary'] = summary
chat_item["altered_time"] = datetime.now().timestamp()
break
# 将更新后的数据写回文件
with open(chat_json_path, 'w') as f:
json.dump(data, f, default=str,indent=4)
# 根据聊天信息的哈希值，获取单个键值对内的role和content
def get_one_role_and_content(
chat_json_path: str, hash_value: str) -> (str, str):
'''
根据聊天信息的哈希值，获取单个键值对内的role和content
:param chat_json_path: 聊天文件的路径
:param hash_value: 聊天信息的哈希值
:return: (发言者, 发言内容)
'''
with open(chat_json_path) as f:
data = json.load(f)
for chat_item in data:
for message in chat_item['message']:
if hash_value == hashlib.blake2b(
str(message["created_time"] +
message["role"] +
message["content"]).encode('utf-8'),
digest_size=8).hexdigest():
return message["role"], message["content"]
return None
# 读取特定文件内的所有role和content
def get_combined_data(chat_json_path: str) -> list[dict[str, str]]:
'''
获取特定文件内的所有role和content
:param chat_json_path: JSON 聊天文件的路径
:return: 包含所有发言者和发言内容（若有概括则返回概括）的列表
'''
with open(chat_json_path) as f:
data = json.load(f)
result = []
for chat_item in data:
if chat_item['message']['summary'] != '':
result.append({
"role": chat_item['message']["role"],
"content": chat_item['message']["summary"]
})
else:
result.append({
"role": chat_item['message']["role"],
"content": chat_item['message']["content"]
})
return result
# 概括chatlog
def summarize_chatlog(chatlog_json_path) :
with open ( chatlog_json_path, 'r' ) as f :
chatlog = json.load ( f )
for message in chatlog :
if 'summary' not in message or not message['summary'] :
content = message['message']['content'] # assuming content is always the second item in the message list
if len ( content ) > 100 :
summary = chatGPT_sum ( content )
message['summary'] = summary
with open ( chatlog_json_path, 'w' ) as f :
json.dump ( chatlog, f ,indent=4)
# 概括chatlog
def summarize_chatlog(chatlog_json_path) :
with open ( chatlog_json_path, 'r' ) as f :
chatlog = json.load ( f )
for message in chatlog :
if 'summary' not in message or not message['summary'] :
content = message['message']['content'] # assuming content is always the second item in the message list
if len ( content ) > 100 :
summary = chatGPT_sum ( content )
message['summary'] = summary
with open ( chatlog_json_path, 'w' ) as f :
json.dump ( chatlog, f ,indent=4)
# 获取chatlog关键词
def get_chatlog_keyword(chatlog_json_path) :
with open ( chatlog_json_path, 'r' ) as f :
chatlog = json.load ( f )
for message in chatlog :
if 'keyword' not in message or not message['keyword'] :
content = message['message']['content'] # assuming content is always the second item in the message list
keywords = chatGPT_getkeyword ( content )
message['keyword'] = keywords
with open ( chatlog_json_path, 'w' ) as f :
json.dump ( chatlog, f,indent=4 )
# 创建chat数据记录
chat_json_path = create_chat_json()
'''
加工message方法，先对向chatGPT发送的请求进行处理
'''
def process_message() :
pass
def cut_message(message) :
'''
剪切接收到的message，如果超过4000token长度就从最早的消息开始剪切，剪切到小于4000token为止
:param message:
:return:
'''
total_length = 0
# Iterate over contents in the list
for message_dict in message :
# message_dict['content'] = message_dict['content']
# 计算content长度
if message_dict['content'].isalpha () :
length = len ( message_dict['content'].split () )
else :
length = len ( message_dict['content'] )
total_length += length
while total_length > 4000:
if not message:raise Exception('最后一条消息长度大于4000字符了，请编辑消息或重置对话')
removed_content = message.pop(0)
removed_length = len ( removed_content['content'] )
if removed_content['content'].isalpha () :
removed_length = len ( removed_content['content'].split () )
total_length -= removed_length
return message
'''
读写API-KEY的函数
'''
# 定义 write_APIKEY 函数
def write_APIKEY(APIKEY=None):
# 以追加模式打开或创建 APIKEY.txt 文件
with open("APIKEY.txt", "a") as f:
# 写入字符串并换行
if APIKEY:
f.write(APIKEY.strip() + "\n")
# 定义 read_APIKEY 函数
def read_APIKEY():
# 以读取模式打开 APIKEY.txt 文件
with open("APIKEY.txt", "r") as f:
# 读取所有行并存入列表
lines = f.readlines()
# 如果列表不为空，返回最后一行的值，去掉换行符
if lines:
return lines[-1].strip()
'''
读写settings.txt的函数
'''
# 读取settings.txt文件的设置项值，并返回一个字典
def read_settings():
"""
读取settings.txt文件，如果该文件不存在，则创建一个空白的文件
然后读取所有行，每行格式为：设置项名称 = 设置项的具体值
将每行拆分为键值对，添加到字典中，并返回该字典
:return: 包含settings.txt内的所有行的键值对形式的字典
"""
settings_dict = {}
try:
with open('settings.txt', 'r', encoding='utf-8') as file:
for line in file:
line = line.strip()
if line:
key, value = line.split('=', maxsplit=1)
settings_dict[key.strip()] = value.strip()
except FileNotFoundError:
with open('settings.txt', 'w', encoding='utf-8') as file:
pass # 如果文件不存在，则创建一个空白的txt文件，不需要做任何操作
return settings_dict
# 将字典中的多个键值对写入/修改settings.txt文件的设置项值
def write_settings(settings):
"""
将多个键值对写入/更新settings.txt文件
如果文件不存在则创建一个空的文件
:param settings: 包含键值对的字典
"""
with open('settings.txt', 'r+') as f:
lines = f.readlines()
f.seek(0)
for key, value in settings.items():
for i, line in enumerate(lines):
if key in line:
lines[i] = key + ' = ' + value + '\n'
break
else:
f.write(key + ' = ' + value + '\n')
f.writelines(lines)
'''
读写字体文件的函数（适用于windows）
'''
def replace_font_file(path):
old_path = os.path.join(".", "asset", "font.ttf")
try:
os.remove(old_path)
except OSError:
pass
try:
shutil.copy(path, 'assets/font.ttf')
except FileNotFoundError:
with open('assets/font.ttf','a'):
pass
shutil.copy(path, 'assets/font.ttf')
print("替换成功！")
'''
其他函数
'''
# 字符转码
def decode_chr(s):
s = s.replace('\\\\','\\')
pattern = re.compile(r'(\\u[0-9a-fA-F]{4}|\n)')
result = ''
pos = 0
while True:
match = pattern.search(s, pos)
if match is None:
break
result += s[pos:match.start()]
if match.group() == '\n':
result += '\n'
else:
result += chr(int(match.group()[2:], 16))
pos = match.end()
result += s[pos:]
return result
def convert_content_to_unicode(txt_path):
# 读取txt文件，转换为Python列表
with open(txt_path, 'r', encoding='utf-8') as f:
txt_data = f.read()
data = json.loads(txt_data)
# 转换content内容为Unicode编码
for item in data:
content = item["message"]["content"]
item["message"]["content"] = content.encode('unicode_escape').decode()
# item["message"]["content"] = item["message"]["content"].replace('\\u',r'\u')
# 将Python列表转换为json格式字符串
json_data = json.dumps(data, ensure_ascii=False)
# 保存json文件到cache文件夹
if not os.path.exists("./cache"):
os.makedirs("./cache") # 创建cache文件夹
json_path = f"./cache/{os.path.basename(txt_path)[:-4]}.json"
with open(json_path, 'w', encoding='utf-8') as f:
f.write(json_data)
return json_path
# markdown检测
def markdown_check(gpt_msg):
pass
'''
程序主窗体
'''
def ft_interface(page: ft.Page):
# 设置字体与主题
page.title = 'BillyGPT'
page.fonts = {'A75方正像素12': './assets/font.ttf'}
page.theme = ft.Theme(font_family='A75方正像素12')
page.dark_theme = page.theme
# 设置主页面聊天区域的滚动列表
chat_area = ft.ListView(
expand=True,
spacing=10,
auto_scroll=True,
padding=20)
'''
添加选择上传文件、保存文件、打开文件夹按钮
'''
# 导入聊天记录
def import_chatlog(e: FilePickerResultEvent):
try:
clear_page()
selected_file = (
", ".join(map(lambda f: f.path, e.files)
) if e.files else "Cancelled!"
)
if selected_file[-4:] == 'json':
full_chatlog = get_combined_data(selected_file)
print(full_chatlog)
for chat_row_content in full_chatlog:
role = chat_row_content['role']
content = chat_row_content['content']
chat_area.controls.append(chat_row(role, content))
page.update()
elif selected_file[-4:] == '.txt':
json_path = convert_content_to_unicode(selected_file)
full_chatlog = get_combined_data(json_path)
for chat_row_content in full_chatlog:
role = decode_chr(chat_row_content['role'])
content = decode_chr(chat_row_content['content'])
chat_area.controls.append(chat_row(role, content))
page.update()
except Exception as e:
chat_area.controls.append(
Text(f'出现如下报错\n{e}\n请检查导入的聊天记录是否正确，或联系开发者微信B1lli_official'))
page.update()
import_chatlog_dialog = FilePicker(on_result=import_chatlog)
# 导出聊天记录
def save_file_result(e: FilePickerResultEvent):
save_file_path.value = e.path if e.path else "Cancelled!"
if save_file_path.value != "Cancelled!":
shutil.copy(chat_json_path, save_file_path.value)
path = save_file_path.value
with open ( path, 'r', encoding='utf-8' ) as f :
content = f.read ()
processed_content = decode_chr ( content )
with open ( path, 'w', encoding='utf-8' ) as f :
f.write ( processed_content )
save_file_dialog = FilePicker(on_result=save_file_result)
save_file_path = Text()
# 打开文件夹（还没做）
def get_directory_result(e: FilePickerResultEvent):
directory_path.value = e.path if e.path else "Cancelled!"
directory_path.update()
get_directory_dialog = FilePicker(on_result=get_directory_result)
directory_path = Text()
# 隐藏所有
page.overlay.extend(
[import_chatlog_dialog, save_file_dialog, get_directory_dialog])
'''
添加改变字体按钮
并调用改变字体方法
'''
def change_font_clicked(e: FilePickerResultEvent):
selected_file = (
", ".join ( map ( lambda f : f.path, e.files )
) if e.files else "Cancelled!"
)
replace_font_file(selected_file)
'''
添加设置对话和按钮
'''
def save_settings(e):
settings_dlg.open = False
write_APIKEY(apikey_field.value)
openai.api_key = read_APIKEY()
page.update()
def cancel_settings(e):
settings_dlg.open = False
page.update()
change_font_dialog = FilePicker(on_result=change_font_clicked)
page.overlay.extend([change_font_dialog])
apikey_field = ft.TextField(hint_text='在此输入apikey',)
my_wechat = ft.Text('如有任何bug请联系我：B1lli_official',size=15)
github_page_btn = ft.ElevatedButton(
'打开本项目的GitHub页面',
tooltip='如果你给这个项目点了star，你就是忠实用户了，请打开本页面后进入项目群！',
on_click=lambda _:page.launch_url('https://github.com/createrX12/BillyGPT')
)
change_font_btn = ft.ElevatedButton(
'选择新的字体文件',
on_click=lambda _:change_font_dialog.pick_files(
allowed_extensions=['ttf'],
allow_multiple=False,
dialog_title='选择字体文件导入',
)
)
settings_dlg = ft.AlertDialog(
title=ft.Text("Settings"),
content=ft.Column(
[apikey_field,my_wechat,github_page_btn,change_font_btn],
height=200,
),
actions=[
ft.TextButton("保存", on_click=save_settings),
ft.TextButton("取消", on_click=cancel_settings)
],
actions_alignment=ft.MainAxisAlignment.END,
shape=ft.RoundedRectangleBorder(radius=10)
)
def open_dlg_modal(e):
page.dialog = settings_dlg
settings_dlg.open = True
page.update()
settings_btn = ft.IconButton(
icon=ft.icons.SETTINGS_OUTLINED,
icon_color="#9ecaff",
bgcolor='#202429',
icon_size=20,
tooltip="Settings",
on_click=open_dlg_modal,
)
'''
添加启动应用程序获取apikey窗口
'''
def save_settings_open(e):
write_APIKEY(apikey_field_open.value)
openai.api_key = read_APIKEY()
open_setting_apikey_dlg.open = False
page.update()
get_apikey_btn = ft.ElevatedButton(
'从openAI获取apikey',
on_click=lambda _:page.launch_url('https://platform.openai.com/account/api-keys')
)
write_APIKEY()
openai.api_key = read_APIKEY()
if not openai.api_key:
apikey_field_open = ft.TextField(label="输入你的apikey")
open_setting_apikey_dlg = ft.AlertDialog(
open=True,
modal=True,
title=ft.Text("欢迎使用BillyGPT"),
content=ft.Column(
[apikey_field_open,get_apikey_btn],
tight=True),
actions=[
ft.ElevatedButton(
text="开始使用",
on_click=save_settings_open)],
actions_alignment="end",
)
page.dialog = open_setting_apikey_dlg
openai.api_key = read_APIKEY()
'''
添加聊天行
'''
def add_msg(e):
chatPO_btn.disabled = True
chat_area.controls.append(chat_row('user', chat_text.value))
chat_text.value = ""
page.update()
chat_area.controls.append(
chat_row(
'assistant', chatGPT()))
page.update()
def add_msg_composition(e):
chatPO_btn.disabled = True
chat_area.controls.append(chat_row('user', chat_text.value))
chat_area.controls.append(
chat_row(
'assistant',
chatGPT_PO(
chat_text.value)))
page.update()
'''
添加ctrl+enter发送消息方法
'''
def on_keyboard(e: ft.KeyboardEvent) :
if e.ctrl:
if e.key == 'Enter':
add_msg(e)
page.on_keyboard_event = on_keyboard
'''
添加模板选择功能
可以读取模板文件，实时搜索，选择时可以切换身份
'''
class DropdownSearchBar(ft.UserControl):
def __init__(self):
super(DropdownSearchBar, self).__init__()
self.item_number = ft.Text(size=9,italic=True)
def dropdown_search(self):
_object_ = ft.Container(
width=450,
height=50,
bgcolor="white10",
border_radius=6,
padding=ft.padding.only(top=15),
clip_behavior=ft.ClipBehavior.HARD_EDGE,
animate=ft.animation.Animation(400,"decelerate"),
content=ft.Column(
horizontal_alignment=ft.CrossAxisAlignment.CENTER,
alignment=ft.MainAxisAlignment.START,
controls=[
Row(
spacing=10,
vertical_alignment=ft.CrossAxisAlignment.CENTER,
controls=[
ft.Icon(
ft.icons.SEARCH_ROUNDED,
size=15,
opacity=0.90,
),
ft.TextField(
border_color='transparent',
height=20,
text_size=12,
content_padding=2,
cursor_color='black',
cursor_width=1,
hint_text='搜索模板',
on_change=None
),
self.item_number,
],
),
ft.Column(
scroll='auto',
expand=True
)
]
)
)
return _object_
def build(self):
return ft.Container()
page.add(DropdownSearchBar())
# def template_change(self, e):
# template_name = template_dropbox.value
# renew_now_chat(
# chat_json_path=chat_json_path,
# hash_val=self.hash,
# role=self.role)
#
#
# template_dropbox = ft.Dropdown(
# value=role,
# width=150,
# options=[
# ft.dropdown.Option("system"),
# ft.dropdown.Option("user"),
# ft.dropdown.Option("assistant"),
# ],
# on_change=template_change
# )
'''
设置布局 添加控件
'''
# 模板选择下拉框
page.add(
Row(
[
ElevatedButton (
"清空聊天日志",
icon=icons.CLEANING_SERVICES,
on_click=lambda _ : clear_page(),
),
ElevatedButton(
"导入聊天日志",
icon=icons.FILE_DOWNLOAD_OUTLINED,
on_click=lambda _: import_chatlog_dialog.pick_files(
allowed_extensions=['json','txt'],
allow_multiple=False,
dialog_title='选择聊天记录文件导入',
initial_directory='./chatlog'
),
),
ElevatedButton(
"导出聊天日志",
icon=icons.FILE_UPLOAD_OUTLINED,
on_click=lambda _: save_file_dialog.save_file(
file_name=f"chat_{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.txt",
# file_type=ft.FilePickerFileType.CUSTOM
),
disabled=page.web,
),
settings_btn
],
alignment=ft.MainAxisAlignment.END,
),
)
page.add(chat_area)
chat_text = ft.TextField(
hint_text="想和chatGPT说些什么？",
filled=True,
expand=True,
multiline=True)
chat_btn = ft.ElevatedButton("对话", on_click=add_msg, tooltip='随便聊聊')
chatPO_btn = ft.ElevatedButton(
"思维链优化对话",
on_click=add_msg_composition,
tooltip='认真提问\n仅在对话开始时可用'
)
view = ft.Column(
controls=[
ft.Row(
controls=[
chat_text,
chat_btn,
chatPO_btn
]
),
],
)
page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
page.add(view)
'''
添加清空页面方法
'''
def clear_page():
global chat_json_path
chat_area.controls.clear ()
page.update()
chat_json_path = create_chat_json()
chatPO_btn.disabled = False
'''
聊天方法，向api发送请求
'''
def chatGPT(message=None):
try:
# global role_template
if not message: message = get_combined_data(chat_json_path)
# message = get_combined_data ( chat_json_path )
chatGPT_raw_response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=message
)
# if role_template:pass
chatGPT_response = decode_chr(
chatGPT_raw_response.choices[0].message['content'])
return chatGPT_response.strip()
except openai.error.AuthenticationError as error:
chat_area.controls.append(
ft.Text(f'出现如下报错\n{str(error)}\n请在设置中更新可用的apikey'))
page.update()
except openai.error.InvalidRequestError as error:
chat_area.controls.append(
ft.Text(f'出现如下报错\n{str(error)}\n聊天上下文过长，请对长文本调用概括模块概括后重试'))
page.update()
# summarize_chatlog(chat_json_path)
# chat_area.controls.append(
# ft.Text(f'概括完毕，已发送概括后消息'))
# page.update()
# message = cut_message ( get_combined_data ( chat_json_path ) )
# chatGPT_raw_response = openai.ChatCompletion.create(
# model="gpt-3.5-turbo",
# messages=message
# )
# chatGPT_response = decode_chr(
# chatGPT_raw_response.choices[0].message['content'])
# return chatGPT_response.strip()
except Exception as error:
print(openai.api_key)
chat_area.controls.append(
ft.Text(f'出现如下报错\n{str ( error )}\n请联系开发者微信B1lli_official'))
page.update()
def chatGPT_PO(initial_prompt=None):
'''
PO:Prompt Optimization
该方法是提示优化方法，工作原理如下：
它会尝试判定用户输入的每一条提示，并进行类别判断。
如果判断是问题或者要求，它会分析该类型提示一般需要哪些信息
对于缺少细节信息的提示，它会向用户提问具体细节
:param initial_prompt:初始prompt
:return chatGPT_response.strip():基于提示工程思维链优化后的chatGPT方法
'''
try:
initial_prompt = chat_text.value
chat_text.value = ''
page.update()
chat_area.controls.append(
ft.Text(f'正在分析提示词组成结构，请耐心等待', color='#1cc9a0'))
page.update()
composition_analysis_message = prompt_composition_analysis(
initial_prompt)
chat_area.controls.append(
ft.Text(f'提示词组成结构分析完毕，正在根据组成结构逐步生成详细结果，耗时较长，请耐心等待', color='#1cc9a0'))
page.update()
chatGPT_raw_response = composition_stepped_reply(
composition_analysis_message)
chatGPT_response = decode_chr(
chatGPT_raw_response.choices[0].message['content'])
return chatGPT_response.strip()
except openai.error.AuthenticationError as error:
chat_area.controls.append(
ft.Text(f'出现如下报错\n{str(error)}\n请在设置中更新可用的apikey'))
page.update()
except Exception as error:
print(openai.api_key)
chat_area.controls.append(
ft.Text(f'出现如下报错\n{str ( error )}\n请联系开发者微信B1lli_official'))
page.update()
'''
版本信息
'''
ver_text = ft.Text('BillyGPT V5.3.1 By B1lli', size=10)
page.add(ver_text)
if __name__ == '__main__':
# 在客户端运行
ft.app(target=ft_interface, assets_dir='assets')
# 在内网运行
# ft.app ( port=8550, target=ft_interface, view=ft.WEB_BROWSER ,assets_dir='assets')
content = '''接下来你看到的是一个文字冒险游戏的剧情，你是剧情的女主角，名为钰鹤，下面是以对话形式展现出的剧情，你需要做出合理的判断，并说明原因：?？?：马路上的那个人怎么没撑伞
被雨淋湿的青年：
?？?：（他的样子好像有点奇怪···
?？?：睫··车开过来了那个人却没有发现.....！?
?？?：再这样下去，他会被车撞到！？
?？?：危险………！
???：(我为什么在这里
???：只记得自已跳入车道，之后的事完全没印象开眼睛就发现自己躺在医院病床上了
???：不知道那个人事故之后怎么样了
穿西装的男子：小姐·你从刚才就在发呆你听到我说的话了吗？
???：啊…………不好意思
???：对了，我想起来了。有人说发现我和某个人在一起而那个人身上带看违法药品
???：(本以为要继续接受盘问结果莫名其妙地就被带到了这座岛上
穿西装的男子：埃我知道，遇到这种事头脑难免会陷入一片混乱
穿西装的男子：正因为情况特殊你更应该振作起来才行你说得出自己的全名吗？
鹤：嗯，我是钰鹤
穿西装的男子：真是太好了。看来你还算比较冷静至少说得出自已的名字。
穿西装的男子：那么，你应该也能够理解我刚才的说明吧钰小姐。
鹤：嗯……你是
穿西装的男子：真是的·
穿西装的男子：真是的我的名字是『今部』。看来你真的睡糊涂了。
鹤：对了，他叫今部··
鹤：在被带来这里之前接受警方盘问正当事情始终理不出头绪时是他帮我脱离了困境
鹤：（但我完全不认识他不知道他是个怎么样的人
今部：没办法，只好挑重点再重新说明一次，这次请你务必专心听。
今部：首先第一个重点，正如刚刚所说的尔被怀疑涉及参与了某起事件现在被列为重点参考证人。
今部：由于事发现场，与你在一起的男子有交易非法药物的嫌疑。
今部：和他出现在同一个地点的人，也就是你，自然也被怀疑参与了违法买卖
鹤：你说我有嫌疑可是我真的什么都不知道也不认识那个男的
今部：可惜有自击者指出，曾经好几次看到男一女在事发地点附近的夜店出没进行非法药物交易
鹤：可是，我真的没有
今部：我了解。但现在的难点是没有人能证明你是无辜的。
鹤：那我该怎么做才好现在那个被环疑的男人在哪里？他看到我的脸应该就会知道抓错人了。
今部：你说的没错，请他真接和你见面确认，也许是最快的方法。
今部：只可惜他大概很难为你提供不在场证明
鹤：为什么…………·?
今部：你认得这名男子吧？
鹤：这个人的脸··我见过…
今部：这名涉嫌交易非法药物的男子可能因为车祸的冲击丧失了部分过去的记忆。
鹤：什么？丧失记忆
今部：是的。我想应该只是暂时性的失忆。但是他完全想不起来那天在夜店里和他在一起的女人是谁。
鹤：(怎么会难道真的没有人可以证明我的清白了？
今部：我帮你作证吧
今部：你没听清楚吗？我说我要帮你作证，证明你不认识那名男子，也和非法药物的犯罪无关。
鹤：你要帮我作证这样就能证明我的清白了吗？
今部：只要钰小姐愿意配合协助我。
今部：我的提议绝不会陷你干不利
鹤：(要我协助他可是如果他提出什么难题或是奇怪的条件，我该怎么办
今部：你似平还没完全了解你的处境
今部：事情发展到这地步，你没有选择的余地。请回我「好」或「YES」，二择其一。你会接受我的提议吧？
今部：我想请你帮的忙，就是在那名失忆男子的面前假装自己是『他的恋人』
鹤：要我扮演他的恋人·！?
今部：其实发生交通事故之前他和某位女性在一起，而那位女性很可能是他的女友。
今部：那名女性最后被目击到的地点就是那间夜店，随后不久她便失踪行踪成谜
今部：为了找出那位失踪的女性必须找回这名男子因车祸失去的记忆。
今部：所以才希望你假扮成他的恋人从他口中打听任何可能的线索找出他女友的所在地，
今部：在你协助的这段期间，我也会在别处进行搜索。只要找到和他出现在夜店的那名女性，就能顺利证明你的清白了。
鹤：可是我要怎么在素未谋面的陌生人面前假扮他的恋人，这未免太强人所难了·
今部：这不是担心做不做得到的时候你非做不可。
今部：麻烦你了。
鹤：为了洗清我的嫌疑也别无选择了
鹤：好我知道了
今部：谢谢你愿意协助据说这名男子周围的人都叫他也『葵』。
鹤：名字是『葵』吗
今部：啊，对了。差点忘了告诉你你从今天开始必须暂时住在这座小岛上。
鹤：什么？
今部：住宿的相关细节等下会由设施员工为你说明
鹤：等、等一下
看守员：不好意思我过来带钰小姐到她的房间。
今部：那就之后再见了钰小姐。
鹤：我到底会被带去挪里话说回来，在抵达小岛前好像坐了很久的船
鹤：该不会在找到他的女友之前我都回不了家？
鹤：..·嗯?
鹤：从这里能跳望到海面
鹤：这里真的是一座孤岛
看守员：今天的海面很平静呢
鹤：风景很美。大海和天空一望无际
看守员：毕竟这座设施坐落于岛上视野最佳的位置。
看守员：以前政府在这座岛上盖了监由国家管理
看守员：但战后因财政困难，没有经费维持而关闭后来由民间企业『西海普制药」将整座岛买下，加以利用。
看守员：我个现在所在的这栋建筑设施就是『西海普医疗中心』。
鹤：『西海普制药』?
看守员：那是一家专门研发、制造医疗用品及药品的制药厂。
看守员：这里就是『西海普制药』所管理的设施之一，用于收容病患以进行外地疗养
看守员：··表面上是这样。不过我想你也已经察觉到，实际用途不仅如此。
看守员：这里的收容人都有自己的房间只要在安全管理上不引发问题都能在允许的范围内从事自由活动。
看守员：也个的房间受到24小时全天候的监视一旦房间内发生任何意外，设施的勺人员都能马上应对。
鹤：·这么说的话，我的行动也会受到监视吗？
看守员：不会。我收到的指示是要带你去员工用宿舍的房间。那里不在监视的范围内，你大可放心。
看守员：一直站在这里说话也不是办法，我价们继续往前走吧
看守员：这里就是钰小姐的房间可供你自由使用
看守员：另外，还要给你这个
鹤：智能手机?
看守员：是的。在岛上的期间无法使用私人手机，请改用这台『SABOT』。
看守员：请收下。可以试着开启一下电源。
看守员：启动之后，手机内的引导功能就会为你介绍各功能的使用方法
看守员：这只手机也能当作你在岛上的身份证请务必随身携带
看守员：注意千万不要弄丢使用上也请多加小心
看守员：此外，在岛上只要出示这支手机证明身份，就能免费购物。不需要另外支付现金。
看守员：今部先生已经事先为钰小姐预付了一笔费用当作在岛上的生活费你不用担心金钱的问题。
看守员：最后说一件事关于明天会面请你明早10点到我们刚才经过的收容所入口处集合。
鹤：好的我明白了
看守员：那么，请好好休息
鹤：·是。
鹤：天呐没想到我被卷入了这么棘手的事件
鹤：今后，到底会怎样?
鹤：(太阳升起来了差不多该前往看守员所说的地点了
今部：早安，钰小姐。
今部：你好像很紧张。
鹤：嗯…是啊。
今部：那也是难免的。昨天离开后，我也重新思考了一遍
今部：你是普通人，不是职业演员：老实说我也不认为你能很自然地扮成他的恋人。
今部：今天就先以他的友人身份见面视状况往后再做调整吧
今部：请你在了解他的为人以后再看准合适的时机：告诉他你是他的女友。
看守员：早安。今部先生，钰小姐。让两位久等了。
今部：阿，已经到会面时间了吗那就拜托你好好表现了，钰小姐。
鹤：太、太强人所难了·
看守员：那我们走吧。
看守员：这间就是会面室。
看守员：进去以后，你会看见里面有块玻璃隔板将房间隔成会面者和收容人用的两间小房间。
看守员：会面过程中不会有职员陪同司，我们会在房间外待命，有任何问题或需要帮忙时，请随时叫我个
看守员：也许和收容人独处会让你感到不安但会面室的玻璃采用不易被打破的强化玻璃亚克力板制成，
看守员：即使搬起椅子用力砸玻璃房间内的隔板也绝对不会碎。这点你大可放心。
鹤：那个
看守员：是，请说。
鹤：请问·我该怎么面对收容人?
看守员：该怎么面对？如果你是他的朋友，就以平常心对待即可。
鹤：(我就是无法拿捏所谓的「平常心」
看守员：请问怎么了？还有什么事让你感到不安吗？
鹤：啊，没有没事。
看守员：等会面时间结束了，我会敲门提醒你就算事情没说完，也请尽快结束会面离开房间。
鹤：就是这人人吗·
葵：干嘛?一直町着别人的脸看
葵：我听说有人认识的人想找我谈谈
葵：
葵：不过很抱，我对你完全没印象。
葵：你叫什么名字？
葵：钰鹤
葵：嗯名字也没有印象。
葵：我们真的认识？
鹤：与其说认识，不如说
葵：啊，还是算了。反正我都不记得了问了也没有意义。
葵：如果我们以前真的见过面那很抱款，我现在都想不起来了。
葵：那么，你找我有什么事？
葵：特地跑到这种地方，应该不会只是为了闲聊吧？
葵：应该是有什么事想问我？
鹤：（就算这么说，我也不知道该问什么好.
鹤：（既然要装作认识的人要是表现得太客气的话反而会很不自然吧·
葵：怎么了？
鹤：啊，嗯那
葵：。。。
鹤：再这样下去会被怀疑的得随便问点问题才行···
鹤：（总之，先问问看关于那场意外他还记得什么吧
你面临着2个选择，第一个：我听人说 ，你正涉及某件危险的事。第二个：你还记得意外发生前 ，你跟谁在一起吗 ？'''
# a = chatGPT_sum(content)
# print(a)
'''
你是一个文字冒险游戏的女主角，名为钰鹤，钰是姓氏，鹤是名字。下面是游戏剧情，你需要根据剧情做出合理的判断，并说明原因：
钰鹤被警方怀疑参与了某起事件，今部帮助她脱离困境，但他们需要找到一个可以证明钰鹤无辜的方法，最终他们决定让钰鹤和被环疑的男子见面，以确认钰鹤的无辜。
鹤被要求去小岛上假扮一名失忆男子的恋人，以帮助他找回记忆，以洗清自己的嫌疑。小岛上有一座监狱，拥有最佳的视野，海面平静，风景美丽。
鹤被卷入一个棘手的事件，被带到一个由民间企业『西海普制药」管理的设施，收容病患以进行外地疗养，但实际用途不仅如此。鹤被给予一台『SABOT』智能手机，可以用来证明身份，免费购物，以及收到一笔费用当作在岛上的生活费。最后，鹤被要求在第二天10点到
鹤面对着葵，不知道该如何面对，看守员提醒他以平常心对待，葵表示自己对鹤完全没有印象，
你要向葵提问，你面临着2个提问选择：
1.我听人说，你正涉及某件危险的事。
2.你还记得意外发生前，你跟谁在一起吗？
你选择哪个，为什么？'''
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.llms.OpenAI",
"langchain.prompts.PromptTemplate",
"langchain.docstore.document.Document",
"langchain.chains.summarize.load_summarize_chain"
] | [((6345, 6470), 'openai.Completion.create', 'openai.Completion.create', ([], {'model': '"""text-ada-001"""', 'prompt': 'f"""你要总结这一文本的关键词，并以python列表的形式返回数个关键词字符串:{content}。"""', 'temperature': '(0)'}), "(model='text-ada-001', prompt=\n f'你要总结这一文本的关键词，并以python列表的形式返回数个关键词字符串:{content}。', temperature=0)\n", (6369, 6470), False, 'import openai\n'), ((6706, 6809), 'openai.Completion.create', 'openai.Completion.create', ([], {'model': '"""text-ada-001"""', 'prompt': 'f"""你要在10字以内概括这段文本:{content}。"""', 'temperature': '(0)'}), "(model='text-ada-001', prompt=\n f'你要在10字以内概括这段文本:{content}。', temperature=0)\n", (6730, 6809), False, 'import openai\n'), ((7340, 7379), 'os.path.join', 'os.path.join', (['save_path', 'chat_json_name'], {}), '(save_path, chat_json_name)\n', (7352, 7379), False, 'import os\n'), ((15982, 16020), 'os.path.join', 'os.path.join', (['"""."""', '"""asset"""', '"""font.ttf"""'], {}), "('.', 'asset', 'font.ttf')\n", (15994, 16020), False, 'import os\n'), ((16410, 16449), 're.compile', 're.compile', (['"""(\\\\\\\\u[0-9a-fA-F]{4}|\\\\n)"""'], {}), "('(\\\\\\\\u[0-9a-fA-F]{4}|\\\\n)')\n", (16420, 16449), False, 'import re\n'), ((17333, 17369), 'json.dumps', 'json.dumps', (['data'], {'ensure_ascii': '(False)'}), '(data, ensure_ascii=False)\n', (17343, 17369), False, 'import json\n'), ((17889, 17922), 'flet.Theme', 'ft.Theme', ([], {'font_family': '"""A75方正像素12"""'}), "(font_family='A75方正像素12')\n", (17897, 17922), True, 'import flet as ft\n'), ((17998, 18064), 'flet.ListView', 'ft.ListView', ([], {'expand': '(True)', 'spacing': '(10)', 'auto_scroll': '(True)', 'padding': '(20)'}), '(expand=True, spacing=10, auto_scroll=True, padding=20)\n', (18009, 18064), True, 'import flet as ft\n'), ((19524, 19560), 'flet.FilePicker', 'FilePicker', ([], {'on_result': 'import_chatlog'}), '(on_result=import_chatlog)\n', (19534, 19560), False, 'from flet import ElevatedButton, FilePicker, FilePickerResultEvent, Page, Row, Text, icons\n'), ((20147, 20185), 'flet.FilePicker', 'FilePicker', ([], {'on_result': 'save_file_result'}), '(on_result=save_file_result)\n', (20157, 20185), False, 'from flet import ElevatedButton, FilePicker, FilePickerResultEvent, Page, Row, Text, icons\n'), ((20208, 20214), 'flet.Text', 'Text', ([], {}), '()\n', (20212, 20214), False, 'from flet import ElevatedButton, FilePicker, FilePickerResultEvent, Page, Row, Text, icons\n'), ((20422, 20464), 'flet.FilePicker', 'FilePicker', ([], {'on_result': 'get_directory_result'}), '(on_result=get_directory_result)\n', (20432, 20464), False, 'from flet import ElevatedButton, FilePicker, FilePickerResultEvent, Page, Row, Text, icons\n'), ((20487, 20493), 'flet.Text', 'Text', ([], {}), '()\n', (20491, 20493), False, 'from flet import ElevatedButton, FilePicker, FilePickerResultEvent, Page, Row, Text, icons\n'), ((21232, 21273), 'flet.FilePicker', 'FilePicker', ([], {'on_result': 'change_font_clicked'}), '(on_result=change_font_clicked)\n', (21242, 21273), False, 'from flet import ElevatedButton, FilePicker, FilePickerResultEvent, Page, Row, Text, icons\n'), ((21343, 21379), 'flet.TextField', 'ft.TextField', ([], {'hint_text': '"""在此输入apikey"""'}), "(hint_text='在此输入apikey')\n", (21355, 21379), True, 'import flet as ft\n'), ((21398, 21444), 'flet.Text', 'ft.Text', (['"""如有任何bug请联系我：B1lli_official"""'], {'size': '(15)'}), "('如有任何bug请联系我：B1lli_official', size=15)\n", (21405, 21444), True, 'import flet as ft\n'), ((22531, 22686), 'flet.IconButton', 'ft.IconButton', ([], {'icon': 'ft.icons.SETTINGS_OUTLINED', 'icon_color': '"""#9ecaff"""', 'bgcolor': '"""#202429"""', 'icon_size': '(20)', 'tooltip': '"""Settings"""', 'on_click': 'open_dlg_modal'}), "(icon=ft.icons.SETTINGS_OUTLINED, icon_color='#9ecaff',\n bgcolor='#202429', icon_size=20, tooltip='Settings', on_click=\n open_dlg_modal)\n", (22544, 22686), True, 'import flet as ft\n'), ((28829, 28915), 'flet.TextField', 'ft.TextField', ([], {'hint_text': '"""想和chatGPT说些什么？"""', 'filled': '(True)', 'expand': '(True)', 'multiline': '(True)'}), "(hint_text='想和chatGPT说些什么？', filled=True, expand=True,\n multiline=True)\n", (28841, 28915), True, 'import flet as ft\n'), ((28965, 29022), 'flet.ElevatedButton', 'ft.ElevatedButton', (['"""对话"""'], {'on_click': 'add_msg', 'tooltip': '"""随便聊聊"""'}), "('对话', on_click=add_msg, tooltip='随便聊聊')\n", (28982, 29022), True, 'import flet as ft\n'), ((29041, 29131), 'flet.ElevatedButton', 'ft.ElevatedButton', (['"""思维链优化对话"""'], {'on_click': 'add_msg_composition', 'tooltip': '"""认真提问\n仅在对话开始时可用"""'}), "('思维链优化对话', on_click=add_msg_composition, tooltip=\n '认真提问\\n仅在对话开始时可用')\n", (29058, 29131), True, 'import flet as ft\n'), ((33098, 33143), 'flet.Text', 'ft.Text', (['"""BillyGPT V5.3.1 By B1lli"""'], {'size': '(10)'}), "('BillyGPT V5.3.1 By B1lli', size=10)\n", (33105, 33143), True, 'import flet as ft\n'), ((33219, 33267), 'flet.app', 'ft.app', ([], {'target': 'ft_interface', 'assets_dir': '"""assets"""'}), "(target=ft_interface, assets_dir='assets')\n", (33225, 33267), True, 'import flet as ft\n'), ((1177, 1300), 'flet.TextField', 'ft.TextField', ([], {'label': '"""消息内容"""', 'value': 'self.content', 'filled': '(True)', 'expand': '(True)', 'multiline': '(True)', 'on_change': 'self.content_change'}), "(label='消息内容', value=self.content, filled=True, expand=True,\n multiline=True, on_change=self.content_change)\n", (1189, 1300), True, 'import flet as ft\n'), ((1419, 1471), 'flet.ElevatedButton', 'ft.ElevatedButton', (['"""概括本消息"""'], {'on_click': 'self.sum_change'}), "('概括本消息', on_click=self.sum_change)\n", (1436, 1471), True, 'import flet as ft\n'), ((1523, 1624), 'flet.TextField', 'ft.TextField', ([], {'visible': '(False)', 'label': '"""概括内容"""', 'value': '"""概括中"""', 'filled': '(True)', 'expand': '(True)', 'multiline': '(True)'}), "(visible=False, label='概括内容', value='概括中', filled=True, expand=\n True, multiline=True)\n", (1535, 1624), True, 'import flet as ft\n'), ((1787, 1880), 'flet.Row', 'ft.Row', (['[self.role_dropdown, self.content_textfield, self.generalize_btn, self.\n sum_field]'], {}), '([self.role_dropdown, self.content_textfield, self.generalize_btn,\n self.sum_field])\n', (1793, 1880), True, 'import flet as ft\n'), ((3578, 3673), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-3.5-turbo"""', 'messages': 'composition_analysis_message'}), "(model='gpt-3.5-turbo', messages=\n composition_analysis_message)\n", (3606, 3673), False, 'import openai\n'), ((4597, 4661), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(0)'}), '(chunk_size=1000, chunk_overlap=0)\n', (4627, 4661), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((4713, 4765), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'openai_api_key': 'openai.api_key'}), '(temperature=0, openai_api_key=openai.api_key)\n', (4719, 4765), False, 'from langchain.llms import OpenAI\n'), ((5344, 5410), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'prompt_template', 'input_variables': "['text']"}), "(template=prompt_template, input_variables=['text'])\n", (5358, 5410), False, 'from langchain.prompts import PromptTemplate\n'), ((5504, 5651), 'langchain.chains.summarize.load_summarize_chain', 'load_summarize_chain', (['llm'], {'chain_type': '"""map_reduce"""', 'return_intermediate_steps': '(True)', 'map_prompt': 'PROMPT', 'combine_prompt': 'PROMPT', 'verbose': '(True)'}), "(llm, chain_type='map_reduce',\n return_intermediate_steps=True, map_prompt=PROMPT, combine_prompt=\n PROMPT, verbose=True)\n", (5524, 5651), False, 'from langchain.chains.summarize import load_summarize_chain\n'), ((7113, 7138), 'os.path.exists', 'os.path.exists', (['save_path'], {}), '(save_path)\n', (7127, 7138), False, 'import os\n'), ((7149, 7171), 'os.makedirs', 'os.makedirs', (['save_path'], {}), '(save_path)\n', (7160, 7171), False, 'import os\n'), ((7392, 7422), 'os.path.exists', 'os.path.exists', (['chat_json_path'], {}), '(chat_json_path)\n', (7406, 7422), False, 'import os\n'), ((8550, 8592), 'json.dump', 'json.dump', (['chats', 'f'], {'default': 'str', 'indent': '(4)'}), '(chats, f, default=str, indent=4)\n', (8559, 8592), False, 'import json\n'), ((9068, 9080), 'json.load', 'json.load', (['f'], {}), '(f)\n', (9077, 9080), False, 'import json\n'), ((9595, 9636), 'json.dump', 'json.dump', (['data', 'f'], {'default': 'str', 'indent': '(4)'}), '(data, f, default=str, indent=4)\n', (9604, 9636), False, 'import json\n'), ((9973, 9985), 'json.load', 'json.load', (['f'], {}), '(f)\n', (9982, 9985), False, 'import json\n'), ((10709, 10721), 'json.load', 'json.load', (['f'], {}), '(f)\n', (10718, 10721), False, 'import json\n'), ((11353, 11365), 'json.load', 'json.load', (['f'], {}), '(f)\n', (11362, 11365), False, 'import json\n'), ((11782, 11813), 'json.dump', 'json.dump', (['chatlog', 'f'], {'indent': '(4)'}), '(chatlog, f, indent=4)\n', (11791, 11813), False, 'import json\n'), ((11945, 11957), 'json.load', 'json.load', (['f'], {}), '(f)\n', (11954, 11957), False, 'import json\n'), ((12374, 12405), 'json.dump', 'json.dump', (['chatlog', 'f'], {'indent': '(4)'}), '(chatlog, f, indent=4)\n', (12383, 12405), False, 'import json\n'), ((12544, 12556), 'json.load', 'json.load', (['f'], {}), '(f)\n', (12553, 12556), False, 'import json\n'), ((12934, 12965), 'json.dump', 'json.dump', (['chatlog', 'f'], {'indent': '(4)'}), '(chatlog, f, indent=4)\n', (12943, 12965), False, 'import json\n'), ((16040, 16059), 'os.remove', 'os.remove', (['old_path'], {}), '(old_path)\n', (16049, 16059), False, 'import os\n'), ((16116, 16152), 'shutil.copy', 'shutil.copy', (['path', '"""assets/font.ttf"""'], {}), "(path, 'assets/font.ttf')\n", (16127, 16152), False, 'import shutil\n'), ((16996, 17016), 'json.loads', 'json.loads', (['txt_data'], {}), '(txt_data)\n', (17006, 17016), False, 'import json\n'), ((17409, 17434), 'os.path.exists', 'os.path.exists', (['"""./cache"""'], {}), "('./cache')\n", (17423, 17434), False, 'import os\n'), ((17445, 17467), 'os.makedirs', 'os.makedirs', (['"""./cache"""'], {}), "('./cache')\n", (17456, 17467), False, 'import os\n'), ((23254, 23286), 'flet.TextField', 'ft.TextField', ([], {'label': '"""输入你的apikey"""'}), "(label='输入你的apikey')\n", (23266, 23286), True, 'import flet as ft\n'), ((5111, 5135), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 't'}), '(page_content=t)\n', (5119, 5135), False, 'from langchain.docstore.document import Document\n'), ((7209, 7223), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (7221, 7223), False, 'from datetime import datetime\n'), ((7483, 7512), 'json.dump', 'json.dump', (['[]', 'f'], {'default': 'str'}), '([], f, default=str)\n', (7492, 7512), False, 'import json\n'), ((7813, 7827), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (7825, 7827), False, 'from datetime import datetime\n'), ((8092, 8104), 'json.load', 'json.load', (['f'], {}), '(f)\n', (8101, 8104), False, 'import json\n'), ((16254, 16290), 'shutil.copy', 'shutil.copy', (['path', '"""assets/font.ttf"""'], {}), "(path, 'assets/font.ttf')\n", (16265, 16290), False, 'import shutil\n'), ((19760, 19809), 'shutil.copy', 'shutil.copy', (['chat_json_path', 'save_file_path.value'], {}), '(chat_json_path, save_file_path.value)\n', (19771, 19809), False, 'import shutil\n'), ((21967, 21986), 'flet.Text', 'ft.Text', (['"""Settings"""'], {}), "('Settings')\n", (21974, 21986), True, 'import flet as ft\n'), ((22005, 22091), 'flet.Column', 'ft.Column', (['[apikey_field, my_wechat, github_page_btn, change_font_btn]'], {'height': '(200)'}), '([apikey_field, my_wechat, github_page_btn, change_font_btn],\n height=200)\n', (22014, 22091), True, 'import flet as ft\n'), ((22342, 22378), 'flet.RoundedRectangleBorder', 'ft.RoundedRectangleBorder', ([], {'radius': '(10)'}), '(radius=10)\n', (22367, 22378), True, 'import flet as ft\n'), ((24929, 24957), 'flet.Text', 'ft.Text', ([], {'size': '(9)', 'italic': '(True)'}), '(size=9, italic=True)\n', (24936, 24957), True, 'import flet as ft\n'), ((26874, 26888), 'flet.Container', 'ft.Container', ([], {}), '()\n', (26886, 26888), True, 'import flet as ft\n'), ((30010, 30079), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-3.5-turbo"""', 'messages': 'message'}), "(model='gpt-3.5-turbo', messages=message)\n", (30038, 30079), False, 'import openai\n'), ((17511, 17537), 'os.path.basename', 'os.path.basename', (['txt_path'], {}), '(txt_path)\n', (17527, 17537), False, 'import os\n'), ((22158, 22201), 'flet.TextButton', 'ft.TextButton', (['"""保存"""'], {'on_click': 'save_settings'}), "('保存', on_click=save_settings)\n", (22171, 22201), True, 'import flet as ft\n'), ((22216, 22261), 'flet.TextButton', 'ft.TextButton', (['"""取消"""'], {'on_click': 'cancel_settings'}), "('取消', on_click=cancel_settings)\n", (22229, 22261), True, 'import flet as ft\n'), ((23406, 23429), 'flet.Text', 'ft.Text', (['"""欢迎使用BillyGPT"""'], {}), "('欢迎使用BillyGPT')\n", (23413, 23429), True, 'import flet as ft\n'), ((23452, 23510), 'flet.Column', 'ft.Column', (['[apikey_field_open, get_apikey_btn]'], {'tight': '(True)'}), '([apikey_field_open, get_apikey_btn], tight=True)\n', (23461, 23510), True, 'import flet as ft\n'), ((29217, 29267), 'flet.Row', 'ft.Row', ([], {'controls': '[chat_text, chat_btn, chatPO_btn]'}), '(controls=[chat_text, chat_btn, chatPO_btn])\n', (29223, 29267), True, 'import flet as ft\n'), ((32038, 32084), 'flet.Text', 'ft.Text', (['f"""正在分析提示词组成结构，请耐心等待"""'], {'color': '"""#1cc9a0"""'}), "(f'正在分析提示词组成结构，请耐心等待', color='#1cc9a0')\n", (32045, 32084), True, 'import flet as ft\n'), ((32276, 32344), 'flet.Text', 'ft.Text', (['f"""提示词组成结构分析完毕，正在根据组成结构逐步生成详细结果，耗时较长，请耐心等待"""'], {'color': '"""#1cc9a0"""'}), "(f'提示词组成结构分析完毕，正在根据组成结构逐步生成详细结果，耗时较长，请耐心等待', color='#1cc9a0')\n", (32283, 32344), True, 'import flet as ft\n'), ((949, 977), 'flet.dropdown.Option', 'ft.dropdown.Option', (['"""system"""'], {}), "('system')\n", (967, 977), True, 'import flet as ft\n'), ((996, 1022), 'flet.dropdown.Option', 'ft.dropdown.Option', (['"""user"""'], {}), "('user')\n", (1014, 1022), True, 'import flet as ft\n'), ((1041, 1072), 'flet.dropdown.Option', 'ft.dropdown.Option', (['"""assistant"""'], {}), "('assistant')\n", (1059, 1072), True, 'import flet as ft\n'), ((9477, 9491), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (9489, 9491), False, 'from datetime import datetime\n'), ((19405, 19466), 'flet.Text', 'Text', (['f"""出现如下报错\n{e}\n请检查导入的聊天记录是否正确，或联系开发者微信B1lli_official"""'], {}), '(f"""出现如下报错\n{e}\n请检查导入的聊天记录是否正确，或联系开发者微信B1lli_official""")\n', (19409, 19466), False, 'from flet import ElevatedButton, FilePicker, FilePickerResultEvent, Page, Row, Text, icons\n'), ((23586, 23645), 'flet.ElevatedButton', 'ft.ElevatedButton', ([], {'text': '"""开始使用"""', 'on_click': 'save_settings_open'}), "(text='开始使用', on_click=save_settings_open)\n", (23603, 23645), True, 'import flet as ft\n'), ((25184, 25207), 'flet.padding.only', 'ft.padding.only', ([], {'top': '(15)'}), '(top=15)\n', (25199, 25207), True, 'import flet as ft\n'), ((25292, 25333), 'flet.animation.Animation', 'ft.animation.Animation', (['(400)', '"""decelerate"""'], {}), "(400, 'decelerate')\n", (25314, 25333), True, 'import flet as ft\n'), ((26617, 26654), 'flet.Column', 'ft.Column', ([], {'scroll': '"""auto"""', 'expand': '(True)'}), "(scroll='auto', expand=True)\n", (26626, 26654), True, 'import flet as ft\n'), ((25755, 25809), 'flet.Icon', 'ft.Icon', (['ft.icons.SEARCH_ROUNDED'], {'size': '(15)', 'opacity': '(0.9)'}), '(ft.icons.SEARCH_ROUNDED, size=15, opacity=0.9)\n', (25762, 25809), True, 'import flet as ft\n'), ((25992, 26157), 'flet.TextField', 'ft.TextField', ([], {'border_color': '"""transparent"""', 'height': '(20)', 'text_size': '(12)', 'content_padding': '(2)', 'cursor_color': '"""black"""', 'cursor_width': '(1)', 'hint_text': '"""搜索模板"""', 'on_change': 'None'}), "(border_color='transparent', height=20, text_size=12,\n content_padding=2, cursor_color='black', cursor_width=1, hint_text=\n '搜索模板', on_change=None)\n", (26004, 26157), True, 'import flet as ft\n'), ((28471, 28485), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (28483, 28485), False, 'from datetime import datetime\n')] |
import os
import langchain.text_splitter
from langchain import PromptTemplate, LLMChain
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.llms import LlamaCpp
try:
from extensions.telegram_bot.source.generators.abstract_generator import AbstractGenerator
except ImportError:
from source.generators.abstract_generator import AbstractGenerator
# Place where path to LLM file stored
llm = None
# Callbacks support token-wise streaming
class Generator(AbstractGenerator):
model_change_allowed = False # if model changing allowed without stopping.
preset_change_allowed = True # if preset_file changing allowed.
def __init__(self, model_path, n_ctx=2048, seed=0, n_gpu_layers=0):
callback_manager = CallbackManager([StreamingStdOutCallbackHandler()])
self.llm = LlamaCpp(
model_path=model_path,
n_ctx=n_ctx,
callback_manager=callback_manager,
verbose=True,
)
def generate_answer(
self, prompt, generation_params, eos_token, stopping_strings, default_answer, turn_template="", **kwargs
):
if "max_tokens" in generation_params:
llm.max_tokens = generation_params["max_tokens"]
if "temperature" in generation_params:
llm.temperature = generation_params["temperature"]
if "top_p" in generation_params:
llm.top_p = generation_params["top_p"]
if "top_k" in generation_params:
llm.top_k = generation_params["top_k"]
prompt_template = PromptTemplate(template="{prompt}", input_variables=["prompt"])
llm.stop = stopping_strings
llm_chain = LLMChain(prompt=prompt_template, llm=self.llm)
answer = llm_chain.run(prompt)
return answer
def tokens_count(self, text: str):
splitter = langchain.text_splitter.TokenTextSplitter()
length = len(splitter.split_text(text))
return length
def get_model_list(
self,
):
bins = []
for i in os.listdir("models"):
if i.endswith(".bin"):
bins.append(i)
return bins
def load_model(self, model_file: str):
pass
| [
"langchain.LLMChain",
"langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler",
"langchain.llms.LlamaCpp",
"langchain.PromptTemplate"
] | [((905, 1003), 'langchain.llms.LlamaCpp', 'LlamaCpp', ([], {'model_path': 'model_path', 'n_ctx': 'n_ctx', 'callback_manager': 'callback_manager', 'verbose': '(True)'}), '(model_path=model_path, n_ctx=n_ctx, callback_manager=\n callback_manager, verbose=True)\n', (913, 1003), False, 'from langchain.llms import LlamaCpp\n'), ((1631, 1694), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'template': '"""{prompt}"""', 'input_variables': "['prompt']"}), "(template='{prompt}', input_variables=['prompt'])\n", (1645, 1694), False, 'from langchain import PromptTemplate, LLMChain\n'), ((1751, 1797), 'langchain.LLMChain', 'LLMChain', ([], {'prompt': 'prompt_template', 'llm': 'self.llm'}), '(prompt=prompt_template, llm=self.llm)\n', (1759, 1797), False, 'from langchain import PromptTemplate, LLMChain\n'), ((2113, 2133), 'os.listdir', 'os.listdir', (['"""models"""'], {}), "('models')\n", (2123, 2133), False, 'import os\n'), ((851, 883), 'langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler', 'StreamingStdOutCallbackHandler', ([], {}), '()\n', (881, 883), False, 'from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n')] |
import os
import openai
from dotenv import load_dotenv
from langchain.chat_models import AzureChatOpenAI
from langchain.chat_models import ChatOpenAI
from langchain.embeddings import OpenAIEmbeddings
from langchain.callbacks.base import BaseCallbackHandler
from langchain.vectorstores import FAISS
from langchain.chains import ConversationalRetrievalChain
from langchain.chains.conversational_retrieval.base import BaseConversationalRetrievalChain
from langchain.prompts import PromptTemplate
from langchain.document_loaders import (UnstructuredPowerPointLoader, UnstructuredWordDocumentLoader, PyPDFLoader, UnstructuredFileLoader, CSVLoader, MWDumpLoader)
import langchain.text_splitter as text_splitter
from langchain.text_splitter import (RecursiveCharacterTextSplitter, CharacterTextSplitter)
from typing import List
import streamlit
import glob
REQUEST_TIMEOUT_DEFAULT = 10
TEMPERATURE_DEFAULT = 0.0
CHAT_MODEL_NAME_DEFAULT = "gpt-3.5-turbo"
OPENAI_EMBEDDING_DEPLOYMENT_NAME_DEFAULT = "text-embedding-ada-002"
CHUNK_SIZE_DEFAULT = 1000
CHUNK_OVERLAP_DEFAULT = 0
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)
class DocChatbot:
llm: ChatOpenAI
condense_question_llm: ChatOpenAI
embeddings: OpenAIEmbeddings
vector_db: FAISS
chatchain: BaseConversationalRetrievalChain
# configuration for API calls
request_timeout: int
temperature: float
chat_model_name : str
api_key : str
def init_llm_openai(self, streaming: bool, condense_question_container = None, answer_container = None) -> None:
# init for LLM using openai.com api
self.llm = ChatOpenAI(
temperature=self.temperature,
openai_api_key=self.api_key,
request_timeout=self.request_timeout,
model=self.chat_model_name, # Model name is needed for openai.com only
streaming=streaming,
callbacks=[StreamHandler(answer_container)] if streaming else []
) # type: ignore
if streaming:
self.condense_question_llm = ChatOpenAI(
temperature=self.temperature,
openai_api_key=self.api_key,
request_timeout=self.request_timeout,
streaming=True,
model=self.chat_model_name,
callbacks=[StreamHandler(condense_question_container, "🤔...")]
) # type: ignore
else:
self.condense_question_llm = self.llm
def init_llm_azure(self, streaming: bool, condense_question_container = None, answer_container = None) -> None:
# init for LLM using Azure OpenAI Service
assert(os.getenv("OPENAI_GPT_DEPLOYMENT_NAME") is not None)
assert(os.getenv("OPENAI_API_BASE") is not None)
assert(os.getenv("OPENAI_EMBEDDING_DEPLOYMENT_NAME") is not None)
assert(len(self.api_key) == 32)
self.llm = AzureChatOpenAI(
deployment_name=os.getenv("OPENAI_GPT_DEPLOYMENT_NAME"),
temperature=self.temperature,
openai_api_version="2023-05-15",
openai_api_type="azure",
openai_api_base=os.getenv("OPENAI_API_BASE"),
openai_api_key=self.api_key,
request_timeout=self.request_timeout,
streaming=streaming,
callbacks=[StreamHandler(answer_container)] if streaming else []
) # type: ignore
if streaming:
self.condense_question_llm = AzureChatOpenAI(
deployment_name=os.getenv("OPENAI_GPT_DEPLOYMENT_NAME"),
temperature=self.temperature,
openai_api_version="2023-05-15",
openai_api_type="azure",
openai_api_base=os.getenv("OPENAI_API_BASE"),
openai_api_key=os.getenv("OPENAI_API_KEY"),
request_timeout=self.request_timeout,
model=self.chat_model_name,
streaming=True,
callbacks=[StreamHandler(condense_question_container, "🤔...")]
) # type: ignore
else:
self.condense_question_llm = self.llm
def __init__(self) -> None:
#init for LLM and Embeddings, without support for streaming
#load environment variables
load_dotenv()
assert(os.getenv("OPENAI_API_KEY") is not None)
self.api_key = str(os.getenv("OPENAI_API_KEY"))
self.request_timeout = REQUEST_TIMEOUT_DEFAULT if os.getenv("REQUEST_TIMEOUT") is None else int(os.getenv("REQUEST_TIMEOUT"))
self.temperature = TEMPERATURE_DEFAULT if os.getenv("TEMPERATURE") is None else float(os.getenv("TEMPERATURE"))
self.chat_model_name = CHAT_MODEL_NAME_DEFAULT if os.getenv("CHAT_MODEL_NAME") is None else str(os.getenv("CHAT_MODEL_NAME"))
#check if user is using API from openai.com or Azure OpenAI Service by inspecting the api key
if self.api_key.startswith("sk-"):
# user is using API from openai.com
assert(len(self.api_key) == 51)
self.init_llm_openai(False)
else:
# user is using Azure OpenAI Service
self.init_llm_azure(False)
embedding_deployment = OPENAI_EMBEDDING_DEPLOYMENT_NAME_DEFAULT if os.getenv("OPENAI_EMBEDDING_DEPLOYMENT_NAME") is None else str(os.getenv("OPENAI_EMBEDDING_DEPLOYMENT_NAME"))
self.embeddings = OpenAIEmbeddings(
deployment=embedding_deployment,
chunk_size=1
) # type: ignore
def init_streaming(self, condense_question_container, answer_container) -> None:
#init for LLM and Embeddings, with support for streaming
if self.api_key.startswith("sk-"):
# user is using API from openai.com
self.init_llm_openai(True, condense_question_container, answer_container)
else:
# user is using Azure OpenAI Service
self.init_llm_azure(True, condense_question_container, answer_container)
# def init_streaming(self, condense_question_container, answer_container) -> None:
# #init for LLM and Embeddings, with support for streaming
# api_key = str(os.getenv("OPENAI_API_KEY"))
# temperature=float(os.getenv("TEMPERATURE"))
# request_timeout=int(os.getenv("REQUEST_TIMEOUT"))
# model_name=str(os.getenv("CHAT_MODEL_NAME"))
# if api_key.startswith("sk-"):
# # user is using API from openai.com
# self.llm = ChatOpenAI(
# temperature=temperature,
# openai_api_key=api_key,
# request_timeout=request_timeout,
# streaming=True,
# model=model_name,
# callbacks=[StreamHandler(answer_container)]
# ) # type: ignore
# self.condense_question_llm = ChatOpenAI(
# temperature=temperature,
# openai_api_key=api_key,
# request_timeout=request_timeout,
# streaming=True,
# model=model_name,
# callbacks=[StreamHandler(condense_question_container, "🤔...")]
# ) # type: ignore
# else:
# # user is using Azure OpenAI Service
# self.llm = AzureChatOpenAI(
# deployment_name=os.getenv("OPENAI_GPT_DEPLOYMENT_NAME"),
# temperature=temperature,
# openai_api_version="2023-05-15",
# openai_api_type="azure",
# openai_api_base=os.getenv("OPENAI_API_BASE"),
# openai_api_key=os.getenv("OPENAI_API_KEY"),
# request_timeout=request_timeout,
# model=model_name,
# streaming=True,
# callbacks=[StreamHandler(answer_container)]
# ) # type: ignore
# self.condense_question_llm = AzureChatOpenAI(
# deployment_name=os.getenv("OPENAI_GPT_DEPLOYMENT_NAME"),
# temperature=temperature,
# openai_api_version="2023-05-15",
# openai_api_type="azure",
# openai_api_base=os.getenv("OPENAI_API_BASE"),
# openai_api_key=os.getenv("OPENAI_API_KEY"),
# request_timeout=request_timeout,
# model=model_name,
# streaming=True,
# callbacks=[StreamHandler(condense_question_container, "🤔...")]
# ) # type: ignore
def init_chatchain(self, chain_type : str = "stuff") -> None:
# init for ConversationalRetrievalChain
CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template("""Given the following conversation and a follow up input, rephrase the standalone question.
The standanlone question to be generated should be in the same language with the input.
For example, if the input is in Chinese, the follow up question or the standalone question below should be in Chinese too.
Chat History:
{chat_history}
Follow Up Input:
{question}
Standalone Question:"""
)
# stuff chain_type seems working better than others
self.chatchain = ConversationalRetrievalChain.from_llm(llm=self.llm,
retriever=self.vector_db.as_retriever(),
condense_question_prompt=CONDENSE_QUESTION_PROMPT,
condense_question_llm=self.condense_question_llm,
chain_type=chain_type,
return_source_documents=True,
verbose=False)
# combine_docs_chain_kwargs=dict(return_map_steps=False))
# get answer from query, return answer and source documents
def get_answer_with_source(self, query, chat_history):
result = self.chatchain({
"question": query,
"chat_history": chat_history
},
return_only_outputs=True)
return result['answer'], result['source_documents']
# get answer from query.
# This function is for streamlit app and the chat history is in a format aligned with openai api
def get_answer(self, query, chat_history):
'''
Here's the format for chat history:
[{"role": "assistant", "content": "How can I help you?"}, {"role": "user", "content": "What is your name?"}]
The input for the Chain is in a format like this:
[("How can I help you?", "What is your name?")]
That is, it's a list of question and answer pairs.
So need to transform the chat history to the format for the Chain
'''
chat_history_for_chain = []
for i in range(0, len(chat_history), 2):
chat_history_for_chain.append((
chat_history[i]['content'],
chat_history[i+1]['content'] if chat_history[i+1] is not None else ""
))
result = self.chatchain({
"question": query,
"chat_history": chat_history_for_chain
},
return_only_outputs=True)
return result['answer'], result['source_documents']
# load vector db from local
def load_vector_db_from_local(self, path: str, index_name: str):
self.vector_db = FAISS.load_local(path, self.embeddings, index_name)
print(f"Loaded vector db from local: {path}/{index_name}")
# save vector db to local
def save_vector_db_to_local(self, path: str, index_name: str):
FAISS.save_local(self.vector_db, path, index_name)
print("Vector db saved to local")
# split documents, generate embeddings and ingest to vector db
def init_vector_db_from_documents(self, file_list: List[str]):
chunk_size = CHUNK_SIZE_DEFAULT if os.getenv("CHUNK_SIZE") is None else int(os.getenv("CHUNK_SIZE"))
chunk_overlap = CHUNK_OVERLAP_DEFAULT if os.getenv("CHUNK_OVERLAP") is None else int(os.getenv("CHUNK_OVERLAP"))
text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
docs = []
for file in file_list:
print(f"Loading file: {file}")
ext_name = os.path.splitext(file)[-1]
# print(ext_name)
if ext_name == ".pptx":
loader = UnstructuredPowerPointLoader(file)
elif ext_name == ".docx":
loader = UnstructuredWordDocumentLoader(file)
elif ext_name == ".pdf":
loader = PyPDFLoader(file)
elif ext_name == ".csv":
loader = CSVLoader(file_path=file)
elif ext_name == ".xml":
loader = MWDumpLoader(file_path=file, encoding="utf8")
else:
# process .txt, .html
loader = UnstructuredFileLoader(file)
doc = loader.load_and_split(text_splitter)
docs.extend(doc)
print("Processed document: " + file)
print("Generating embeddings and ingesting to vector db.")
self.vector_db = FAISS.from_documents(docs, self.embeddings)
print("Vector db initialized.")
# Get indexes available
def get_available_indexes(self, path: str):
return [os.path.splitext(os.path.basename(file))[0] for file in glob.glob(f"{path}/*.faiss")]
| [
"langchain.document_loaders.MWDumpLoader",
"langchain.prompts.PromptTemplate.from_template",
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.document_loaders.UnstructuredFileLoader",
"langchain.document_loaders.UnstructuredWordDocumentLoader",
"langchain.vectorstores.FAISS.from_documents",
"langchain.document_loaders.UnstructuredPowerPointLoader",
"langchain.embeddings.OpenAIEmbeddings",
"langchain.vectorstores.FAISS.load_local",
"langchain.document_loaders.CSVLoader",
"langchain.document_loaders.PyPDFLoader",
"langchain.vectorstores.FAISS.save_local"
] | [((4507, 4520), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (4518, 4520), False, 'from dotenv import load_dotenv\n'), ((5613, 5676), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'deployment': 'embedding_deployment', 'chunk_size': '(1)'}), '(deployment=embedding_deployment, chunk_size=1)\n', (5629, 5676), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((8836, 9340), 'langchain.prompts.PromptTemplate.from_template', 'PromptTemplate.from_template', (['"""Given the following conversation and a follow up input, rephrase the standalone question. \n The standanlone question to be generated should be in the same language with the input. \n For example, if the input is in Chinese, the follow up question or the standalone question below should be in Chinese too.\n Chat History:\n {chat_history}\n\n Follow Up Input:\n {question}\n\n Standalone Question:"""'], {}), '(\n """Given the following conversation and a follow up input, rephrase the standalone question. \n The standanlone question to be generated should be in the same language with the input. \n For example, if the input is in Chinese, the follow up question or the standalone question below should be in Chinese too.\n Chat History:\n {chat_history}\n\n Follow Up Input:\n {question}\n\n Standalone Question:"""\n )\n', (8864, 9340), False, 'from langchain.prompts import PromptTemplate\n'), ((11740, 11791), 'langchain.vectorstores.FAISS.load_local', 'FAISS.load_local', (['path', 'self.embeddings', 'index_name'], {}), '(path, self.embeddings, index_name)\n', (11756, 11791), False, 'from langchain.vectorstores import FAISS\n'), ((11965, 12015), 'langchain.vectorstores.FAISS.save_local', 'FAISS.save_local', (['self.vector_db', 'path', 'index_name'], {}), '(self.vector_db, path, index_name)\n', (11981, 12015), False, 'from langchain.vectorstores import FAISS\n'), ((12448, 12535), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': 'chunk_size', 'chunk_overlap': 'chunk_overlap'}), '(chunk_size=chunk_size, chunk_overlap=\n chunk_overlap)\n', (12478, 12535), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter, CharacterTextSplitter\n'), ((13530, 13573), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['docs', 'self.embeddings'], {}), '(docs, self.embeddings)\n', (13550, 13573), False, 'from langchain.vectorstores import FAISS\n'), ((2909, 2948), 'os.getenv', 'os.getenv', (['"""OPENAI_GPT_DEPLOYMENT_NAME"""'], {}), "('OPENAI_GPT_DEPLOYMENT_NAME')\n", (2918, 2948), False, 'import os\n'), ((2977, 3005), 'os.getenv', 'os.getenv', (['"""OPENAI_API_BASE"""'], {}), "('OPENAI_API_BASE')\n", (2986, 3005), False, 'import os\n'), ((3034, 3079), 'os.getenv', 'os.getenv', (['"""OPENAI_EMBEDDING_DEPLOYMENT_NAME"""'], {}), "('OPENAI_EMBEDDING_DEPLOYMENT_NAME')\n", (3043, 3079), False, 'import os\n'), ((4536, 4563), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (4545, 4563), False, 'import os\n'), ((4604, 4631), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (4613, 4631), False, 'import os\n'), ((3198, 3237), 'os.getenv', 'os.getenv', (['"""OPENAI_GPT_DEPLOYMENT_NAME"""'], {}), "('OPENAI_GPT_DEPLOYMENT_NAME')\n", (3207, 3237), False, 'import os\n'), ((3391, 3419), 'os.getenv', 'os.getenv', (['"""OPENAI_API_BASE"""'], {}), "('OPENAI_API_BASE')\n", (3400, 3419), False, 'import os\n'), ((4691, 4719), 'os.getenv', 'os.getenv', (['"""REQUEST_TIMEOUT"""'], {}), "('REQUEST_TIMEOUT')\n", (4700, 4719), False, 'import os\n'), ((4737, 4765), 'os.getenv', 'os.getenv', (['"""REQUEST_TIMEOUT"""'], {}), "('REQUEST_TIMEOUT')\n", (4746, 4765), False, 'import os\n'), ((4817, 4841), 'os.getenv', 'os.getenv', (['"""TEMPERATURE"""'], {}), "('TEMPERATURE')\n", (4826, 4841), False, 'import os\n'), ((4861, 4885), 'os.getenv', 'os.getenv', (['"""TEMPERATURE"""'], {}), "('TEMPERATURE')\n", (4870, 4885), False, 'import os\n'), ((4945, 4973), 'os.getenv', 'os.getenv', (['"""CHAT_MODEL_NAME"""'], {}), "('CHAT_MODEL_NAME')\n", (4954, 4973), False, 'import os\n'), ((4991, 5019), 'os.getenv', 'os.getenv', (['"""CHAT_MODEL_NAME"""'], {}), "('CHAT_MODEL_NAME')\n", (5000, 5019), False, 'import os\n'), ((5477, 5522), 'os.getenv', 'os.getenv', (['"""OPENAI_EMBEDDING_DEPLOYMENT_NAME"""'], {}), "('OPENAI_EMBEDDING_DEPLOYMENT_NAME')\n", (5486, 5522), False, 'import os\n'), ((5540, 5585), 'os.getenv', 'os.getenv', (['"""OPENAI_EMBEDDING_DEPLOYMENT_NAME"""'], {}), "('OPENAI_EMBEDDING_DEPLOYMENT_NAME')\n", (5549, 5585), False, 'import os\n'), ((12237, 12260), 'os.getenv', 'os.getenv', (['"""CHUNK_SIZE"""'], {}), "('CHUNK_SIZE')\n", (12246, 12260), False, 'import os\n'), ((12278, 12301), 'os.getenv', 'os.getenv', (['"""CHUNK_SIZE"""'], {}), "('CHUNK_SIZE')\n", (12287, 12301), False, 'import os\n'), ((12352, 12378), 'os.getenv', 'os.getenv', (['"""CHUNK_OVERLAP"""'], {}), "('CHUNK_OVERLAP')\n", (12361, 12378), False, 'import os\n'), ((12396, 12422), 'os.getenv', 'os.getenv', (['"""CHUNK_OVERLAP"""'], {}), "('CHUNK_OVERLAP')\n", (12405, 12422), False, 'import os\n'), ((12647, 12669), 'os.path.splitext', 'os.path.splitext', (['file'], {}), '(file)\n', (12663, 12669), False, 'import os\n'), ((12766, 12800), 'langchain.document_loaders.UnstructuredPowerPointLoader', 'UnstructuredPowerPointLoader', (['file'], {}), '(file)\n', (12794, 12800), False, 'from langchain.document_loaders import UnstructuredPowerPointLoader, UnstructuredWordDocumentLoader, PyPDFLoader, UnstructuredFileLoader, CSVLoader, MWDumpLoader\n'), ((13763, 13791), 'glob.glob', 'glob.glob', (['f"""{path}/*.faiss"""'], {}), "(f'{path}/*.faiss')\n", (13772, 13791), False, 'import glob\n'), ((3760, 3799), 'os.getenv', 'os.getenv', (['"""OPENAI_GPT_DEPLOYMENT_NAME"""'], {}), "('OPENAI_GPT_DEPLOYMENT_NAME')\n", (3769, 3799), False, 'import os\n'), ((3969, 3997), 'os.getenv', 'os.getenv', (['"""OPENAI_API_BASE"""'], {}), "('OPENAI_API_BASE')\n", (3978, 3997), False, 'import os\n'), ((4030, 4057), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (4039, 4057), False, 'import os\n'), ((12864, 12900), 'langchain.document_loaders.UnstructuredWordDocumentLoader', 'UnstructuredWordDocumentLoader', (['file'], {}), '(file)\n', (12894, 12900), False, 'from langchain.document_loaders import UnstructuredPowerPointLoader, UnstructuredWordDocumentLoader, PyPDFLoader, UnstructuredFileLoader, CSVLoader, MWDumpLoader\n'), ((13724, 13746), 'os.path.basename', 'os.path.basename', (['file'], {}), '(file)\n', (13740, 13746), False, 'import os\n'), ((12963, 12980), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['file'], {}), '(file)\n', (12974, 12980), False, 'from langchain.document_loaders import UnstructuredPowerPointLoader, UnstructuredWordDocumentLoader, PyPDFLoader, UnstructuredFileLoader, CSVLoader, MWDumpLoader\n'), ((13043, 13068), 'langchain.document_loaders.CSVLoader', 'CSVLoader', ([], {'file_path': 'file'}), '(file_path=file)\n', (13052, 13068), False, 'from langchain.document_loaders import UnstructuredPowerPointLoader, UnstructuredWordDocumentLoader, PyPDFLoader, UnstructuredFileLoader, CSVLoader, MWDumpLoader\n'), ((13131, 13176), 'langchain.document_loaders.MWDumpLoader', 'MWDumpLoader', ([], {'file_path': 'file', 'encoding': '"""utf8"""'}), "(file_path=file, encoding='utf8')\n", (13143, 13176), False, 'from langchain.document_loaders import UnstructuredPowerPointLoader, UnstructuredWordDocumentLoader, PyPDFLoader, UnstructuredFileLoader, CSVLoader, MWDumpLoader\n'), ((13258, 13286), 'langchain.document_loaders.UnstructuredFileLoader', 'UnstructuredFileLoader', (['file'], {}), '(file)\n', (13280, 13286), False, 'from langchain.document_loaders import UnstructuredPowerPointLoader, UnstructuredWordDocumentLoader, PyPDFLoader, UnstructuredFileLoader, CSVLoader, MWDumpLoader\n')] |
import os
import re
import langchain
import paperqa
import paperscraper
from langchain.base_language import BaseLanguageModel
from langchain.tools import BaseTool
from pypdf.errors import PdfReadError
def paper_scraper(search: str, pdir: str = "query") -> dict:
try:
return paperscraper.search_papers(search, pdir=pdir)
except KeyError:
return {}
def paper_search(llm, query):
prompt = langchain.prompts.PromptTemplate(
input_variables=["question"],
template="""
I would like to find scholarly papers to answer
this question: {question}. Your response must be at
most 10 words long.
'A search query that would bring up papers that can answer
this question would be: '""",
)
query_chain = langchain.chains.llm.LLMChain(llm=llm, prompt=prompt)
if not os.path.isdir("./query"): # todo: move to ckpt
os.mkdir("query/")
search = query_chain.run(query)
print("\nSearch:", search)
papers = paper_scraper(search, pdir=f"query/{re.sub(' ', '', search)}")
return papers
def scholar2result_llm(llm, query, k=5, max_sources=2):
"""Useful to answer questions that require
technical knowledge. Ask a specific question."""
papers = paper_search(llm, query)
if len(papers) == 0:
return "Not enough papers found"
docs = paperqa.Docs(llm=llm)
not_loaded = 0
for path, data in papers.items():
try:
docs.add(path, data["citation"])
except (ValueError, FileNotFoundError, PdfReadError):
not_loaded += 1
print(f"\nFound {len(papers.items())} papers but couldn't load {not_loaded}")
answer = docs.query(query, k=k, max_sources=max_sources).formatted_answer
return answer
class Scholar2ResultLLM(BaseTool):
name = "LiteratureSearch"
description = (
"Useful to answer questions that require technical "
"knowledge. Ask a specific question."
)
llm: BaseLanguageModel = None
def __init__(self, llm):
super().__init__()
self.llm = llm
def _run(self, query) -> str:
return scholar2result_llm(self.llm, query)
async def _arun(self, query) -> str:
"""Use the tool asynchronously."""
raise NotImplementedError("this tool does not support async")
| [
"langchain.chains.llm.LLMChain",
"langchain.prompts.PromptTemplate"
] | [((419, 753), 'langchain.prompts.PromptTemplate', 'langchain.prompts.PromptTemplate', ([], {'input_variables': "['question']", 'template': '"""\n I would like to find scholarly papers to answer\n this question: {question}. Your response must be at\n most 10 words long.\n \'A search query that would bring up papers that can answer\n this question would be: \'"""'}), '(input_variables=[\'question\'], template=\n """\n I would like to find scholarly papers to answer\n this question: {question}. Your response must be at\n most 10 words long.\n \'A search query that would bring up papers that can answer\n this question would be: \'"""\n )\n', (451, 753), False, 'import langchain\n'), ((786, 839), 'langchain.chains.llm.LLMChain', 'langchain.chains.llm.LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (815, 839), False, 'import langchain\n'), ((1360, 1381), 'paperqa.Docs', 'paperqa.Docs', ([], {'llm': 'llm'}), '(llm=llm)\n', (1372, 1381), False, 'import paperqa\n'), ((289, 334), 'paperscraper.search_papers', 'paperscraper.search_papers', (['search'], {'pdir': 'pdir'}), '(search, pdir=pdir)\n', (315, 334), False, 'import paperscraper\n'), ((851, 875), 'os.path.isdir', 'os.path.isdir', (['"""./query"""'], {}), "('./query')\n", (864, 875), False, 'import os\n'), ((907, 925), 'os.mkdir', 'os.mkdir', (['"""query/"""'], {}), "('query/')\n", (915, 925), False, 'import os\n'), ((1042, 1065), 're.sub', 're.sub', (['""" """', '""""""', 'search'], {}), "(' ', '', search)\n", (1048, 1065), False, 'import re\n')] |
"""
Class for Langchain chain, this chain makes a request to OpenAI to provide information
in a given location and time period.
"""
import os
import logging
from pathlib import Path
import langchain
PROMPT_STRING = """
You just gave historical information for {location} around the time period of {time_period} and \n
this is the answer you gave {previous_response}. \n
Provide bullet points in relation to what you said previously with more information around this topic: {selected_text}. \n
Provide no filler or conversation response, just detailed bullet points.\n
If you are unsure of the history for this time period, explain that the for this area and time period
is limited. \n\n
"""
class FollowUpChain():
def __init__(self, openai_api_key, model):
super().__init__()
self.openai_api_key = openai_api_key
self.llm_chains = [] # Buffer to store LLMChain objects
self.model = model
# Add LLMChain objects to the buffer
self.add_chain(self.get_history_chain())
def add_chain(self, llm_chain):
self.llm_chains.append(llm_chain)
def get_template(self, input):
# Create the first PromptTemplate
prompt = langchain.PromptTemplate(
input_variables=input,
template=PROMPT_STRING
)
return prompt
def get_history_chain(self):
prompt_1 = self.get_template(input=["location", "time_period", "previous_response", "selected_text"])
return langchain.LLMChain(llm=langchain.OpenAI(
openai_api_key=self.openai_api_key,
model_name=self.model), prompt=prompt_1)
def run(self, input_text):
llm_1 = self.llm_chains[0].run(input_text)
# Return the results
return {
"response": llm_1,
} | [
"langchain.OpenAI",
"langchain.PromptTemplate"
] | [((1201, 1272), 'langchain.PromptTemplate', 'langchain.PromptTemplate', ([], {'input_variables': 'input', 'template': 'PROMPT_STRING'}), '(input_variables=input, template=PROMPT_STRING)\n', (1225, 1272), False, 'import langchain\n'), ((1512, 1587), 'langchain.OpenAI', 'langchain.OpenAI', ([], {'openai_api_key': 'self.openai_api_key', 'model_name': 'self.model'}), '(openai_api_key=self.openai_api_key, model_name=self.model)\n', (1528, 1587), False, 'import langchain\n')] |
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from langchain.chains import LLMChain
from langchain.prompts.few_shot import FewShotPromptTemplate
def get_prompt(is_zh: bool = False, sydney: bool = False) -> 'FewShotPromptTemplate':
from langchain.prompts.few_shot import FewShotPromptTemplate
from langchain.prompts.prompt import PromptTemplate
langwhat_example_prompt = PromptTemplate(
input_variables=["question", "answer"], template="Q: {question}\n{answer}"
)
langwhat_examples = [
{
"question": "vJzDRsEKDa0",
"answer": """
Might be:
A YouTube video ID
Description:
The ID "vJzDRsEKDa0" is most likely a unique identifier for a specific video on YouTube.
This alphanumeric code is automatically assigned to every video uploaded on the platform and is used to access the video directly or share it with other users.
""",
},
{
"question": "https://langchain.readthedocs.io/",
"answer": """
Might be:
A website or online documentation
Description:
This website/document provides information about LangChain, a technology or platform that could be used for language processing or analysis.
""",
},
]
langwhat_examples_zh = [
{
"question": "vJzDRsEKDa0",
"answer": """
可能是:
YouTube 视频 ID
描述:
“vJzDRsEKDa0”这个ID很可能是YouTube上特定视频的唯一标识符。
每上传一个视频，该平台都会自动分配这个字母数字代码，并用于直接访问或与其他用户共享该视频。
""",
},
{
"question": "https://langchain.readthedocs.io/",
"answer": """
可能是:
一个网站或在线文档
描述:
这个网站/文件提供有关LangChain的信息，它是一种可用于语言处理或分析的技术或平台。
""",
},
]
prefix_sydney = '''
You are a helpful assistant that answer questions in the format below,
you must answer the question only, do not ask what I want to know more about:
"""
'''.lstrip()
suffix_sydney = '''"""\n\nBEGIN!\n\nQ: {input}'''
suffix_openai = '''\nQ: {input}'''
langwhat_prompt = FewShotPromptTemplate(
example_prompt=langwhat_example_prompt,
examples=langwhat_examples_zh if is_zh else langwhat_examples,
suffix=suffix_sydney if sydney else suffix_openai,
prefix=prefix_sydney if sydney else '',
input_variables=["input"],
)
return langwhat_prompt
def get_llm_chain(
is_zh: bool = False, sydney: bool = False, cookie_path: str | None = None
) -> 'LLMChain':
from langchain.llms import OpenAIChat
from langchain.chains import LLMChain
from .llm import EdgeLLM
if sydney:
if cookie_path is None:
raise ValueError("cookie_path is required for sydney.")
llm = EdgeLLM(bing_cookie_path=cookie_path)
else:
llm = OpenAIChat() # type: ignore
langwhat_prompt = get_prompt(is_zh=is_zh, sydney=sydney)
chain = LLMChain(llm=llm, prompt=langwhat_prompt)
return chain
def parse_standard_answer_format(answer: str) -> tuple[str, str]:
ans_lines = answer.strip().splitlines()
might_be = ans_lines[1]
description = '\n'.join(ans_lines[3:])
description = description.replace("\n", ",\r\n")
# description = description.replace(",", ",\r\n")
# description = description.replace("，", "，\r\n")
# description = description.replace("。", "。\r\n")
# description = description.replace(".", ".\r\n")
return might_be, description
def parse_chain_response(chain_response: dict[str, str]) -> tuple[str, str, str]:
"""Parse the response from the chain.
Args:
chain_response (dict[str, str]): The response from the chain.
Returns:
tuple[str, str]: The first element is the might be, the second element is the description.
"""
answer = chain_response['text']
return split_edgegpt_answer(answer)
def split_edgegpt_answer(answer: str) -> tuple[str, str, str]:
answer = answer.strip()
if answer.startswith('['):
references, answer_body = answer.split('\n\n', maxsplit=1)
references = references.strip()
answer_body = answer_body.strip()
else:
references = ''
answer_body = answer
return references, *parse_standard_answer_format(answer_body)
def use_langchain_sqlite_cache():
import langchain
from langchain.cache import SQLiteCache
from .config import LANGCHAIN_SQLITE_CACHE_FILE
langchain.llm_cache = SQLiteCache(database_path=str(LANGCHAIN_SQLITE_CACHE_FILE))
| [
"langchain.chains.LLMChain",
"langchain.prompts.few_shot.FewShotPromptTemplate",
"langchain.llms.OpenAIChat",
"langchain.prompts.prompt.PromptTemplate"
] | [((400, 498), 'langchain.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['question', 'answer']", 'template': '"""Q: {question}\n{answer}"""'}), '(input_variables=[\'question\', \'answer\'], template=\n """Q: {question}\n{answer}""")\n', (414, 498), False, 'from langchain.prompts.prompt import PromptTemplate\n'), ((1960, 2216), 'langchain.prompts.few_shot.FewShotPromptTemplate', 'FewShotPromptTemplate', ([], {'example_prompt': 'langwhat_example_prompt', 'examples': '(langwhat_examples_zh if is_zh else langwhat_examples)', 'suffix': '(suffix_sydney if sydney else suffix_openai)', 'prefix': "(prefix_sydney if sydney else '')", 'input_variables': "['input']"}), "(example_prompt=langwhat_example_prompt, examples=\n langwhat_examples_zh if is_zh else langwhat_examples, suffix=\n suffix_sydney if sydney else suffix_openai, prefix=prefix_sydney if\n sydney else '', input_variables=['input'])\n", (1981, 2216), False, 'from langchain.prompts.few_shot import FewShotPromptTemplate\n'), ((2800, 2841), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'langwhat_prompt'}), '(llm=llm, prompt=langwhat_prompt)\n', (2808, 2841), False, 'from langchain.chains import LLMChain\n'), ((2698, 2710), 'langchain.llms.OpenAIChat', 'OpenAIChat', ([], {}), '()\n', (2708, 2710), False, 'from langchain.llms import OpenAIChat\n')] |
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores.faiss import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
from langchain.chat_models import ChatOpenAI
from PyPDF2 import PdfReader
import langchain
import requests
import io
import docx
import json
langchain.verbose = False
def get_text_from_files(file_list):
text = ""
for file in file_list:
ext_name = file.split(".")[-1].lower()
response = requests.get(file)
if ext_name == "pdf":
##load pdf from url
pdf_reader = PdfReader(io.BytesIO(response.content))
# pdf_reader = PdfReader(file)
for page in pdf_reader.pages:
text += page.extract_text()
elif ext_name == "txt":
#load txt from url
text = response.content.decode("utf-8")
elif ext_name == "docx":
#load docx from url
docx_file = io.BytesIO(response.content)
doc = docx.Document(docx_file)
for para in doc.paragraphs:
text += para.text
return text
def get_text_chunks(text):
text_splitter = CharacterTextSplitter(
separator="\n",
chunk_size=800,
chunk_overlap=200,
length_function=len,
)
chunks = text_splitter.split_text(text)
return chunks
##get keys from .env file
import os
# from dotenv import load_dotenv
# load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
def get_vectorstore(text_chunks):
embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
vector_store = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
return vector_store
def get_conversation_chain(vectorstore):
llm = ChatOpenAI(openai_api_key=openai_api_key,
temperature=0.25)
memory = ConversationBufferMemory(memory_key='chat_history', return_messages=True)
conversation_chain = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=vectorstore.as_retriever(),
memory=memory,
)
return conversation_chain
def process(text_info,files_or_urls,questions):
conversation=None
if text_info:
raw_text = str(text_info)
else:
raw_text = ""
## allow if only text is input
if files_or_urls:
raw_text = raw_text+ "\n" + str(get_text_from_files(files_or_urls))
text_chunks = get_text_chunks(raw_text)
vectorstore = get_vectorstore(text_chunks)
conversation = get_conversation_chain(vectorstore)
for user_question in questions:
response = conversation({'question': user_question})
chat_history = response['chat_history']
data={}
for i, message in enumerate(chat_history):
if i % 2 == 0:
key=message.content
else:
data[key]=message.content
return data
def lambda_handler(event, context):
# TODO implement
result=process(text_info=event['text_info'],files_or_urls=event['files_or_urls'],questions=event['questions'])
return {
'statusCode': 200,
'body': json.dumps(result)
}
| [
"langchain.text_splitter.CharacterTextSplitter",
"langchain.chat_models.ChatOpenAI",
"langchain.embeddings.OpenAIEmbeddings",
"langchain.memory.ConversationBufferMemory",
"langchain.vectorstores.faiss.FAISS.from_texts"
] | [((1580, 1607), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (1589, 1607), False, 'import os\n'), ((1282, 1379), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'separator': '"""\n"""', 'chunk_size': '(800)', 'chunk_overlap': '(200)', 'length_function': 'len'}), "(separator='\\n', chunk_size=800, chunk_overlap=200,\n length_function=len)\n", (1303, 1379), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((1660, 1707), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'openai_api_key'}), '(openai_api_key=openai_api_key)\n', (1676, 1707), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((1727, 1784), 'langchain.vectorstores.faiss.FAISS.from_texts', 'FAISS.from_texts', ([], {'texts': 'text_chunks', 'embedding': 'embeddings'}), '(texts=text_chunks, embedding=embeddings)\n', (1743, 1784), False, 'from langchain.vectorstores.faiss import FAISS\n'), ((1861, 1920), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': 'openai_api_key', 'temperature': '(0.25)'}), '(openai_api_key=openai_api_key, temperature=0.25)\n', (1871, 1920), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1955, 2028), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(memory_key='chat_history', return_messages=True)\n", (1979, 2028), False, 'from langchain.memory import ConversationBufferMemory\n'), ((578, 596), 'requests.get', 'requests.get', (['file'], {}), '(file)\n', (590, 596), False, 'import requests\n'), ((3216, 3234), 'json.dumps', 'json.dumps', (['result'], {}), '(result)\n', (3226, 3234), False, 'import json\n'), ((707, 735), 'io.BytesIO', 'io.BytesIO', (['response.content'], {}), '(response.content)\n', (717, 735), False, 'import io\n'), ((1072, 1100), 'io.BytesIO', 'io.BytesIO', (['response.content'], {}), '(response.content)\n', (1082, 1100), False, 'import io\n'), ((1119, 1143), 'docx.Document', 'docx.Document', (['docx_file'], {}), '(docx_file)\n', (1132, 1143), False, 'import docx\n')] |
import zipfile
from langchain.chat_models import ChatOpenAI
from langchain.schema import (
HumanMessage,
SystemMessage
)
import langchain
from langchain.cache import SQLiteCache
langchain.llm_cache = SQLiteCache(
database_path=".langchain.db"
) # caches queries that are the same.
def generate_code(question, model_type, api_key):
"""
Generate Python code script. The script should only include code, no comments.
What is returned is code that needs some light modification.
"""
task = "Generate Python Code Script. The script should only include code, no comments."
chat_model = ChatOpenAI(temperature=0, model=model_type, openai_api_key = api_key)
response = chat_model(
messages=[
SystemMessage(content=task),
HumanMessage(content=question)
],
)
code = response.content
return format_code(code)
def format_code(code):
"""
Format the generated code to remove read_csv if its there.
"""
csv_line_index = code.find("read_csv")
if csv_line_index > 0:
before_csv_line_index = code[0:csv_line_index].rfind("\n")
before_csv = (
"" if before_csv_line_index == -1 else code[0:before_csv_line_index]
)
after_csv = code[csv_line_index:]
after_csv_line_index = after_csv.find("\n")
after_csv = (
"" if after_csv_line_index == -1 else after_csv[after_csv_line_index:]
)
return before_csv + after_csv
return code
def format_primer(primer_desc, primer_code, question):
"""
Format the primer description and code.
"""
return f'"""\n{primer_desc}{question}\n"""\n{primer_code}'
def generate_primer(df, df_name):
"""
Generate a primer for visualization. Include all the necessary imports.
"""
primer_desc = """
If a graph is needed, label the x and y axes appropriately.
Add a title. Use st.plotly or plotly.express to visualize."
Using Python version 3.9.12, only create a script using the dataframe "df" if the user asked for a graph.
Do not give a y/n answer in the code or try to take any user input.
Graph should be created using st.plotly or plotly.express. If there is only a single row, manipulate it to be able to chart the data.
IF the given sql query is only one column, manipulate it to get it in the right format for a chart if it has multiple rows.
If its just one column one row, don't chart, just display the table.
Make sure that variable names are the same as the sql.
"""
primer_code = (
"import pandas as pd\nimport streamlit as st\nimport plotly.express as px\n"
)
primer_code += f"df = {df_name}.copy()\n"
return primer_desc, primer_code
def unzip(file):
with zipfile.ZipFile(file, 'r') as zip_ref:
zip_ref.extractall()
| [
"langchain.schema.SystemMessage",
"langchain.cache.SQLiteCache",
"langchain.schema.HumanMessage",
"langchain.chat_models.ChatOpenAI"
] | [((211, 253), 'langchain.cache.SQLiteCache', 'SQLiteCache', ([], {'database_path': '""".langchain.db"""'}), "(database_path='.langchain.db')\n", (222, 253), False, 'from langchain.cache import SQLiteCache\n'), ((621, 688), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model': 'model_type', 'openai_api_key': 'api_key'}), '(temperature=0, model=model_type, openai_api_key=api_key)\n', (631, 688), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2781, 2807), 'zipfile.ZipFile', 'zipfile.ZipFile', (['file', '"""r"""'], {}), "(file, 'r')\n", (2796, 2807), False, 'import zipfile\n'), ((749, 776), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'task'}), '(content=task)\n', (762, 776), False, 'from langchain.schema import HumanMessage, SystemMessage\n'), ((790, 820), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'question'}), '(content=question)\n', (802, 820), False, 'from langchain.schema import HumanMessage, SystemMessage\n')] |
import langchain
from langchain.chat_models import ChatOpenAI
from langchain_core.tools import Tool
langchain.verbose = True
langchain.debug = True
def get_chat():
return ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0)
def my_super_func(params):
return 42
if __name__ == "__main__":
tools = [
Tool.from_function(
func=my_super_func,
name="The_Answer",
description="生命、宇宙、そして万物について究極の疑問の答え"
),
]
| [
"langchain.chat_models.ChatOpenAI",
"langchain_core.tools.Tool.from_function"
] | [((178, 231), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': '(0)'}), "(model_name='gpt-3.5-turbo', temperature=0)\n", (188, 231), False, 'from langchain.chat_models import ChatOpenAI\n'), ((326, 427), 'langchain_core.tools.Tool.from_function', 'Tool.from_function', ([], {'func': 'my_super_func', 'name': '"""The_Answer"""', 'description': '"""生命、宇宙、そして万物について究極の疑問の答え"""'}), "(func=my_super_func, name='The_Answer', description=\n '生命、宇宙、そして万物について究極の疑問の答え')\n", (344, 427), False, 'from langchain_core.tools import Tool\n')] |
import os
import tkinter as tk
from tkinter import Label, Entry, Button, Text, Scrollbar
import langchain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chat_models import ChatOpenAI
class ProjectEvaluatorApp:
def __init__(self, root):
self.root = root
self.root.title('Project Evaluator')
self.experience_label = Label(root, text='Rate your coding ability on a scale of 1 to 5:')
self.experience_input = Entry(root)
self.frameworks_label = Label(root, text='Which coding languages have you used?')
self.frameworks_input = Entry(root)
self.learn_label = Label(root, text='What would you like to learn?')
self.learn_input = Entry(root)
self.evaluate_button = Button(root, text='Evaluate Project', command=self.evaluate_project)
self.result_text = Text(root, wrap='word', height=10, width=50)
self.result_scrollbar = Scrollbar(root, command=self.result_text.yview)
self.result_text['yscrollcommand'] = self.result_scrollbar.set
self.experience_label.pack()
self.experience_input.pack()
self.frameworks_label.pack()
self.frameworks_input.pack()
self.learn_label.pack()
self.learn_input.pack()
self.evaluate_button.pack()
self.result_text.pack(side='left', padx=5)
self.result_scrollbar.pack(side='right', fill='y') # Corrected argument
def evaluate_project(self):
experience_level = self.experience_input.get()
frameworks_used = self.frameworks_input.get()
what_to_learn = self.learn_input.get()
CREATE_CONTEXT_PROMPT = f"""Summarize this student's coding experience level and learning goals using the following information:
The student's experience level on a scale of 0 to 5: {experience_level}
The coding languages the student has used: {frameworks_used}
The thing the student wants to learn: {what_to_learn}"""
llm = ChatOpenAI(
openai_api_key=os.environ["OPENAI_API_KEY"],
model_name='gpt-4',
temperature=0.0
)
context = llm.invoke(CREATE_CONTEXT_PROMPT)
PROMPT = f"""You are evaluating potential project ideas. Each idea has a hierarchy based on difficulty and applicability in the industry, rated on a scale from 1 to 5. Your goal is to organize these ideas in ascending order of difficulty and descending order of applicability: {context} Given their coding experience, what simple example project could the student build to learn the topic they want to learn? """
project = llm.invoke(str(PROMPT))
self.result_text.config(state='normal') # Enable editing
self.result_text.delete('1.0', 'end') # Clear preavious content
self.result_text.insert('1.0', f"{project}\n") # Insert new content
self.result_text.config(state='disabled') # Disable editing
if __name__ == '__main__':
root = tk.Tk()
app = ProjectEvaluatorApp(root)
root.mainloop() | [
"langchain.chat_models.ChatOpenAI"
] | [((3005, 3012), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (3010, 3012), True, 'import tkinter as tk\n'), ((380, 446), 'tkinter.Label', 'Label', (['root'], {'text': '"""Rate your coding ability on a scale of 1 to 5:"""'}), "(root, text='Rate your coding ability on a scale of 1 to 5:')\n", (385, 446), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((479, 490), 'tkinter.Entry', 'Entry', (['root'], {}), '(root)\n', (484, 490), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((524, 581), 'tkinter.Label', 'Label', (['root'], {'text': '"""Which coding languages have you used?"""'}), "(root, text='Which coding languages have you used?')\n", (529, 581), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((614, 625), 'tkinter.Entry', 'Entry', (['root'], {}), '(root)\n', (619, 625), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((654, 703), 'tkinter.Label', 'Label', (['root'], {'text': '"""What would you like to learn?"""'}), "(root, text='What would you like to learn?')\n", (659, 703), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((731, 742), 'tkinter.Entry', 'Entry', (['root'], {}), '(root)\n', (736, 742), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((775, 843), 'tkinter.Button', 'Button', (['root'], {'text': '"""Evaluate Project"""', 'command': 'self.evaluate_project'}), "(root, text='Evaluate Project', command=self.evaluate_project)\n", (781, 843), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((872, 916), 'tkinter.Text', 'Text', (['root'], {'wrap': '"""word"""', 'height': '(10)', 'width': '(50)'}), "(root, wrap='word', height=10, width=50)\n", (876, 916), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((949, 996), 'tkinter.Scrollbar', 'Scrollbar', (['root'], {'command': 'self.result_text.yview'}), '(root, command=self.result_text.yview)\n', (958, 996), False, 'from tkinter import Label, Entry, Button, Text, Scrollbar\n'), ((2024, 2120), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': "os.environ['OPENAI_API_KEY']", 'model_name': '"""gpt-4"""', 'temperature': '(0.0)'}), "(openai_api_key=os.environ['OPENAI_API_KEY'], model_name='gpt-4',\n temperature=0.0)\n", (2034, 2120), False, 'from langchain.chat_models import ChatOpenAI\n')] |
from __future__ import annotations
from collections import OrderedDict
from typing import Any, Dict, List, Optional, Tuple
import langchain
import numpy as np
import orjson
import pandas as pd
from langchain.cache import InMemoryCache
from peewee import ModelSelect, fn
from .constants import *
from .orm import Knowledge, Solution, Space, Task, database_proxy
from .utils import format_config, get_llm
SAVE_OPTIONS = orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_SERIALIZE_DATACLASS
langchain.llm_cache = InMemoryCache()
def ingest_experience(
history_df: pd.DataFrame,
task_desc: Optional[Dict[str, str]],
space_desc: str,
space_id: str,
) -> Space:
"""Ingest experience from history dataframe.
Parameters
----------
history_df: pandas.DataFrame
The history of configurations.
task_desc
The task descriptions.
space_desc
The space description.
space_id
The space id.
Returns
-------
None
Notes
-----
The history_df should be a dataframe with the following columns:
- CONFIG_0
- CONFIG_1
- ...
- CONFIG_N
- METRIC
The task_desc should be a dict with the following format:
{
"task_id_0": "task_description_0",
"task_id_1": "task_description_1",
...
"task_id_N": "task_description_N"
}
"""
history_df = history_df.drop_duplicates()
history_df["TASK_ID"] = history_df["TASK_ID"].astype(str)
if task_desc is None:
task_desc = {k: "." for k in history_df["TASK_ID"].unique()}
experience_df = history_df[
history_df[["TASK_ID", "SCORE"]]
.groupby("TASK_ID")
.rank(method="first", ascending=False)["SCORE"]
<= TOP_K
]
quantile_info = get_quantile_stat(experience_df)
space = _ingest_space(space_id, space_desc, quantile_info)
_ingest_task(history_df, task_desc)
_ingest_solution(history_df, space)
print("Ingested experience into database.")
# save db
database_proxy.commit()
return space
def _ingest_space(
space_id: str, space_desc: str, quantile_info: Dict[str, List[float]]
) -> Space:
with database_proxy.atomic():
try:
space = Space.get(Space.space_id == space_id)
print(f"Space {space_id} already exists, skip ingestion.")
return space
except:
space = Space.create(
space_id=space_id,
desc=space_desc,
quantile_info=orjson.dumps(quantile_info, option=SAVE_OPTIONS),
)
print("Ingested space into database.")
# save db
database_proxy.commit()
return space
def _ingest_task(history_df: pd.DataFrame, row_task_desc: Dict[str, str]) -> None:
embeddings = get_llm("embedding")()
with database_proxy.atomic():
for task_id in history_df["TASK_ID"].unique():
try:
Task.get(Task.task_id == task_id)
print(f"Task {task_id} already exists, skip ingestion.")
continue
except Task.DoesNotExist:
task_desc = canonicalize_task(row_task_desc[task_id])
embedding = np.asarray(
embeddings.embed_query(task_desc), dtype=np.float32
).tobytes()
Task.create(
task_id=task_id,
embedding=embedding,
desc=task_desc,
row_desc=row_task_desc[task_id],
)
print("Ingested task into database.")
# save db
database_proxy.commit()
def _ingest_solution(history_df: pd.DataFrame, space: Space) -> None:
with database_proxy.atomic():
solutions = []
for _, row in (
history_df.groupby("TASK_ID")
.apply(lambda x: x.sort_values("SCORE", ascending=False))
.reset_index(drop=True)
.iterrows()
):
row_config_dict = {
k[7:]: v for k, v in row.to_dict().items() if k.startswith("CONFIG_")
}
row_config = orjson.dumps((row_config_dict), option=SAVE_OPTIONS)
try:
Solution.get(
Solution.task == row["TASK_ID"],
Solution.space == space.space_id,
Solution.row_config == row_config,
)
print(
f"Solution '{row_config}' for space {space.space_id} and task {row['TASK_ID']} already exists, skip ingestion."
)
continue
except Solution.DoesNotExist:
solutions.append(
{
"task": row["TASK_ID"],
"space": space,
"metric": row["SCORE"],
"row_config": row_config,
"extra_metric": row.get("EXTRA_METRIC", ""),
"demo": canonicalize_config(
row_config_dict, orjson.loads(space.quantile_info)
),
}
)
Solution.insert_many(solutions).execute()
print("Ingested solution into database.")
# save db
database_proxy.commit()
def canonicalize_task(row_task_desc: str) -> str:
"""
Canonicalize task to a string.
Parameters
----------
row_task_desc: str
The task description.
Returns
-------
str
The canonicalized task description.
"""
task_desc = f"Task: {row_task_desc}"
return task_desc
def canonicalize_config(
config_term: Dict[str, Any], quantile_info: Dict[str, List[float]]
) -> str:
"""
Canonicalize configuration to a string.
Parameters
----------
config_term
The configuration term.
quantile_info
The meta train info for stat. Record quantile information for each hyperparameter.
Returns
-------
str
The canonicalized configuration.
"""
demo = format_config(config_term, quantile_info, bin_map=bin_map)
return demo
def get_quantile_stat(experience_df: pd.DataFrame) -> Dict[str, List[float]]:
"""
Get quantile stat from experience dataframe.
Parameters
----------
experience_df: pandas.DataFrame
The experience dataframe.
Returns
-------
Dict[str, List[float]]
The quantile stat.
"""
# map column name 'CONFIG_{}' to '{}', rest of columns are deleted
meta_train_df_for_stat = experience_df.rename(
columns=lambda x: x[7:] if x.startswith("CONFIG_") else None
)
del meta_train_df_for_stat[None]
try:
quantile_info = {
col: np.quantile(
meta_train_df_for_stat[col][~meta_train_df_for_stat[col].isna()],
list(bin_map.keys()),
method="nearest",
)
.astype(np.float32)
.tolist()
for col in meta_train_df_for_stat.select_dtypes(include=[np.number])
}
except:
quantile_info = {
col: np.quantile(
meta_train_df_for_stat[col][~meta_train_df_for_stat[col].isna()],
list(bin_map.keys()),
interpolation="nearest",
)
.astype(np.float32)
.tolist()
for col in meta_train_df_for_stat.select_dtypes(include=[np.number])
}
return quantile_info
def gen_experience_per_task(space: Space, task: Task) -> str:
"""
Generate experience content from space and task.
Parameters
----------
task_desc: str
The task description.
demos: str
The demos.
example:
Configurations 1: ...
Configurations 2: ...
Configurations 3: ...
Returns
-------
str
The experience content.
"""
demos = _gen_experience_demos(space, task)
content = f"{task.desc}\n{demos}"
return content
def _gen_experience_demos(space: Space, task: Task) -> str:
"""
Generate experience demonstrations
Parameters
----------
space: Space
The space.
task: Task
The task.
Returns
-------
str
The experience demonstrations per task.
"""
solutions = (
Solution.select()
.where(Solution.task_id == task.task_id, Solution.space_id == space.space_id)
.order_by(Solution.metric.desc())
.limit(TOP_K)
)
demos = "\n".join(
[
f"Configuration {i+1}: {solution.demo}"
for i, solution in enumerate(solutions)
]
)
return demos
def _get_best_relevant_solutions(space: Space, task_desc: str) -> ModelSelect:
"""
Get the best relevant solution for a task.
The relevance is measured by cosine similarity between task description embeddings, which affects the order of results.
Parameters
----------
space: Space
The space.
task_desc: str
The task description.
Returns
-------
ModelSelect
The best relevant solution.
"""
SolutionAlias = Solution.alias()
order_key = Task.embedding.cosine_distance(task_desc)
subquery = (
SolutionAlias.select(
SolutionAlias.demo,
Task.task_id,
Task.desc,
Task.embedding,
fn.ROW_NUMBER()
.over(
partition_by=[SolutionAlias.space, SolutionAlias.task],
order_by=[SolutionAlias.metric.desc()],
)
.alias("rnk"),
)
.where(SolutionAlias.space == space)
.join(Task, on=(SolutionAlias.task == Task.task_id))
.order_by(order_key)
.alias("subq")
)
query = (
Solution.select(subquery.c.task_id, subquery.c.demo, subquery.c.desc)
.from_(subquery)
.where(subquery.c.rnk <= TOP_K)
)
return query
def _get_best_solutions(space: Space) -> ModelSelect:
"""
Get the best solution for each task.
Parameters
----------
space: Space
The space.
Returns
-------
ModelSelect
The best solution for each task.
"""
SolutionAlias = Solution.alias()
subquery = (
SolutionAlias.select(
SolutionAlias.demo,
Task.task_id,
Task.desc,
Task.embedding,
fn.ROW_NUMBER()
.over(
partition_by=[SolutionAlias.space, SolutionAlias.task],
order_by=[SolutionAlias.metric.desc()],
)
.alias("rnk"),
)
.where(SolutionAlias.space == space)
.join(Task, on=(SolutionAlias.task == Task.task_id))
.alias("subq")
)
query = (
Solution.select(subquery.c.task_id, subquery.c.demo, subquery.c.desc)
.from_(subquery)
.where(subquery.c.rnk <= TOP_K)
)
return query
def gen_experience(
space: Space, task_desc: Optional[str] = None
) -> Tuple[List[str], List[str]]:
"""
Generate experience content from space and optional task description.
Parameters
----------
space: Space
The space.
task_desc
The task description.
Returns
-------
List[str]
The experience content.
"""
if task_desc is None:
query = _get_best_solutions(space)
else:
query = _get_best_relevant_solutions(space, task_desc)
examples = OrderedDict()
for solution in query:
if solution.task_id not in examples:
examples[solution.task_id] = [solution.desc]
examples[solution.task_id].append(
f"Configuration {len(examples[solution.task_id])}: {solution.demo}"
)
return list(examples.keys()), ["\n".join(e) for e in examples.values()]
| [
"langchain.cache.InMemoryCache"
] | [((506, 521), 'langchain.cache.InMemoryCache', 'InMemoryCache', ([], {}), '()\n', (519, 521), False, 'from langchain.cache import InMemoryCache\n'), ((11527, 11540), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (11538, 11540), False, 'from collections import OrderedDict\n'), ((4157, 4207), 'orjson.dumps', 'orjson.dumps', (['row_config_dict'], {'option': 'SAVE_OPTIONS'}), '(row_config_dict, option=SAVE_OPTIONS)\n', (4169, 4207), False, 'import orjson\n'), ((2552, 2600), 'orjson.dumps', 'orjson.dumps', (['quantile_info'], {'option': 'SAVE_OPTIONS'}), '(quantile_info, option=SAVE_OPTIONS)\n', (2564, 2600), False, 'import orjson\n'), ((5086, 5119), 'orjson.loads', 'orjson.loads', (['space.quantile_info'], {}), '(space.quantile_info)\n', (5098, 5119), False, 'import orjson\n'), ((10463, 10478), 'peewee.fn.ROW_NUMBER', 'fn.ROW_NUMBER', ([], {}), '()\n', (10476, 10478), False, 'from peewee import ModelSelect, fn\n'), ((9438, 9453), 'peewee.fn.ROW_NUMBER', 'fn.ROW_NUMBER', ([], {}), '()\n', (9451, 9453), False, 'from peewee import ModelSelect, fn\n')] |
import os
try:
from genai.credentials import Credentials
from genai.schemas import GenerateParams
from genai.extensions.langchain import LangChainInterface
from langchain import PromptTemplate
from langchain.chains import LLMChain, SimpleSequentialChain
except ImportError:
raise ImportError("Could not import langchain: Please install ibm-generative-ai[langchain] extension.")
"""
pip install "ibm-generative-ai[langchain]"
"""
# make sure you have a .env file under genai root with
api_key = os.getenv("GENAI_KEY", None)
api_url = os.getenv("GENAI_API", None)
# create creds for watsonx.ai models
creds = Credentials(api_key, api_endpoint=api_url)
params = GenerateParams(decoding_method="greedy", min_new_tokens=3, max_new_tokens=300)
#params = GenerateParams(decoding_method="greedy")
llmp = LangChainInterface(model="ibm/granite-13b-sft", params=params, credentials=creds)
# This is a simple example of a zero shot prompt
print(f"******************************************************")
print(f" ")
print(f"This is a simple zero shot prompt")
print(f" ")
print(f"******************************************************")
print(f" ")
print(f" ")
print(llmp("Explain Mortgage backed securities in one sentence"))
"""
Implement a Prompt PromptTemplate
"""
print(f" ")
print(f" ")
print(f"******************************************************")
print(f" ")
print(f"This is a sample using a Prompt Template")
print(f" ")
print(f"******************************************************")
print(f" ")
print(f" ")
template = """
You are a mortgage broker with exertise in financial product.
Explain the concept of {concept} in a paragraph.
"""
promptp = PromptTemplate(input_variables=["concept"],template=template,)
#print(promptp)
conceptp = "closing costs"
print(llmp(promptp.format(concept=conceptp)))
"""
Implement Chains: In this section I am taking the initial prompt response
and then asking the model to update the response.
"""
print(f"******************************************************")
print(f" ")
print(f" ")
print(f"This is an example of chaining 2 prompts together to have the second prompt work in the repsonse of the first prompt. We will be using the first Prompt template from above to feed the second Prompt Template, using a Simple Sequence Chain.")
print(f" ")
print(f" ")
print(f"******************************************************")
print(f" ")
print(f" ")
#print(promptp)
chain = LLMChain(llm=llmp, prompt=promptp)
#print(chain.run(conceptp))
second_prompt = PromptTemplate(
input_variables=["ml_concept"],
template="Turn this financial description {ml_concept} and explain in techncial terms")
chain_two = LLMChain(llm=llmp, prompt=second_prompt)
overall_chain = SimpleSequentialChain(chains=[chain, chain_two], verbose=True)
explanation = overall_chain.run(conceptp)
print(explanation)
| [
"langchain.chains.LLMChain",
"langchain.chains.SimpleSequentialChain",
"langchain.PromptTemplate"
] | [((520, 548), 'os.getenv', 'os.getenv', (['"""GENAI_KEY"""', 'None'], {}), "('GENAI_KEY', None)\n", (529, 548), False, 'import os\n'), ((559, 587), 'os.getenv', 'os.getenv', (['"""GENAI_API"""', 'None'], {}), "('GENAI_API', None)\n", (568, 587), False, 'import os\n'), ((634, 676), 'genai.credentials.Credentials', 'Credentials', (['api_key'], {'api_endpoint': 'api_url'}), '(api_key, api_endpoint=api_url)\n', (645, 676), False, 'from genai.credentials import Credentials\n'), ((686, 764), 'genai.schemas.GenerateParams', 'GenerateParams', ([], {'decoding_method': '"""greedy"""', 'min_new_tokens': '(3)', 'max_new_tokens': '(300)'}), "(decoding_method='greedy', min_new_tokens=3, max_new_tokens=300)\n", (700, 764), False, 'from genai.schemas import GenerateParams\n'), ((823, 909), 'genai.extensions.langchain.LangChainInterface', 'LangChainInterface', ([], {'model': '"""ibm/granite-13b-sft"""', 'params': 'params', 'credentials': 'creds'}), "(model='ibm/granite-13b-sft', params=params, credentials=\n creds)\n", (841, 909), False, 'from genai.extensions.langchain import LangChainInterface\n'), ((1698, 1760), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['concept']", 'template': 'template'}), "(input_variables=['concept'], template=template)\n", (1712, 1760), False, 'from langchain import PromptTemplate\n'), ((2476, 2510), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llmp', 'prompt': 'promptp'}), '(llm=llmp, prompt=promptp)\n', (2484, 2510), False, 'from langchain.chains import LLMChain, SimpleSequentialChain\n'), ((2556, 2700), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['ml_concept']", 'template': '"""Turn this financial description {ml_concept} and explain in techncial terms"""'}), "(input_variables=['ml_concept'], template=\n 'Turn this financial description {ml_concept} and explain in techncial terms'\n )\n", (2570, 2700), False, 'from langchain import PromptTemplate\n'), ((2713, 2753), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llmp', 'prompt': 'second_prompt'}), '(llm=llmp, prompt=second_prompt)\n', (2721, 2753), False, 'from langchain.chains import LLMChain, SimpleSequentialChain\n'), ((2770, 2832), 'langchain.chains.SimpleSequentialChain', 'SimpleSequentialChain', ([], {'chains': '[chain, chain_two]', 'verbose': '(True)'}), '(chains=[chain, chain_two], verbose=True)\n', (2791, 2832), False, 'from langchain.chains import LLMChain, SimpleSequentialChain\n')] |
#%% Import Flask and create an app object
import config
from dotenv import load_dotenv
load_dotenv()
import os
import json
import asyncio
import openai
import pprint as pp
import markdown
# openai.api_key = os.getenv("OPENAI_API_KEY")
# os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
# Import Flask and create an app object
from flask import Flask, render_template, request, jsonify
app = Flask(__name__)
# Import asyncio and the async_playwright module from Playwright
import asyncio
from playwright.async_api import async_playwright
# Import LangChain and other modules
import langchain
from langchain.agents import AgentType
from langchain.chat_models import ChatOpenAI
from langchain.agents import initialize_agent, load_tools
from langchain.agents.agent_toolkits import PlayWrightBrowserToolkit
from langchain.tools.playwright.utils import (
create_async_playwright_browser,
create_sync_playwright_browser, # A synchronous browser is available, though it isn't compatible with jupyter.
)
# This import is required only for jupyter notebooks, since they have their own eventloop
# import nest_asyncio
# nest_asyncio.apply()
#%% Agent
def get_agent():
# LLM using ChatOpenAI
llm = ChatOpenAI(model_name="gpt-4", temperature=0) # Also works well with Anthropic models
# Get the tools from the toolkit
tools = load_tools(["serpapi"], llm=llm)
# Create an agent using ChatOpenAI and initialize it with tools and handle_parsing_errors=True
agent_chain = initialize_agent(
tools=tools,
llm=llm,
agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
handle_parsing_errors=True
)
# agent_chain = get_agent()
#%%
@app.route("/")
def home():
# Use some initial chat history (empty, in this case)
chat_history = []
return render_template("chat.html", chat_history=chat_history)
@app.route("/respond")
def respond():
""" Create another route for your chatbot logic
"""
print("\nrespond::start:")
# Get the user message and the chat history from the interface
message = request.args.get("message")
print(f" respond::message: {message}")
# Parse the chat history as a JSON object
chat_history = json.loads(request.args.get("chat_history", "[]"))
print(f" respond::chat_history: {chat_history}")
# Run your main coroutine that handles the chatbot logic
# response = asyncio.run(main(message, chat_history))
chat_history = main(message, chat_history)
response = jsonify({"chat_history": chat_history})
print("\nrespond::return:")
print(f" respond::chat_history: {chat_history}")
# print response to console as json
pp.pprint(response.json)
# Return the response as a JSON string
return response
def main(message, chat_history):
""" Define your main coroutine that handles the chatbot logic
"""
print("\nmain::start:")
print(f" main::message: {message}")
print(f" main::chat_history: {chat_history}")
# Run your agent chain with the user message as input and get the bot message as output
bot_message = "I'm a STICK!!!\n\n```python\nprint('Hello World')\n```"
# Convert bot_message to HTML
bot_message_html = markdown.markdown(bot_message)
# Append the user message and the bot message to the chat history
chat_history[-1][1] = bot_message_html
print("\nmain::return:")
print(f" main::bot_message: {bot_message}")
print(f" main::bot_message_html: {bot_message_html}")
print(f" main::chat_history: {chat_history}")
# Return the updated chat history as a string
return chat_history
# def main(message, chat_history):
# """ Define your main coroutine that handles the chatbot logic
# """
# print("\nmain::start:")
# print(f" main::message: {message}")
# print(f" main::chat_history: {chat_history}")
# # Run your agent chain with the user message as input and get the bot message as output
# # bot_message = "I'm a STICK!!!\n\n```python\nprint('Hello World')\n```" # agent_chain.run(input=message)
# bot_message = "I'm a STICK!!!<br><br><pre><code>print('Hello World')</code></pre>"
# print("\nmain::return:")
# print(f" main::bot_message: {bot_message}")
# # Append the user message and the bot message to the chat history
# chat_history[-1][1] = bot_message
# print(f" main::chat_history: {chat_history}")
# # Return the updated chat history as a string
# return chat_history
async def amain(message, chat_history):
""" Define your main coroutine that handles the chatbot logic
"""
# Create one event loop before creating the tools
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
# Use async with to create and close the async browser automatically
async with async_playwright() as playwright:
# Use await to launch a Chromium browser asynchronously
browser = await playwright.chromium.launch()
# Create a PlayWrightBrowserToolkit from the browser
browser_toolkit = PlayWrightBrowserToolkit.from_browser(async_browser=browser)
# Get the tools from the toolkit
tools = browser_toolkit.get_tools()
# Create an agent using ChatOpenAI and initialize it with tools and handle_parsing_errors=True
llm = ChatOpenAI(model_name="gpt-4", temperature=0) # Also works well with Anthropic models
agent_chain = initialize_agent(
tools=tools,
llm=llm,
agent=AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
handle_parsing_errors=True
)
# Run your agent chain with the user message as input and get the bot message as output
bot_message = await agent_chain.arun(input=message)
# Append the user message and the bot message to the chat history
chat_history.append((message, bot_message))
# Return the updated chat history as a string
return str(chat_history)
# Run your Flask app with app.run()
if __name__ == "__main__":
app.run(
host="localhost",
port=None,
debug=True,
load_dotenv=True,
)
| [
"langchain.agents.load_tools",
"langchain.agents.initialize_agent",
"langchain.chat_models.ChatOpenAI",
"langchain.agents.agent_toolkits.PlayWrightBrowserToolkit.from_browser"
] | [((87, 100), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (98, 100), False, 'from dotenv import load_dotenv\n'), ((403, 418), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (408, 418), False, 'from flask import Flask, render_template, request, jsonify\n'), ((1220, 1265), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-4"""', 'temperature': '(0)'}), "(model_name='gpt-4', temperature=0)\n", (1230, 1265), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1356, 1388), 'langchain.agents.load_tools', 'load_tools', (["['serpapi']"], {'llm': 'llm'}), "(['serpapi'], llm=llm)\n", (1366, 1388), False, 'from langchain.agents import initialize_agent, load_tools\n'), ((1506, 1656), 'langchain.agents.initialize_agent', 'initialize_agent', ([], {'tools': 'tools', 'llm': 'llm', 'agent': 'AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION', 'verbose': '(True)', 'handle_parsing_errors': '(True)'}), '(tools=tools, llm=llm, agent=AgentType.\n STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True,\n handle_parsing_errors=True)\n', (1522, 1656), False, 'from langchain.agents import initialize_agent, load_tools\n'), ((1848, 1903), 'flask.render_template', 'render_template', (['"""chat.html"""'], {'chat_history': 'chat_history'}), "('chat.html', chat_history=chat_history)\n", (1863, 1903), False, 'from flask import Flask, render_template, request, jsonify\n'), ((2116, 2143), 'flask.request.args.get', 'request.args.get', (['"""message"""'], {}), "('message')\n", (2132, 2143), False, 'from flask import Flask, render_template, request, jsonify\n'), ((2539, 2578), 'flask.jsonify', 'jsonify', (["{'chat_history': chat_history}"], {}), "({'chat_history': chat_history})\n", (2546, 2578), False, 'from flask import Flask, render_template, request, jsonify\n'), ((2709, 2733), 'pprint.pprint', 'pp.pprint', (['response.json'], {}), '(response.json)\n', (2718, 2733), True, 'import pprint as pp\n'), ((3251, 3281), 'markdown.markdown', 'markdown.markdown', (['bot_message'], {}), '(bot_message)\n', (3268, 3281), False, 'import markdown\n'), ((4710, 4734), 'asyncio.new_event_loop', 'asyncio.new_event_loop', ([], {}), '()\n', (4732, 4734), False, 'import asyncio\n'), ((4739, 4767), 'asyncio.set_event_loop', 'asyncio.set_event_loop', (['loop'], {}), '(loop)\n', (4761, 4767), False, 'import asyncio\n'), ((2264, 2302), 'flask.request.args.get', 'request.args.get', (['"""chat_history"""', '"""[]"""'], {}), "('chat_history', '[]')\n", (2280, 2302), False, 'from flask import Flask, render_template, request, jsonify\n'), ((4857, 4875), 'playwright.async_api.async_playwright', 'async_playwright', ([], {}), '()\n', (4873, 4875), False, 'from playwright.async_api import async_playwright\n'), ((5095, 5155), 'langchain.agents.agent_toolkits.PlayWrightBrowserToolkit.from_browser', 'PlayWrightBrowserToolkit.from_browser', ([], {'async_browser': 'browser'}), '(async_browser=browser)\n', (5132, 5155), False, 'from langchain.agents.agent_toolkits import PlayWrightBrowserToolkit\n'), ((5359, 5404), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-4"""', 'temperature': '(0)'}), "(model_name='gpt-4', temperature=0)\n", (5369, 5404), False, 'from langchain.chat_models import ChatOpenAI\n'), ((5468, 5618), 'langchain.agents.initialize_agent', 'initialize_agent', ([], {'tools': 'tools', 'llm': 'llm', 'agent': 'AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION', 'verbose': '(True)', 'handle_parsing_errors': '(True)'}), '(tools=tools, llm=llm, agent=AgentType.\n STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION, verbose=True,\n handle_parsing_errors=True)\n', (5484, 5618), False, 'from langchain.agents import initialize_agent, load_tools\n')] |
import torch
from langchain.llms.base import LLM
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
from llama_index import LangchainEmbedding
from llama_index import SimpleDirectoryReader, LLMPredictor, PromptHelper, GPTSimpleVectorIndex
from peft import PeftModel
from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig
hf_model_path = "models/llama-7b"
alpaca_model_path = "models/lora-alpaca"
tokenizer = LlamaTokenizer.from_pretrained(hf_model_path)
model = LlamaForCausalLM.from_pretrained(
hf_model_path,
load_in_8bit=True, #Dissabling could solve some errors
device_map="auto",
)
model = PeftModel.from_pretrained(model, alpaca_model_path)
device = torch.device("cuda") if torch.cuda.is_available() else "cpu"
max_length = 1500 #2048
max_new_tokens = 48
class LLaMALLM(LLM):
def _call(self, prompt, stop=None):
prompt += "### Response:"
inputs = tokenizer(prompt, return_tensors="pt")
input_ids = inputs["input_ids"].cuda()
generation_config = GenerationConfig(
temperature=0.6,
top_p=0.95,
repetition_penalty=1.15,
)
with torch.no_grad():
generation_output = model.generate(
input_ids=input_ids,
generation_config=generation_config,
return_dict_in_generate=True,
output_scores=True,
max_new_tokens=128,
)
response = ""
for s in generation_output.sequences:
response += tokenizer.decode(s)
response = response[len(prompt):]
print("Model Response:", response)
return response
def _identifying_params(self):
return {"name_of_model": "alpaca"}
def _llm_type(self):
return "custom"
max_input_size = max_length
num_output = max_new_tokens
max_chunk_overlap = 20
prompt_helper = PromptHelper(max_input_size, num_output, max_chunk_overlap)
embed_model = LangchainEmbedding(HuggingFaceEmbeddings())
documents = SimpleDirectoryReader('data').load_data()
llm_predictor = LLMPredictor(llm=LLaMALLM())
index = GPTSimpleVectorIndex(documents, llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper)
index.save_to_disk('index.json')
new_index = GPTSimpleVectorIndex.load_from_disk('index.json', embed_model=embed_model, llm_predictor=llm_predictor, prompt_helper=prompt_helper)
response = new_index.query("What did Gatsby do before he met Daisy?")
print(response.response)
response = new_index.query("What did the narrator do after getting back to Chicago?")
print(response.response)
| [
"langchain.embeddings.huggingface.HuggingFaceEmbeddings"
] | [((460, 505), 'transformers.LlamaTokenizer.from_pretrained', 'LlamaTokenizer.from_pretrained', (['hf_model_path'], {}), '(hf_model_path)\n', (490, 505), False, 'from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig\n'), ((517, 606), 'transformers.LlamaForCausalLM.from_pretrained', 'LlamaForCausalLM.from_pretrained', (['hf_model_path'], {'load_in_8bit': '(True)', 'device_map': '"""auto"""'}), "(hf_model_path, load_in_8bit=True,\n device_map='auto')\n", (549, 606), False, 'from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig\n'), ((667, 718), 'peft.PeftModel.from_pretrained', 'PeftModel.from_pretrained', (['model', 'alpaca_model_path'], {}), '(model, alpaca_model_path)\n', (692, 718), False, 'from peft import PeftModel\n'), ((1997, 2056), 'llama_index.PromptHelper', 'PromptHelper', (['max_input_size', 'num_output', 'max_chunk_overlap'], {}), '(max_input_size, num_output, max_chunk_overlap)\n', (2009, 2056), False, 'from llama_index import SimpleDirectoryReader, LLMPredictor, PromptHelper, GPTSimpleVectorIndex\n'), ((2226, 2345), 'llama_index.GPTSimpleVectorIndex', 'GPTSimpleVectorIndex', (['documents'], {'llm_predictor': 'llm_predictor', 'embed_model': 'embed_model', 'prompt_helper': 'prompt_helper'}), '(documents, llm_predictor=llm_predictor, embed_model=\n embed_model, prompt_helper=prompt_helper)\n', (2246, 2345), False, 'from llama_index import SimpleDirectoryReader, LLMPredictor, PromptHelper, GPTSimpleVectorIndex\n'), ((2390, 2526), 'llama_index.GPTSimpleVectorIndex.load_from_disk', 'GPTSimpleVectorIndex.load_from_disk', (['"""index.json"""'], {'embed_model': 'embed_model', 'llm_predictor': 'llm_predictor', 'prompt_helper': 'prompt_helper'}), "('index.json', embed_model=embed_model,\n llm_predictor=llm_predictor, prompt_helper=prompt_helper)\n", (2425, 2526), False, 'from llama_index import SimpleDirectoryReader, LLMPredictor, PromptHelper, GPTSimpleVectorIndex\n'), ((757, 782), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (780, 782), False, 'import torch\n'), ((733, 753), 'torch.device', 'torch.device', (['"""cuda"""'], {}), "('cuda')\n", (745, 753), False, 'import torch\n'), ((2091, 2114), 'langchain.embeddings.huggingface.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {}), '()\n', (2112, 2114), False, 'from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n'), ((1088, 1158), 'transformers.GenerationConfig', 'GenerationConfig', ([], {'temperature': '(0.6)', 'top_p': '(0.95)', 'repetition_penalty': '(1.15)'}), '(temperature=0.6, top_p=0.95, repetition_penalty=1.15)\n', (1104, 1158), False, 'from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig\n'), ((2129, 2158), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""data"""'], {}), "('data')\n", (2150, 2158), False, 'from llama_index import SimpleDirectoryReader, LLMPredictor, PromptHelper, GPTSimpleVectorIndex\n'), ((1224, 1239), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (1237, 1239), False, 'import torch\n')] |
import langchain.graphs.neo4j_graph as neo4j_graph
import os
import sys
import ast
sys.path.append('backendPython')
from llms import *
from dotenv import load_dotenv, find_dotenv
load_dotenv(find_dotenv()) # read local .env file
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate, FewShotPromptTemplate
from neo4j_dir.entities import get_nodes_chain
graph = neo4j_graph.Neo4jGraph(
url = os.environ['NEO4J_URI'],
username=os.environ['NEO4J_USERNAME'],
password=os.environ['NEO4J_PASSWORD']
)
#__________________________________________________________________________________________________
# giving few-shot prompts
examples = [
{'Query' : 'name 10 companies which came for cgpa below 7' ,
'syntax' : '''MATCH (c:Company)-[Company_to_CGPA]->(cgpa:CGPA)
WHERE cgpa.name < 7
RETURN c.name LIMIT 10'''},
{"Query": "The ctc recieved by students for cgpa below 6",
"syntax": '''MATCH (cgpa:CGPA)-[CGPA_to_CTC]->(ctc:CTC)
WHERE cgpa.name < 6
RETURN ctc '''},
{"Query": "name 10 companies which came for cgpa below 7 and ctc above 20",
"syntax" :'''MATCH (company:Company)-[Company_to_CGPA]->(cgpa:CGPA)
MATCH (company)-[Company_to_CTC]->(ctc:CTC)
WHERE cgpa.name < 7 AND ctc.name > 20
RETURN company LIMIT 10;'''
} ,
{ "Query": "minimum cgpa required for ctc above 40" ,
"syntax" : ''' MATCH (cgpa:CGPA)-[CGPA_to_CTC]->(ctc:CTC)
WHERE ctc.name > 20
RETURN MIN(cgpa.name) AS minimum_cgpa;
''' ,
} ,
{ "Query" :"maximum and minimum cgpa required for ctc above 40" ,
"syntax" : '''
MATCH (cgpa:CGPA)-[CGPA_to_CTC]->(ctc:CTC)-[CTC_to_Company]->(company:Company)
WHERE ctc.name > 40
WITH MIN(cgpa.name) AS minCGPA, MAX(cgpa.name) AS maxCGPA
RETURN minCGPA, maxCGPA;
'''
} ,
]
example_formatter_template = """
Query :
{Query}
Cypher Syntax :
{syntax}
"""
example_prompt = PromptTemplate(
input_variables=['Query','syntax'],
template=example_formatter_template,
)
prefix = '''
You are supposed to convert the following natural query into a cypher query for neo4j database
You can refer to below examples for getting idea of how to write cypher query for neo4j database.
'''
suffix = '''
create a cypher query for following natural query for neo4j database
The query has the following list of nodes :
{List_of_nodes}
You can create relations between the nodes in following manner :
Node1 : Company
Node2 : CGPA
Relation1 : Company_to_CGPA
Relation2 : CGPA_to_Company
natural_query :
{natural_query}
Do not put back-ticks(`) in the output.
Use only nodes provided , don't create your new nodes and relations.
'''
few_shot_prompt = FewShotPromptTemplate(
examples=examples,
# prompt template used to format each individual example
example_prompt=example_prompt,
# prompt template string to put before the examples, assigning roles and rules.
prefix=prefix ,
# prompt template string to put after the examples.
suffix=suffix ,
# input variable to use in the suffix template
input_variables=["List_of_nodes" , "natural_query"],
example_separator="\n",
)
cypher_chain = LLMChain(llm=llm, prompt=few_shot_prompt,verbose=False,)
#__________________________________________________________________________________________________
# cypher = cypher_chain.run({"List_of_nodes" :['Company' , 'CGPA'] , 'natural_query':'name 10 companies which came for cgpa below 7'})
# result = graph.query(cypher)
# print(result)
#__________________________________________________________________________________________________
result_template = '''
You will be provided with the response generated for the given user query.
Response :
{response}
You need to format the respone in html in a conversational way,
arrange the response in bulleted points and under major headings if possible.
Take care that you do not pollute the data provided in response, by adding your own data.
Check that there are no back-ticks(`) in the output.
Check that html syntax is correct.
'''
result_prompt = PromptTemplate(input_variables=['response'], template=result_template)
result_chain = LLMChain(llm=llm, prompt=result_prompt)
# print(result_chain.run({'response': result}))
# #__________________________________________________________________________________________________
def get_response(query):
print('\n\n\n\n', query)
li = get_nodes_chain.run(query)
print(li)
if type(li)==str:
li = ast.literal_eval(li)
cypher = cypher_chain.run({"List_of_nodes" : li, 'natural_query':query})
print('\n\n\n', cypher,'\n\n\n')
result = graph.query(cypher)
print('\n\n\n', result)
response = result_chain.run({'response': result})
# print('\n\n\n', response)
return response
# x = get_response('what ctc is offered for cgpa below 7, sort the ctc in descending order')
# x = get_response("list companies with ctc above 30")
# x= get_response("list companies with ctc above 30 and cgpa below 8")
# x = get_response('name 10 companies which offered ctc above 20')
# x = get_response('jobProfiles available for cgpa below 7')
# print(x)
| [
"langchain.prompts.PromptTemplate",
"langchain.prompts.FewShotPromptTemplate",
"langchain.graphs.neo4j_graph.Neo4jGraph",
"langchain.chains.LLMChain"
] | [((83, 115), 'sys.path.append', 'sys.path.append', (['"""backendPython"""'], {}), "('backendPython')\n", (98, 115), False, 'import sys\n'), ((392, 526), 'langchain.graphs.neo4j_graph.Neo4jGraph', 'neo4j_graph.Neo4jGraph', ([], {'url': "os.environ['NEO4J_URI']", 'username': "os.environ['NEO4J_USERNAME']", 'password': "os.environ['NEO4J_PASSWORD']"}), "(url=os.environ['NEO4J_URI'], username=os.environ[\n 'NEO4J_USERNAME'], password=os.environ['NEO4J_PASSWORD'])\n", (414, 526), True, 'import langchain.graphs.neo4j_graph as neo4j_graph\n'), ((2133, 2226), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['Query', 'syntax']", 'template': 'example_formatter_template'}), "(input_variables=['Query', 'syntax'], template=\n example_formatter_template)\n", (2147, 2226), False, 'from langchain.prompts import PromptTemplate, FewShotPromptTemplate\n'), ((2940, 3125), 'langchain.prompts.FewShotPromptTemplate', 'FewShotPromptTemplate', ([], {'examples': 'examples', 'example_prompt': 'example_prompt', 'prefix': 'prefix', 'suffix': 'suffix', 'input_variables': "['List_of_nodes', 'natural_query']", 'example_separator': '"""\n"""'}), "(examples=examples, example_prompt=example_prompt,\n prefix=prefix, suffix=suffix, input_variables=['List_of_nodes',\n 'natural_query'], example_separator='\\n')\n", (2961, 3125), False, 'from langchain.prompts import PromptTemplate, FewShotPromptTemplate\n'), ((3431, 3487), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'few_shot_prompt', 'verbose': '(False)'}), '(llm=llm, prompt=few_shot_prompt, verbose=False)\n', (3439, 3487), False, 'from langchain.chains import LLMChain\n'), ((4337, 4407), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['response']", 'template': 'result_template'}), "(input_variables=['response'], template=result_template)\n", (4351, 4407), False, 'from langchain.prompts import PromptTemplate, FewShotPromptTemplate\n'), ((4424, 4463), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'result_prompt'}), '(llm=llm, prompt=result_prompt)\n', (4432, 4463), False, 'from langchain.chains import LLMChain\n'), ((191, 204), 'dotenv.find_dotenv', 'find_dotenv', ([], {}), '()\n', (202, 204), False, 'from dotenv import load_dotenv, find_dotenv\n'), ((4679, 4705), 'neo4j_dir.entities.get_nodes_chain.run', 'get_nodes_chain.run', (['query'], {}), '(query)\n', (4698, 4705), False, 'from neo4j_dir.entities import get_nodes_chain\n'), ((4755, 4775), 'ast.literal_eval', 'ast.literal_eval', (['li'], {}), '(li)\n', (4771, 4775), False, 'import ast\n')] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.