code
stringlengths 141
79.4k
| apis
sequencelengths 1
23
| extract_api
stringlengths 126
73.2k
|
|---|---|---|
from __future__ import annotations
from typing import TYPE_CHECKING, ClassVar, Collection, Dict, List
from venv import logger
import requests
from langchain.schema.document import Document
from langchain.vectorstores.base import VectorStore, VectorStoreRetriever
from langchain_core.pydantic_v1 import Field, root_validator
if TYPE_CHECKING:
from langchain.callbacks.manager import (
AsyncCallbackManagerForRetrieverRun,
CallbackManagerForRetrieverRun,
)
class VectorStoreFilterRetriever(VectorStoreRetriever):
vectorstore: VectorStore
search_type: str = 'similarity'
search_kwargs: dict = Field(default_factory=dict)
allowed_search_types: ClassVar[Collection[str]] = (
'similarity',
'similarity_score_threshold',
'mmr',
)
access_url: str = None
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
@root_validator()
def validate_search_type(cls, values: Dict) -> Dict:
"""Validate search type."""
search_type = values['search_type']
if search_type not in cls.allowed_search_types:
raise ValueError(f'search_type of {search_type} not allowed. Valid values are: '
f'{cls.allowed_search_types}')
if search_type == 'similarity_score_threshold':
score_threshold = values['search_kwargs'].get('score_threshold')
if (score_threshold is None) or (not isinstance(score_threshold, float)):
raise ValueError('`score_threshold` is not specified with a float value(0~1) '
'in `search_kwargs`.')
return values
def _get_relevant_documents(self, query: str, *,
run_manager: CallbackManagerForRetrieverRun) -> List[Document]:
if self.search_type == 'similarity':
docs = self.vectorstore.similarity_search(query, **self.search_kwargs)
elif self.search_type == 'similarity_score_threshold':
docs_and_similarities = (self.vectorstore.similarity_search_with_relevance_scores(
query, **self.search_kwargs))
docs = [doc for doc, _ in docs_and_similarities]
elif self.search_type == 'mmr':
docs = self.vectorstore.max_marginal_relevance_search(query, **self.search_kwargs)
else:
raise ValueError(f'search_type of {self.search_type} not allowed.')
return self.get_file_access(docs)
async def _aget_relevant_documents(
self, query: str, *,
run_manager: AsyncCallbackManagerForRetrieverRun) -> List[Document]:
if self.search_type == 'similarity':
docs = await self.vectorstore.asimilarity_search(query, **self.search_kwargs)
elif self.search_type == 'similarity_score_threshold':
docs_and_similarities = (await
self.vectorstore.asimilarity_search_with_relevance_scores(
query, **self.search_kwargs))
docs = [doc for doc, _ in docs_and_similarities]
elif self.search_type == 'mmr':
docs = await self.vectorstore.amax_marginal_relevance_search(
query, **self.search_kwargs)
else:
raise ValueError(f'search_type of {self.search_type} not allowed.')
return self.get_file_access(docs)
def get_file_access(self, docs: List[Document]):
file_ids = [doc.metadata.get('file_id') for doc in docs if 'file_id' in doc.metadata]
if file_ids:
res = requests.get(self.access_url, json=file_ids)
if res.status_code == 200:
doc_res = res.json().get('data') or []
doc_right = {doc.get('docid') for doc in doc_res if doc.get('result') == 1}
for doc in docs:
if doc.metadata.get('file_id') and doc.metadata.get(
'file_id') not in doc_right:
doc.page_content = ''
doc.metadata['right'] = False
return docs
else:
logger.error(f'query_file_access_fail url={self.access_url} res={res.text}')
return [Document(page_content='', metadata={})]
else:
return docs
| [
"langchain.schema.document.Document",
"langchain_core.pydantic_v1.Field",
"langchain_core.pydantic_v1.root_validator"
] | [((631, 658), 'langchain_core.pydantic_v1.Field', 'Field', ([], {'default_factory': 'dict'}), '(default_factory=dict)\n', (636, 658), False, 'from langchain_core.pydantic_v1 import Field, root_validator\n'), ((942, 958), 'langchain_core.pydantic_v1.root_validator', 'root_validator', ([], {}), '()\n', (956, 958), False, 'from langchain_core.pydantic_v1 import Field, root_validator\n'), ((3618, 3662), 'requests.get', 'requests.get', (['self.access_url'], {'json': 'file_ids'}), '(self.access_url, json=file_ids)\n', (3630, 3662), False, 'import requests\n'), ((4174, 4250), 'venv.logger.error', 'logger.error', (['f"""query_file_access_fail url={self.access_url} res={res.text}"""'], {}), "(f'query_file_access_fail url={self.access_url} res={res.text}')\n", (4186, 4250), False, 'from venv import logger\n'), ((4275, 4313), 'langchain.schema.document.Document', 'Document', ([], {'page_content': '""""""', 'metadata': '{}'}), "(page_content='', metadata={})\n", (4283, 4313), False, 'from langchain.schema.document import Document\n')] |
import os
from typing import Optional
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain.schema import BaseMessage, HumanMessage
from rebyte_langchain.rebyte_langchain import RebyteEndpoint
from realtime_ai_character.llm.base import (
AsyncCallbackAudioHandler,
AsyncCallbackTextHandler,
LLM,
)
from realtime_ai_character.logger import get_logger
from realtime_ai_character.utils import Character, timed
logger = get_logger(__name__)
class RebyteLlm(LLM):
def __init__(self):
self.rebyte_api_key = os.getenv("REBYTE_API_KEY", "")
self.chat_rebyte = RebyteEndpoint(
rebyte_api_key=self.rebyte_api_key, client=None, streaming=True
)
self.config = {}
def get_config(self):
return self.config
def _set_character_config(self, character: Character):
self.chat_rebyte.project_id = character.rebyte_api_project_id
self.chat_rebyte.agent_id = character.rebyte_api_agent_id
if character.rebyte_api_version is not None:
self.chat_rebyte.version = character.rebyte_api_version
def _set_user_config(self, user_id: str):
self.chat_rebyte.session_id = user_id
@timed
async def achat(
self,
history: list[BaseMessage],
user_input: str,
user_id: str,
character: Character,
callback: AsyncCallbackTextHandler,
audioCallback: Optional[AsyncCallbackAudioHandler] = None,
metadata: Optional[dict] = None,
*args,
**kwargs,
) -> str:
# 1. Add user input to history
# delete the first system message in history. just use the system prompt in rebyte platform
history.pop(0)
history.append(HumanMessage(content=user_input))
# 2. Generate response
# set project_id and agent_id for character
self._set_character_config(character=character)
# set session_id for user
self._set_user_config(user_id)
callbacks = [callback, StreamingStdOutCallbackHandler()]
if audioCallback is not None:
callbacks.append(audioCallback)
response = await self.chat_rebyte.agenerate(
[history],
callbacks=callbacks,
metadata=metadata,
)
logger.info(f"Response: {response}")
return response.generations[0][0].text
| [
"langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler",
"langchain.schema.HumanMessage"
] | [((473, 493), 'realtime_ai_character.logger.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (483, 493), False, 'from realtime_ai_character.logger import get_logger\n'), ((572, 603), 'os.getenv', 'os.getenv', (['"""REBYTE_API_KEY"""', '""""""'], {}), "('REBYTE_API_KEY', '')\n", (581, 603), False, 'import os\n'), ((632, 711), 'rebyte_langchain.rebyte_langchain.RebyteEndpoint', 'RebyteEndpoint', ([], {'rebyte_api_key': 'self.rebyte_api_key', 'client': 'None', 'streaming': '(True)'}), '(rebyte_api_key=self.rebyte_api_key, client=None, streaming=True)\n', (646, 711), False, 'from rebyte_langchain.rebyte_langchain import RebyteEndpoint\n'), ((1768, 1800), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'user_input'}), '(content=user_input)\n', (1780, 1800), False, 'from langchain.schema import BaseMessage, HumanMessage\n'), ((2046, 2078), 'langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler', 'StreamingStdOutCallbackHandler', ([], {}), '()\n', (2076, 2078), False, 'from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n')] |
from langchain.agents import AgentType, initialize_agent
from langchain_community.agent_toolkits import ZapierToolkit
from langchain_community.tools import BaseTool
from langchain_community.utilities.zapier import ZapierNLAWrapper
from langchain_openai import ChatOpenAI
class ZapierNLA(BaseTool):
name = "Zapier"
description = (
"useful for performing actions such sending emails, scheduling meetings etc."
)
return_direct = False
def _run(self, input: str) -> str:
zapier_nla_api_key = self.metadata["zapierNlaApiKey"]
zapier = ZapierNLAWrapper(zapier_nla_api_key=zapier_nla_api_key)
toolkit = ZapierToolkit.from_zapier_nla_wrapper(zapier)
agent = initialize_agent(
toolkit.get_tools(),
llm=ChatOpenAI(openai_api_key=self.metadata["openaiApiKey"], model="gpt-4"),
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
)
output = agent.run(input)
return output
async def _arun(self, input: str) -> str:
zapier_nla_api_key = self.metadata["zapierNlaApiKey"]
zapier = ZapierNLAWrapper(zapier_nla_api_key=zapier_nla_api_key)
toolkit = ZapierToolkit.from_zapier_nla_wrapper(zapier)
agent = initialize_agent(
toolkit.get_tools(),
llm=ChatOpenAI(openai_api_key=self.metadata["openaiApiKey"], model="gpt-4"),
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True,
)
output = await agent.arun(input)
return output
| [
"langchain_openai.ChatOpenAI",
"langchain_community.agent_toolkits.ZapierToolkit.from_zapier_nla_wrapper",
"langchain_community.utilities.zapier.ZapierNLAWrapper"
] | [((577, 632), 'langchain_community.utilities.zapier.ZapierNLAWrapper', 'ZapierNLAWrapper', ([], {'zapier_nla_api_key': 'zapier_nla_api_key'}), '(zapier_nla_api_key=zapier_nla_api_key)\n', (593, 632), False, 'from langchain_community.utilities.zapier import ZapierNLAWrapper\n'), ((651, 696), 'langchain_community.agent_toolkits.ZapierToolkit.from_zapier_nla_wrapper', 'ZapierToolkit.from_zapier_nla_wrapper', (['zapier'], {}), '(zapier)\n', (688, 696), False, 'from langchain_community.agent_toolkits import ZapierToolkit\n'), ((1128, 1183), 'langchain_community.utilities.zapier.ZapierNLAWrapper', 'ZapierNLAWrapper', ([], {'zapier_nla_api_key': 'zapier_nla_api_key'}), '(zapier_nla_api_key=zapier_nla_api_key)\n', (1144, 1183), False, 'from langchain_community.utilities.zapier import ZapierNLAWrapper\n'), ((1202, 1247), 'langchain_community.agent_toolkits.ZapierToolkit.from_zapier_nla_wrapper', 'ZapierToolkit.from_zapier_nla_wrapper', (['zapier'], {}), '(zapier)\n', (1239, 1247), False, 'from langchain_community.agent_toolkits import ZapierToolkit\n'), ((780, 851), 'langchain_openai.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': "self.metadata['openaiApiKey']", 'model': '"""gpt-4"""'}), "(openai_api_key=self.metadata['openaiApiKey'], model='gpt-4')\n", (790, 851), False, 'from langchain_openai import ChatOpenAI\n'), ((1331, 1402), 'langchain_openai.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': "self.metadata['openaiApiKey']", 'model': '"""gpt-4"""'}), "(openai_api_key=self.metadata['openaiApiKey'], model='gpt-4')\n", (1341, 1402), False, 'from langchain_openai import ChatOpenAI\n')] |
from celery import shared_task
from langchain.text_splitter import RecursiveCharacterTextSplitter
from shared.models.opencopilot_db.pdf_data_sources import (
insert_pdf_data_source,
update_pdf_data_source_status,
)
from langchain.document_loaders import UnstructuredMarkdownLoader
from shared.utils.opencopilot_utils import (
get_embeddings,
StoreOptions,
get_file_path,
)
from shared.utils.opencopilot_utils.init_vector_store import init_vector_store
from workers.utils.remove_escape_sequences import remove_escape_sequences
@shared_task
def process_markdown(file_name: str, bot_id: str):
try:
insert_pdf_data_source(chatbot_id=bot_id, file_name=file_name, status="PENDING")
loader = UnstructuredMarkdownLoader(get_file_path(file_name))
raw_docs = loader.load()
for doc in raw_docs:
doc.page_content = remove_escape_sequences(doc.page_content)
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000, chunk_overlap=200, length_function=len
)
docs = text_splitter.split_documents(raw_docs)
embeddings = get_embeddings()
init_vector_store(
docs,
StoreOptions(namespace="knowledgebase", metadata={"bot_id": bot_id}),
)
update_pdf_data_source_status(
chatbot_id=bot_id, file_name=file_name, status="COMPLETED"
)
except Exception as e:
update_pdf_data_source_status(
chatbot_id=bot_id, file_name=file_name, status="FAILED"
)
print(f"Error processing {file_name}:", e)
@shared_task
def retry_failed_markdown_crawl(chatbot_id: str, file_name: str):
"""Re-runs a failed PDF crawl.
Args:
chatbot_id: The ID of the chatbot.
file_name: The name of the PDF file to crawl.
"""
update_pdf_data_source_status(
chatbot_id=chatbot_id, file_name=file_name, status="PENDING"
)
try:
process_markdown(file_name=file_name, bot_id=chatbot_id)
except Exception as e:
update_pdf_data_source_status(
chatbot_id=chatbot_id, file_name=file_name, status="FAILED"
)
print(f"Error reprocessing {file_name}:", e)
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter"
] | [((1830, 1925), 'shared.models.opencopilot_db.pdf_data_sources.update_pdf_data_source_status', 'update_pdf_data_source_status', ([], {'chatbot_id': 'chatbot_id', 'file_name': 'file_name', 'status': '"""PENDING"""'}), "(chatbot_id=chatbot_id, file_name=file_name,\n status='PENDING')\n", (1859, 1925), False, 'from shared.models.opencopilot_db.pdf_data_sources import insert_pdf_data_source, update_pdf_data_source_status\n'), ((630, 715), 'shared.models.opencopilot_db.pdf_data_sources.insert_pdf_data_source', 'insert_pdf_data_source', ([], {'chatbot_id': 'bot_id', 'file_name': 'file_name', 'status': '"""PENDING"""'}), "(chatbot_id=bot_id, file_name=file_name, status='PENDING'\n )\n", (652, 715), False, 'from shared.models.opencopilot_db.pdf_data_sources import insert_pdf_data_source, update_pdf_data_source_status\n'), ((941, 1032), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(200)', 'length_function': 'len'}), '(chunk_size=1000, chunk_overlap=200,\n length_function=len)\n', (971, 1032), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1127, 1143), 'shared.utils.opencopilot_utils.get_embeddings', 'get_embeddings', ([], {}), '()\n', (1141, 1143), False, 'from shared.utils.opencopilot_utils import get_embeddings, StoreOptions, get_file_path\n'), ((1290, 1383), 'shared.models.opencopilot_db.pdf_data_sources.update_pdf_data_source_status', 'update_pdf_data_source_status', ([], {'chatbot_id': 'bot_id', 'file_name': 'file_name', 'status': '"""COMPLETED"""'}), "(chatbot_id=bot_id, file_name=file_name,\n status='COMPLETED')\n", (1319, 1383), False, 'from shared.models.opencopilot_db.pdf_data_sources import insert_pdf_data_source, update_pdf_data_source_status\n'), ((755, 779), 'shared.utils.opencopilot_utils.get_file_path', 'get_file_path', (['file_name'], {}), '(file_name)\n', (768, 779), False, 'from shared.utils.opencopilot_utils import get_embeddings, StoreOptions, get_file_path\n'), ((874, 915), 'workers.utils.remove_escape_sequences.remove_escape_sequences', 'remove_escape_sequences', (['doc.page_content'], {}), '(doc.page_content)\n', (897, 915), False, 'from workers.utils.remove_escape_sequences import remove_escape_sequences\n'), ((1201, 1269), 'shared.utils.opencopilot_utils.StoreOptions', 'StoreOptions', ([], {'namespace': '"""knowledgebase"""', 'metadata': "{'bot_id': bot_id}"}), "(namespace='knowledgebase', metadata={'bot_id': bot_id})\n", (1213, 1269), False, 'from shared.utils.opencopilot_utils import get_embeddings, StoreOptions, get_file_path\n'), ((1437, 1527), 'shared.models.opencopilot_db.pdf_data_sources.update_pdf_data_source_status', 'update_pdf_data_source_status', ([], {'chatbot_id': 'bot_id', 'file_name': 'file_name', 'status': '"""FAILED"""'}), "(chatbot_id=bot_id, file_name=file_name,\n status='FAILED')\n", (1466, 1527), False, 'from shared.models.opencopilot_db.pdf_data_sources import insert_pdf_data_source, update_pdf_data_source_status\n'), ((2045, 2139), 'shared.models.opencopilot_db.pdf_data_sources.update_pdf_data_source_status', 'update_pdf_data_source_status', ([], {'chatbot_id': 'chatbot_id', 'file_name': 'file_name', 'status': '"""FAILED"""'}), "(chatbot_id=chatbot_id, file_name=file_name,\n status='FAILED')\n", (2074, 2139), False, 'from shared.models.opencopilot_db.pdf_data_sources import insert_pdf_data_source, update_pdf_data_source_status\n')] |
from concurrent.futures import ThreadPoolExecutor
import asyncio
import logging
from typing import Optional, Tuple
from langchain import ConversationChain
from vocode.streaming.agent.base_agent import RespondAgent
from vocode.streaming.models.agent import ChatVertexAIAgentConfig
from langchain_community.chat_models import ChatVertexAI
from langchain.prompts import (
ChatPromptTemplate,
MessagesPlaceholder,
HumanMessagePromptTemplate,
)
from langchain.schema import HumanMessage, SystemMessage, AIMessage
from langchain.memory import ConversationBufferMemory
class ChatVertexAIAgent(RespondAgent[ChatVertexAIAgentConfig]):
def __init__(
self,
agent_config: ChatVertexAIAgentConfig,
logger: Optional[logging.Logger] = None,
):
super().__init__(agent_config=agent_config, logger=logger)
self.prompt = ChatPromptTemplate.from_messages(
[
MessagesPlaceholder(variable_name="history"),
HumanMessagePromptTemplate.from_template("{input}"),
]
)
self.llm = ChatVertexAI()
self.memory = ConversationBufferMemory(return_messages=True)
self.memory.chat_memory.messages.append(
SystemMessage(content=self.agent_config.prompt_preamble)
)
self.conversation = ConversationChain(
memory=self.memory, prompt=self.prompt, llm=self.llm
)
if agent_config.initial_message:
raise NotImplementedError("initial_message not supported for Vertex AI")
self.thread_pool_executor = ThreadPoolExecutor(max_workers=1)
async def respond(
self,
human_input,
conversation_id: str,
is_interrupt: bool = False,
) -> Tuple[str, bool]:
# Vertex AI doesn't allow async, so we run in a separate thread
text = await asyncio.get_event_loop().run_in_executor(
self.thread_pool_executor,
lambda input: self.conversation.predict(input=input),
human_input,
)
self.logger.debug(f"LLM response: {text}")
return text, False
| [
"langchain.prompts.HumanMessagePromptTemplate.from_template",
"langchain.memory.ConversationBufferMemory",
"langchain.prompts.MessagesPlaceholder",
"langchain.schema.SystemMessage",
"langchain_community.chat_models.ChatVertexAI",
"langchain.ConversationChain"
] | [((1089, 1103), 'langchain_community.chat_models.ChatVertexAI', 'ChatVertexAI', ([], {}), '()\n', (1101, 1103), False, 'from langchain_community.chat_models import ChatVertexAI\n'), ((1127, 1173), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'return_messages': '(True)'}), '(return_messages=True)\n', (1151, 1173), False, 'from langchain.memory import ConversationBufferMemory\n'), ((1331, 1402), 'langchain.ConversationChain', 'ConversationChain', ([], {'memory': 'self.memory', 'prompt': 'self.prompt', 'llm': 'self.llm'}), '(memory=self.memory, prompt=self.prompt, llm=self.llm)\n', (1348, 1402), False, 'from langchain import ConversationChain\n'), ((1587, 1620), 'concurrent.futures.ThreadPoolExecutor', 'ThreadPoolExecutor', ([], {'max_workers': '(1)'}), '(max_workers=1)\n', (1605, 1620), False, 'from concurrent.futures import ThreadPoolExecutor\n'), ((1235, 1291), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'self.agent_config.prompt_preamble'}), '(content=self.agent_config.prompt_preamble)\n', (1248, 1291), False, 'from langchain.schema import HumanMessage, SystemMessage, AIMessage\n'), ((930, 974), 'langchain.prompts.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': '"""history"""'}), "(variable_name='history')\n", (949, 974), False, 'from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate\n'), ((992, 1043), 'langchain.prompts.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['"""{input}"""'], {}), "('{input}')\n", (1032, 1043), False, 'from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder, HumanMessagePromptTemplate\n'), ((1866, 1890), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (1888, 1890), False, 'import asyncio\n')] |
# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# This is a simple standalone implementation showing rag pipeline using Nvidia AI Foundational models.
# It uses a simple Streamlit UI and one file implementation of a minimalistic RAG pipeline.
############################################
# Component #1 - Document Loader
############################################
import streamlit as st
import os
st.set_page_config(layout = "wide")
with st.sidebar:
DOCS_DIR = os.path.abspath("./uploaded_docs")
if not os.path.exists(DOCS_DIR):
os.makedirs(DOCS_DIR)
st.subheader("Add to the Knowledge Base")
with st.form("my-form", clear_on_submit=True):
uploaded_files = st.file_uploader("Upload a file to the Knowledge Base:", accept_multiple_files = True)
submitted = st.form_submit_button("Upload!")
if uploaded_files and submitted:
for uploaded_file in uploaded_files:
st.success(f"File {uploaded_file.name} uploaded successfully!")
with open(os.path.join(DOCS_DIR, uploaded_file.name),"wb") as f:
f.write(uploaded_file.read())
############################################
# Component #2 - Embedding Model and LLM
############################################
from langchain_nvidia_ai_endpoints import ChatNVIDIA, NVIDIAEmbeddings
# make sure to export your NVIDIA AI Playground key as NVIDIA_API_KEY!
llm = ChatNVIDIA(model="mixtral_8x7b")
document_embedder = NVIDIAEmbeddings(model="nvolveqa_40k", model_type="passage")
query_embedder = NVIDIAEmbeddings(model="nvolveqa_40k", model_type="query")
############################################
# Component #3 - Vector Database Store
############################################
from langchain.text_splitter import CharacterTextSplitter
from langchain.document_loaders import DirectoryLoader
from langchain.vectorstores import FAISS
import pickle
with st.sidebar:
# Option for using an existing vector store
use_existing_vector_store = st.radio("Use existing vector store if available", ["Yes", "No"], horizontal=True)
# Path to the vector store file
vector_store_path = "vectorstore.pkl"
# Load raw documents from the directory
raw_documents = DirectoryLoader(DOCS_DIR).load()
# Check for existing vector store file
vector_store_exists = os.path.exists(vector_store_path)
vectorstore = None
if use_existing_vector_store == "Yes" and vector_store_exists:
with open(vector_store_path, "rb") as f:
vectorstore = pickle.load(f)
with st.sidebar:
st.success("Existing vector store loaded successfully.")
else:
with st.sidebar:
if raw_documents:
with st.spinner("Splitting documents into chunks..."):
text_splitter = CharacterTextSplitter(chunk_size=2000, chunk_overlap=200)
documents = text_splitter.split_documents(raw_documents)
with st.spinner("Adding document chunks to vector database..."):
vectorstore = FAISS.from_documents(documents, document_embedder)
with st.spinner("Saving vector store"):
with open(vector_store_path, "wb") as f:
pickle.dump(vectorstore, f)
st.success("Vector store created and saved.")
else:
st.warning("No documents available to process!", icon="⚠️")
############################################
# Component #4 - LLM Response Generation and Chat
############################################
st.subheader("Chat with your AI Assistant, Envie!")
if "messages" not in st.session_state:
st.session_state.messages = []
for message in st.session_state.messages:
with st.chat_message(message["role"]):
st.markdown(message["content"])
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
prompt_template = ChatPromptTemplate.from_messages(
[("system", "You are a helpful AI assistant named Envie. You will reply to questions only based on the context that you are provided. If something is out of context, you will refrain from replying and politely decline to respond to the user."), ("user", "{input}")]
)
user_input = st.chat_input("Can you tell me what NVIDIA is known for?")
llm = ChatNVIDIA(model="mixtral_8x7b")
chain = prompt_template | llm | StrOutputParser()
if user_input and vectorstore!=None:
st.session_state.messages.append({"role": "user", "content": user_input})
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents(user_input)
with st.chat_message("user"):
st.markdown(user_input)
context = ""
for doc in docs:
context += doc.page_content + "\n\n"
augmented_user_input = "Context: " + context + "\n\nQuestion: " + user_input + "\n"
with st.chat_message("assistant"):
message_placeholder = st.empty()
full_response = ""
for response in chain.stream({"input": augmented_user_input}):
full_response += response
message_placeholder.markdown(full_response + "▌")
message_placeholder.markdown(full_response)
st.session_state.messages.append({"role": "assistant", "content": full_response})
| [
"langchain.text_splitter.CharacterTextSplitter",
"langchain.document_loaders.DirectoryLoader",
"langchain_core.output_parsers.StrOutputParser",
"langchain.vectorstores.FAISS.from_documents",
"langchain_core.prompts.ChatPromptTemplate.from_messages",
"langchain_nvidia_ai_endpoints.NVIDIAEmbeddings",
"langchain_nvidia_ai_endpoints.ChatNVIDIA"
] | [((1034, 1067), 'streamlit.set_page_config', 'st.set_page_config', ([], {'layout': '"""wide"""'}), "(layout='wide')\n", (1052, 1067), True, 'import streamlit as st\n'), ((2031, 2063), 'langchain_nvidia_ai_endpoints.ChatNVIDIA', 'ChatNVIDIA', ([], {'model': '"""mixtral_8x7b"""'}), "(model='mixtral_8x7b')\n", (2041, 2063), False, 'from langchain_nvidia_ai_endpoints import ChatNVIDIA, NVIDIAEmbeddings\n'), ((2084, 2144), 'langchain_nvidia_ai_endpoints.NVIDIAEmbeddings', 'NVIDIAEmbeddings', ([], {'model': '"""nvolveqa_40k"""', 'model_type': '"""passage"""'}), "(model='nvolveqa_40k', model_type='passage')\n", (2100, 2144), False, 'from langchain_nvidia_ai_endpoints import ChatNVIDIA, NVIDIAEmbeddings\n'), ((2162, 2220), 'langchain_nvidia_ai_endpoints.NVIDIAEmbeddings', 'NVIDIAEmbeddings', ([], {'model': '"""nvolveqa_40k"""', 'model_type': '"""query"""'}), "(model='nvolveqa_40k', model_type='query')\n", (2178, 2220), False, 'from langchain_nvidia_ai_endpoints import ChatNVIDIA, NVIDIAEmbeddings\n'), ((2925, 2958), 'os.path.exists', 'os.path.exists', (['vector_store_path'], {}), '(vector_store_path)\n', (2939, 2958), False, 'import os\n'), ((4095, 4146), 'streamlit.subheader', 'st.subheader', (['"""Chat with your AI Assistant, Envie!"""'], {}), "('Chat with your AI Assistant, Envie!')\n", (4107, 4146), True, 'import streamlit as st\n'), ((4480, 4788), 'langchain_core.prompts.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (["[('system',\n 'You are a helpful AI assistant named Envie. You will reply to questions only based on the context that you are provided. If something is out of context, you will refrain from replying and politely decline to respond to the user.'\n ), ('user', '{input}')]"], {}), "([('system',\n 'You are a helpful AI assistant named Envie. You will reply to questions only based on the context that you are provided. If something is out of context, you will refrain from replying and politely decline to respond to the user.'\n ), ('user', '{input}')])\n", (4512, 4788), False, 'from langchain_core.prompts import ChatPromptTemplate\n'), ((4799, 4857), 'streamlit.chat_input', 'st.chat_input', (['"""Can you tell me what NVIDIA is known for?"""'], {}), "('Can you tell me what NVIDIA is known for?')\n", (4812, 4857), True, 'import streamlit as st\n'), ((4864, 4896), 'langchain_nvidia_ai_endpoints.ChatNVIDIA', 'ChatNVIDIA', ([], {'model': '"""mixtral_8x7b"""'}), "(model='mixtral_8x7b')\n", (4874, 4896), False, 'from langchain_nvidia_ai_endpoints import ChatNVIDIA, NVIDIAEmbeddings\n'), ((1103, 1137), 'os.path.abspath', 'os.path.abspath', (['"""./uploaded_docs"""'], {}), "('./uploaded_docs')\n", (1118, 1137), False, 'import os\n'), ((1209, 1250), 'streamlit.subheader', 'st.subheader', (['"""Add to the Knowledge Base"""'], {}), "('Add to the Knowledge Base')\n", (1221, 1250), True, 'import streamlit as st\n'), ((2618, 2704), 'streamlit.radio', 'st.radio', (['"""Use existing vector store if available"""', "['Yes', 'No']"], {'horizontal': '(True)'}), "('Use existing vector store if available', ['Yes', 'No'],\n horizontal=True)\n", (2626, 2704), True, 'import streamlit as st\n'), ((4930, 4947), 'langchain_core.output_parsers.StrOutputParser', 'StrOutputParser', ([], {}), '()\n', (4945, 4947), False, 'from langchain_core.output_parsers import StrOutputParser\n'), ((4990, 5063), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': user_input}"], {}), "({'role': 'user', 'content': user_input})\n", (5022, 5063), True, 'import streamlit as st\n'), ((5738, 5823), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'assistant', 'content': full_response}"], {}), "({'role': 'assistant', 'content':\n full_response})\n", (5770, 5823), True, 'import streamlit as st\n'), ((1149, 1173), 'os.path.exists', 'os.path.exists', (['DOCS_DIR'], {}), '(DOCS_DIR)\n', (1163, 1173), False, 'import os\n'), ((1183, 1204), 'os.makedirs', 'os.makedirs', (['DOCS_DIR'], {}), '(DOCS_DIR)\n', (1194, 1204), False, 'import os\n'), ((1260, 1300), 'streamlit.form', 'st.form', (['"""my-form"""'], {'clear_on_submit': '(True)'}), "('my-form', clear_on_submit=True)\n", (1267, 1300), True, 'import streamlit as st\n'), ((1327, 1415), 'streamlit.file_uploader', 'st.file_uploader', (['"""Upload a file to the Knowledge Base:"""'], {'accept_multiple_files': '(True)'}), "('Upload a file to the Knowledge Base:',\n accept_multiple_files=True)\n", (1343, 1415), True, 'import streamlit as st\n'), ((1434, 1466), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""Upload!"""'], {}), "('Upload!')\n", (1455, 1466), True, 'import streamlit as st\n'), ((2829, 2854), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (['DOCS_DIR'], {}), '(DOCS_DIR)\n', (2844, 2854), False, 'from langchain.document_loaders import DirectoryLoader\n'), ((3108, 3122), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (3119, 3122), False, 'import pickle\n'), ((3152, 3208), 'streamlit.success', 'st.success', (['"""Existing vector store loaded successfully."""'], {}), "('Existing vector store loaded successfully.')\n", (3162, 3208), True, 'import streamlit as st\n'), ((4274, 4306), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (4289, 4306), True, 'import streamlit as st\n'), ((4316, 4347), 'streamlit.markdown', 'st.markdown', (["message['content']"], {}), "(message['content'])\n", (4327, 4347), True, 'import streamlit as st\n'), ((5172, 5195), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (5187, 5195), True, 'import streamlit as st\n'), ((5205, 5228), 'streamlit.markdown', 'st.markdown', (['user_input'], {}), '(user_input)\n', (5216, 5228), True, 'import streamlit as st\n'), ((5412, 5440), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (5427, 5440), True, 'import streamlit as st\n'), ((5472, 5482), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (5480, 5482), True, 'import streamlit as st\n'), ((1562, 1625), 'streamlit.success', 'st.success', (['f"""File {uploaded_file.name} uploaded successfully!"""'], {}), "(f'File {uploaded_file.name} uploaded successfully!')\n", (1572, 1625), True, 'import streamlit as st\n'), ((3821, 3866), 'streamlit.success', 'st.success', (['"""Vector store created and saved."""'], {}), "('Vector store created and saved.')\n", (3831, 3866), True, 'import streamlit as st\n'), ((3893, 3952), 'streamlit.warning', 'st.warning', (['"""No documents available to process!"""'], {'icon': '"""⚠️"""'}), "('No documents available to process!', icon='⚠️')\n", (3903, 3952), True, 'import streamlit as st\n'), ((3279, 3327), 'streamlit.spinner', 'st.spinner', (['"""Splitting documents into chunks..."""'], {}), "('Splitting documents into chunks...')\n", (3289, 3327), True, 'import streamlit as st\n'), ((3361, 3418), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(2000)', 'chunk_overlap': '(200)'}), '(chunk_size=2000, chunk_overlap=200)\n', (3382, 3418), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((3510, 3568), 'streamlit.spinner', 'st.spinner', (['"""Adding document chunks to vector database..."""'], {}), "('Adding document chunks to vector database...')\n", (3520, 3568), True, 'import streamlit as st\n'), ((3600, 3650), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['documents', 'document_embedder'], {}), '(documents, document_embedder)\n', (3620, 3650), False, 'from langchain.vectorstores import FAISS\n'), ((3669, 3702), 'streamlit.spinner', 'st.spinner', (['"""Saving vector store"""'], {}), "('Saving vector store')\n", (3679, 3702), True, 'import streamlit as st\n'), ((1648, 1690), 'os.path.join', 'os.path.join', (['DOCS_DIR', 'uploaded_file.name'], {}), '(DOCS_DIR, uploaded_file.name)\n', (1660, 1690), False, 'import os\n'), ((3781, 3808), 'pickle.dump', 'pickle.dump', (['vectorstore', 'f'], {}), '(vectorstore, f)\n', (3792, 3808), False, 'import pickle\n')] |
from langchain.chains import RetrievalQA, ConversationalRetrievalChain, ConversationChain
from langchain.prompts.prompt import PromptTemplate
from langchain.vectorstores.base import VectorStoreRetriever
from langchain.chat_models import ChatOpenAI
from langchain.memory import ConversationBufferMemory
import pickle
import os
from env import OPENAI_API_KEY
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question.
You can assume the question about the most recent state of the union address.
Chat History:
{chat_history}
Follow Up Input: {question}
Standalone question:"""
CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
template = """You are an AI assistant for answering questions about the most recent state of the union address.
You are given the following extracted parts of a long document and a question. Provide a conversational answer.
If you don't know the answer, just say "Hmm, I'm not sure." Don't try to make up an answer.
If the question is not about the most recent state of the union, politely inform them that you are tuned to only answer questions about the most recent state of the union.
Lastly, answer the question as if you were a pirate from the south seas and are just coming back from a pirate expedition where you found a treasure chest full of gold doubloons.
Question: {question}
=========
{context}
=========
Answer in Markdown:"""
QA_PROMPT = PromptTemplate(template=template, input_variables=[
"question", "context"])
pyhealth_template = """
1. role clarification, task definition (high-level instruction), and model encouragement
2. task flow/procedures (input/output clarification)
3. information (chat history, retrieval results: doc + codes) -> separate code doc and txt doc
4. notice (law, regulation, policy, etc.) -> !!!
5. now, give the response.
tricks:
- important info should be at the beginning or in the end. knowledge is in the middle.
- use "sep" to block the prompt
"""
def load_retriever():
with open("vectorstore.pkl", "rb") as f:
vectorstore = pickle.load(f)
retriever = VectorStoreRetriever(vectorstore=vectorstore)
return retriever
def get_basic_qa_chain():
llm = ChatOpenAI(model_name="gpt-4", temperature=0)
retriever = load_retriever()
memory = ConversationBufferMemory(
memory_key="chat_history", return_messages=True)
model = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
memory=memory)
return model
def get_custom_prompt_qa_chain():
llm = ChatOpenAI(model_name="gpt-4", temperature=0)
retriever = load_retriever()
memory = ConversationBufferMemory(
memory_key="chat_history", return_messages=True)
# see: https://github.com/langchain-ai/langchain/issues/6635
# see: https://github.com/langchain-ai/langchain/issues/1497
model = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
memory=memory,
combine_docs_chain_kwargs={"prompt": QA_PROMPT})
return model
def get_condense_prompt_qa_chain():
llm = ChatOpenAI(model_name="gpt-4", temperature=0)
retriever = load_retriever()
memory = ConversationBufferMemory(
memory_key="chat_history", return_messages=True)
# see: https://github.com/langchain-ai/langchain/issues/5890
model = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
memory=memory,
condense_question_prompt=CONDENSE_QUESTION_PROMPT,
combine_docs_chain_kwargs={"prompt": QA_PROMPT})
return model
def get_qa_with_sources_chain():
llm = ChatOpenAI(model_name="gpt-4", temperature=0)
retriever = load_retriever()
history = []
model = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
return_source_documents=True)
def model_func(question):
# bug: this doesn't work with the built-in memory
# hacking around it for the tutorial
# see: https://github.com/langchain-ai/langchain/issues/5630
new_input = {"question": question['question'], "chat_history": history}
result = model(new_input)
history.append((question['question'], result['answer']))
return result
return model_func
def get_basic_chain():
llm = ChatOpenAI(model_name="gpt-4", temperature=0)
memory = ConversationBufferMemory()
model = ConversationChain(
llm=llm,
memory=memory)
return model
chain_options = {
"basic": get_basic_qa_chain,
"with_sources": get_qa_with_sources_chain,
"custom_prompt": get_custom_prompt_qa_chain,
"condense_prompt": get_condense_prompt_qa_chain
}
| [
"langchain.chains.ConversationChain",
"langchain.prompts.prompt.PromptTemplate",
"langchain.vectorstores.base.VectorStoreRetriever",
"langchain.chains.ConversationalRetrievalChain.from_llm",
"langchain.memory.ConversationBufferMemory",
"langchain.chat_models.ChatOpenAI",
"langchain.prompts.prompt.PromptTemplate.from_template"
] | [((727, 766), 'langchain.prompts.prompt.PromptTemplate.from_template', 'PromptTemplate.from_template', (['_template'], {}), '(_template)\n', (755, 766), False, 'from langchain.prompts.prompt import PromptTemplate\n'), ((1521, 1595), 'langchain.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'template': 'template', 'input_variables': "['question', 'context']"}), "(template=template, input_variables=['question', 'context'])\n", (1535, 1595), False, 'from langchain.prompts.prompt import PromptTemplate\n'), ((2225, 2270), 'langchain.vectorstores.base.VectorStoreRetriever', 'VectorStoreRetriever', ([], {'vectorstore': 'vectorstore'}), '(vectorstore=vectorstore)\n', (2245, 2270), False, 'from langchain.vectorstores.base import VectorStoreRetriever\n'), ((2330, 2375), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-4"""', 'temperature': '(0)'}), "(model_name='gpt-4', temperature=0)\n", (2340, 2375), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2422, 2495), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(memory_key='chat_history', return_messages=True)\n", (2446, 2495), False, 'from langchain.memory import ConversationBufferMemory\n'), ((2517, 2604), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', ([], {'llm': 'llm', 'retriever': 'retriever', 'memory': 'memory'}), '(llm=llm, retriever=retriever, memory=\n memory)\n', (2554, 2604), False, 'from langchain.chains import RetrievalQA, ConversationalRetrievalChain, ConversationChain\n'), ((2688, 2733), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-4"""', 'temperature': '(0)'}), "(model_name='gpt-4', temperature=0)\n", (2698, 2733), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2780, 2853), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(memory_key='chat_history', return_messages=True)\n", (2804, 2853), False, 'from langchain.memory import ConversationBufferMemory\n'), ((3005, 3141), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', ([], {'llm': 'llm', 'retriever': 'retriever', 'memory': 'memory', 'combine_docs_chain_kwargs': "{'prompt': QA_PROMPT}"}), "(llm=llm, retriever=retriever, memory=\n memory, combine_docs_chain_kwargs={'prompt': QA_PROMPT})\n", (3042, 3141), False, 'from langchain.chains import RetrievalQA, ConversationalRetrievalChain, ConversationChain\n'), ((3235, 3280), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-4"""', 'temperature': '(0)'}), "(model_name='gpt-4', temperature=0)\n", (3245, 3280), False, 'from langchain.chat_models import ChatOpenAI\n'), ((3327, 3400), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(memory_key='chat_history', return_messages=True)\n", (3351, 3400), False, 'from langchain.memory import ConversationBufferMemory\n'), ((3487, 3678), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', ([], {'llm': 'llm', 'retriever': 'retriever', 'memory': 'memory', 'condense_question_prompt': 'CONDENSE_QUESTION_PROMPT', 'combine_docs_chain_kwargs': "{'prompt': QA_PROMPT}"}), "(llm=llm, retriever=retriever, memory=\n memory, condense_question_prompt=CONDENSE_QUESTION_PROMPT,\n combine_docs_chain_kwargs={'prompt': QA_PROMPT})\n", (3524, 3678), False, 'from langchain.chains import RetrievalQA, ConversationalRetrievalChain, ConversationChain\n'), ((3773, 3818), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-4"""', 'temperature': '(0)'}), "(model_name='gpt-4', temperature=0)\n", (3783, 3818), False, 'from langchain.chat_models import ChatOpenAI\n'), ((3881, 3982), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', ([], {'llm': 'llm', 'retriever': 'retriever', 'return_source_documents': '(True)'}), '(llm=llm, retriever=retriever,\n return_source_documents=True)\n', (3918, 3982), False, 'from langchain.chains import RetrievalQA, ConversationalRetrievalChain, ConversationChain\n'), ((4466, 4511), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-4"""', 'temperature': '(0)'}), "(model_name='gpt-4', temperature=0)\n", (4476, 4511), False, 'from langchain.chat_models import ChatOpenAI\n'), ((4525, 4551), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {}), '()\n', (4549, 4551), False, 'from langchain.memory import ConversationBufferMemory\n'), ((4564, 4605), 'langchain.chains.ConversationChain', 'ConversationChain', ([], {'llm': 'llm', 'memory': 'memory'}), '(llm=llm, memory=memory)\n', (4581, 4605), False, 'from langchain.chains import RetrievalQA, ConversationalRetrievalChain, ConversationChain\n'), ((2194, 2208), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (2205, 2208), False, 'import pickle\n')] |
# flake8: noqa
from langchain.prompts import PromptTemplate
## Use a shorter template to reduce the number of tokens in the prompt
template = """Create a final answer to the given questions using the provided document excerpts (given in no particular order) as sources. ALWAYS include a "SOURCES" section in your answer citing only the minimal set of sources needed to answer the question. If you are unable to answer the question, simply state that you do not have enough information to answer the question and leave the SOURCES section empty. Use only the provided documents and do not attempt to fabricate an answer.
---------
QUESTION: What is the purpose of ARPA-H?
=========
Content: More support for patients and families. \n\nTo get there, I call on Congress to fund ARPA-H, the Advanced Research Projects Agency for Health. \n\nIt's based on DARPA—the Defense Department project that led to the Internet, GPS, and so much more. \n\nARPA-H will have a singular purpose—to drive breakthroughs in cancer, Alzheimer's, diabetes, and more.
SOURCES: 1-32
Content: While we're at it, let's make sure every American can get the health care they need. \n\nWe've already made historic investments in health care. \n\nWe've made it easier for Americans to get the care they need, when they need it. \n\nWe've made it easier for Americans to get the treatments they need, when they need them. \n\nWe've made it easier for Americans to get the medications they need, when they need them.
SOURCES: 1-33
Content: The V.A. is pioneering new ways of linking toxic exposures to disease, already helping veterans get the care they deserve. \n\nWe need to extend that same care to all Americans. \n\nThat's why I'm calling on Congress to pass legislation that would establish a national registry of toxic exposures, and provide health care and financial assistance to those affected.
SOURCES: 1-30
=========
FINAL ANSWER: The purpose of ARPA-H is to drive breakthroughs in cancer, Alzheimer's, diabetes, and more.
SOURCES: 1-32
---------
QUESTION: {question}
=========
{summaries}
=========
FINAL ANSWER:"""
STUFF_PROMPT = PromptTemplate(
template=template, input_variables=["summaries", "question"]
)
| [
"langchain.prompts.PromptTemplate"
] | [((2121, 2197), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'template', 'input_variables': "['summaries', 'question']"}), "(template=template, input_variables=['summaries', 'question'])\n", (2135, 2197), False, 'from langchain.prompts import PromptTemplate\n')] |
import whisper
import textwrap
from langchain.chat_models import ChatOpenAI
from langchain.chains.summarize import load_summarize_chain
from langchain.schema import Document
from langchain.llms import OpenAI
from langchain import PromptTemplate
from langchain.chains import LLMChain
from langchain.document_loaders import WebBaseLoader
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
from datetime import datetime
# Transcribe audio
def transcribe_audio(path):
model = whisper.load_model("base")
transcription = model.transcribe(audio=path, fp16=False)
return textwrap.fill(transcription["text"], width=50)
# Summarize text
def summarize_text(text):
llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo-16k")
chain = load_summarize_chain(llm, chain_type="stuff")
docs = [Document(page_content=text)]
return chain.run(docs)
def summarize_web_content(url):
loader = WebBaseLoader(url)
docs = loader.load()
llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo-16k")
chain = load_summarize_chain(llm, chain_type="stuff")
return chain.run(docs)
# Export to PDF
def export_to_pdf(summary, title, participants, filename="summary.pdf"):
wrapped_summary = textwrap.fill(summary, width=75)
date_of_meeting = datetime.now().strftime("%Y-%m-%d")
# Clean and wrap the title
title = title.replace("\n", " ")
wrapped_title = textwrap.fill(title, width=50)
c = canvas.Canvas(filename, pagesize=letter)
width, height = letter
# Title
c.setFont("Helvetica-Bold", 18)
y_title = height - 100
for line in wrapped_title.split("\n"):
c.drawString(100, y_title, line)
y_title -= 20 # Adjust the line spacing as needed for the title
c.setFont("Helvetica", 12)
# Date
c.drawString(100, y_title - 30, f"Date: {date_of_meeting}")
# Participants
c.drawString(100, y_title - 50, "Participants:")
for i, participant in enumerate(participants):
c.drawString(120, y_title - 70 - (i * 14), participant)
# Summary
y_summary = y_title - 150 # Adjust this value based on the title and participants
for line in wrapped_summary.split("\n"):
c.drawString(100, y_summary, line)
y_summary -= 14
c.save()
def create_title(summary):
llm = OpenAI(temperature=0)
prompt = PromptTemplate(
input_variables=["summary"],
template="Create a title for this summary:{summary}?",
)
chain = LLMChain(llm=llm, prompt=prompt)
title = chain.run(summary)
title = title.replace("\n", " ").strip()
return title
# Example usage with MP3 file
path = "./17 VS Code Tips That Will Change Your Data Science Workflow.mp3"
participants = ["Alice", "Bob", "Charlie"]
transcription = transcribe_audio(path)
summary = summarize_text(transcription)
title = create_title(summary)
export_to_pdf(summary, title, participants, filename="summary-audio.pdf")
# Example usage with Web URL
web_url = "https://termene.ro/"
summary = summarize_web_content(web_url)
title = create_title(summary)
export_to_pdf(summary, title, participants=[], filename="summary-web.pdf")
| [
"langchain.chains.summarize.load_summarize_chain",
"langchain.llms.OpenAI",
"langchain.chat_models.ChatOpenAI",
"langchain.schema.Document",
"langchain.document_loaders.WebBaseLoader",
"langchain.chains.LLMChain",
"langchain.PromptTemplate"
] | [((508, 534), 'whisper.load_model', 'whisper.load_model', (['"""base"""'], {}), "('base')\n", (526, 534), False, 'import whisper\n'), ((607, 653), 'textwrap.fill', 'textwrap.fill', (["transcription['text']"], {'width': '(50)'}), "(transcription['text'], width=50)\n", (620, 653), False, 'import textwrap\n'), ((709, 766), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo-16k"""'}), "(temperature=0, model_name='gpt-3.5-turbo-16k')\n", (719, 766), False, 'from langchain.chat_models import ChatOpenAI\n'), ((779, 824), 'langchain.chains.summarize.load_summarize_chain', 'load_summarize_chain', (['llm'], {'chain_type': '"""stuff"""'}), "(llm, chain_type='stuff')\n", (799, 824), False, 'from langchain.chains.summarize import load_summarize_chain\n'), ((940, 958), 'langchain.document_loaders.WebBaseLoader', 'WebBaseLoader', (['url'], {}), '(url)\n', (953, 958), False, 'from langchain.document_loaders import WebBaseLoader\n'), ((995, 1052), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo-16k"""'}), "(temperature=0, model_name='gpt-3.5-turbo-16k')\n", (1005, 1052), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1065, 1110), 'langchain.chains.summarize.load_summarize_chain', 'load_summarize_chain', (['llm'], {'chain_type': '"""stuff"""'}), "(llm, chain_type='stuff')\n", (1085, 1110), False, 'from langchain.chains.summarize import load_summarize_chain\n'), ((1252, 1284), 'textwrap.fill', 'textwrap.fill', (['summary'], {'width': '(75)'}), '(summary, width=75)\n', (1265, 1284), False, 'import textwrap\n'), ((1432, 1462), 'textwrap.fill', 'textwrap.fill', (['title'], {'width': '(50)'}), '(title, width=50)\n', (1445, 1462), False, 'import textwrap\n'), ((1472, 1512), 'reportlab.pdfgen.canvas.Canvas', 'canvas.Canvas', (['filename'], {'pagesize': 'letter'}), '(filename, pagesize=letter)\n', (1485, 1512), False, 'from reportlab.pdfgen import canvas\n'), ((2335, 2356), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (2341, 2356), False, 'from langchain.llms import OpenAI\n'), ((2370, 2473), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['summary']", 'template': '"""Create a title for this summary:{summary}?"""'}), "(input_variables=['summary'], template=\n 'Create a title for this summary:{summary}?')\n", (2384, 2473), False, 'from langchain import PromptTemplate\n'), ((2505, 2537), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (2513, 2537), False, 'from langchain.chains import LLMChain\n'), ((837, 864), 'langchain.schema.Document', 'Document', ([], {'page_content': 'text'}), '(page_content=text)\n', (845, 864), False, 'from langchain.schema import Document\n'), ((1307, 1321), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1319, 1321), False, 'from datetime import datetime\n')] |
from langchain.agents import load_tools
from langchain.tools import AIPluginTool
from parse import *
from langchain.chat_models.base import BaseChatModel
from langchain.chat_models import ChatOpenAI, AzureChatOpenAI
import utils
def create_plugins_static():
plugins = [
AIPluginTool.from_plugin_url(
"https://www.klarna.com/.well-known/ai-plugin.json"
)
]
plugins += load_tools(["requests_all"])
return plugins
def create_chat_model(openai_config: utils.OpenAIConfig) -> BaseChatModel:
if openai_config.is_azure_openai():
return AzureChatOpenAI(
temperature=0,
openai_api_base=openai_config.AZURE_OPENAI_API_ENDPOINT,
openai_api_version=openai_config.AZURE_OPENAI_API_VERSION
if openai_config.AZURE_OPENAI_API_VERSION
else "2023-03-15-preview",
deployment_name=openai_config.AZURE_OPENAI_API_DEPLOYMENT_NAME,
openai_api_key=openai_config.OPENAI_API_KEY,
openai_api_type=openai_config.OPENAI_API_TYPE,
)
else:
return ChatOpenAI(
temperature=0,
openai_api_key=openai_config.OPENAI_API_KEY,
openai_organization=openai_config.OPENAI_ORG_ID,
model_name=openai_config.OPENAI_MODEL_ID,
)
| [
"langchain.tools.AIPluginTool.from_plugin_url",
"langchain.chat_models.AzureChatOpenAI",
"langchain.agents.load_tools",
"langchain.chat_models.ChatOpenAI"
] | [((410, 438), 'langchain.agents.load_tools', 'load_tools', (["['requests_all']"], {}), "(['requests_all'])\n", (420, 438), False, 'from langchain.agents import load_tools\n'), ((285, 371), 'langchain.tools.AIPluginTool.from_plugin_url', 'AIPluginTool.from_plugin_url', (['"""https://www.klarna.com/.well-known/ai-plugin.json"""'], {}), "(\n 'https://www.klarna.com/.well-known/ai-plugin.json')\n", (313, 371), False, 'from langchain.tools import AIPluginTool\n'), ((590, 984), 'langchain.chat_models.AzureChatOpenAI', 'AzureChatOpenAI', ([], {'temperature': '(0)', 'openai_api_base': 'openai_config.AZURE_OPENAI_API_ENDPOINT', 'openai_api_version': "(openai_config.AZURE_OPENAI_API_VERSION if openai_config.\n AZURE_OPENAI_API_VERSION else '2023-03-15-preview')", 'deployment_name': 'openai_config.AZURE_OPENAI_API_DEPLOYMENT_NAME', 'openai_api_key': 'openai_config.OPENAI_API_KEY', 'openai_api_type': 'openai_config.OPENAI_API_TYPE'}), "(temperature=0, openai_api_base=openai_config.\n AZURE_OPENAI_API_ENDPOINT, openai_api_version=openai_config.\n AZURE_OPENAI_API_VERSION if openai_config.AZURE_OPENAI_API_VERSION else\n '2023-03-15-preview', deployment_name=openai_config.\n AZURE_OPENAI_API_DEPLOYMENT_NAME, openai_api_key=openai_config.\n OPENAI_API_KEY, openai_api_type=openai_config.OPENAI_API_TYPE)\n", (605, 984), False, 'from langchain.chat_models import ChatOpenAI, AzureChatOpenAI\n'), ((1093, 1263), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'openai_api_key': 'openai_config.OPENAI_API_KEY', 'openai_organization': 'openai_config.OPENAI_ORG_ID', 'model_name': 'openai_config.OPENAI_MODEL_ID'}), '(temperature=0, openai_api_key=openai_config.OPENAI_API_KEY,\n openai_organization=openai_config.OPENAI_ORG_ID, model_name=\n openai_config.OPENAI_MODEL_ID)\n', (1103, 1263), False, 'from langchain.chat_models import ChatOpenAI, AzureChatOpenAI\n')] |
import re
import string
from collections import Counter
import numpy as np
import pandas as pd
import tqdm
from langchain.evaluation.qa import QAEvalChain
from langchain.llms import OpenAI
from algos.PWS import PWS_Base, PWS_Extra
from algos.notool import CoT, IO
from algos.react import ReactBase
def normalize_answer(s):
def remove_articles(text):
return re.sub(r"\b(a|an|the)\b", " ", text)
def white_space_fix(text):
return " ".join(text.split())
def remove_punc(text):
exclude = set(string.punctuation)
return "".join(ch for ch in text if ch not in exclude)
def lower(text):
return text.lower()
return white_space_fix(remove_articles(remove_punc(lower(s))))
def f1_score(prediction, ground_truth):
normalized_prediction = normalize_answer(prediction)
normalized_ground_truth = normalize_answer(ground_truth)
if normalized_prediction in ['yes', 'no', 'noanswer'] and normalized_prediction != normalized_ground_truth:
return 0
if normalized_ground_truth in ['yes', 'no', 'noanswer'] and normalized_prediction != normalized_ground_truth:
return 0
prediction_tokens = normalized_prediction.split()
ground_truth_tokens = normalized_ground_truth.split()
common = Counter(prediction_tokens) & Counter(ground_truth_tokens)
num_same = sum(common.values())
if num_same == 0:
return 0
precision = 1.0 * num_same / len(prediction_tokens)
recall = 1.0 * num_same / len(ground_truth_tokens)
f1 = (2 * precision * recall) / (precision + recall)
return f1
def llm_accuracy_score(query, prediction, ground_truth):
data = [{
'query': query,
'answer': ground_truth,
}]
pred = [{
'query': query,
'answer': ground_truth,
'result': prediction,
}]
eval_chain = QAEvalChain.from_llm(OpenAI(temperature=0))
graded_outputs = eval_chain.evaluate(data, pred)
return 1 if graded_outputs[0]['text'].strip() == 'CORRECT' else 0
class Evaluator:
def __init__(self, task, dataset, algo, maxtry=3):
assert task in ["hotpot_qa", "trivia_qa", "gsm8k", "physics_question", "disfl_qa",
"sports_understanding", "strategy_qa", "sotu_qa"]
assert isinstance(dataset, pd.DataFrame)
assert isinstance(algo, (PWS_Base, PWS_Extra, ReactBase, IO, CoT))
self.task = task
self.dataset = dataset
self.algo = algo
self.maxtry = maxtry
self.failed_response = self._failed_response()
self.eval_data = self._initialize_eval_dict()
def run(self):
print("\n******************* Start Evaluation *******************\n")
if self.task in ["hotpot_qa", "sotu_qa"]:
for i in tqdm.tqdm(range(len(self.dataset))):
question = self.dataset["question"][i]
label = self.dataset["answer"][i]
for _ in range(self.maxtry):
try:
response = self.algo.run(question)
break
except:
response = self.failed_response
self._update_eval_dict(question, label, response)
elif self.task == "fever":
for i in tqdm.tqdm(range(len(self.dataset))):
question = self.dataset["claim"][i]
label = self.dataset["label"][i]
for _ in range(self.maxtry):
try:
response = self.algo.run(question)
break
except:
response = self.failed_response
self._update_eval_dict(question, label, response)
elif self.task == "trivia_qa":
for i in tqdm.tqdm(range(len(self.dataset))):
question = self.dataset["question"][i]
label = self.dataset["answer"][i]["value"]
for _ in range(self.maxtry):
try:
response = self.algo.run(question)
break
except:
response = self.failed_response
self._update_eval_dict(question, label, response)
elif self.task == "gsm8k":
for i in tqdm.tqdm(range(len(self.dataset))):
question = self.dataset["question"][i]
label = self.dataset["answer"][i].split("#### ")[1]
for _ in range(self.maxtry):
try:
response = self.algo.run(question)
break
except:
response = self.failed_response
self._update_eval_dict(question, label, response)
elif self.task in ["physics_question", "sports_understanding", "strategy_qa"]:
for i in tqdm.tqdm(range(len(self.dataset))):
question = self.dataset["input"][i]
label = self.dataset["target"][i]
for _ in range(self.maxtry):
try:
response = self.algo.run(question)
break
except:
response = self.failed_response
self._update_eval_dict(question, label, response)
else:
raise NotImplementedError
return self._get_avg_results(), self.eval_data
def _initialize_eval_dict(self):
data = {}
for d in ["label", "preds", "em", "f1", "acc", "wall_time", "total_tokens", "total_cost", "steps", "token_cost",
"tool_cost", "planner_log", "solver_log"]:
data[d] = []
return data
def _update_eval_dict(self, question, label, response):
pred = self._parse_prediction(response["output"])
self.eval_data["label"] += [label]
self.eval_data["preds"] += [pred]
self.eval_data["em"] += [self.get_metrics(question, label, pred)["em"]]
self.eval_data["f1"] += [self.get_metrics(question, label, pred)["f1"]]
self.eval_data["acc"] += [self.get_metrics(question, label, pred)["acc"]]
self.eval_data["wall_time"] += [response["wall_time"]]
self.eval_data["total_tokens"] += [response["total_tokens"]]
self.eval_data["total_cost"] += [response["total_cost"]]
self.eval_data["steps"] += [response["steps"]]
self.eval_data["token_cost"] += [response["token_cost"]]
self.eval_data["tool_cost"] += [response["tool_cost"]]
if "planner_log" in response:
self.eval_data["planner_log"] += [response["planner_log"]]
if "solver_log" in response:
self.eval_data["solver_log"] += [response["solver_log"]]
def _get_avg_results(self):
result = {}
result["avg_em"] = np.nanmean(self.eval_data["em"])
result["avg_f1"] = np.nanmean(self.eval_data["f1"])
result["avg_acc"] = np.nanmean(self.eval_data["acc"])
result["avg_wall_time"] = np.nanmean(self.eval_data["wall_time"])
result["avg_total_tokens"] = np.nanmean(self.eval_data["total_tokens"])
result["avg_total_cost"] = np.nanmean(self.eval_data["total_cost"])
result["avg_steps"] = np.nanmean(self.eval_data["steps"])
result["avg_token_cost"] = np.nanmean(self.eval_data["token_cost"])
result["avg_tool_cost"] = np.nanmean(self.eval_data["tool_cost"])
return result
def get_metrics(self, query, label, pred):
if pred is None:
return {'em': 0, 'f1': 0}
norm_label = normalize_answer(label)
norm_pred = normalize_answer(pred)
em = (norm_pred == norm_label)
f1 = f1_score(norm_pred, norm_label)
acc = llm_accuracy_score(query, pred, label)
return {'em': em, 'f1': f1, 'acc': acc}
def _parse_prediction(self, output):
if isinstance(self.algo, IO):
return str(output).strip("\n")
elif isinstance(self.algo, CoT):
return str(output).split("\n")[-1].replace("Answer:", "")
elif isinstance(self.algo, ReactBase):
return str(output).strip("\n")
elif isinstance(self.algo, PWS_Base):
return str(output).strip("\n")
elif isinstance(self.algo, PWS_Extra):
return str(output).strip("\n")
def _failed_response(self):
resposne = {}
for key in ["input", "output", "wall_time", "total_tokens", "total_cost", "steps", "token_cost", "tool_cost"]:
resposne[key] = np.nan
return resposne
| [
"langchain.llms.OpenAI"
] | [((373, 410), 're.sub', 're.sub', (['"""\\\\b(a|an|the)\\\\b"""', '""" """', 'text'], {}), "('\\\\b(a|an|the)\\\\b', ' ', text)\n", (379, 410), False, 'import re\n'), ((1278, 1304), 'collections.Counter', 'Counter', (['prediction_tokens'], {}), '(prediction_tokens)\n', (1285, 1304), False, 'from collections import Counter\n'), ((1307, 1335), 'collections.Counter', 'Counter', (['ground_truth_tokens'], {}), '(ground_truth_tokens)\n', (1314, 1335), False, 'from collections import Counter\n'), ((1874, 1895), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (1880, 1895), False, 'from langchain.llms import OpenAI\n'), ((6841, 6873), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['em']"], {}), "(self.eval_data['em'])\n", (6851, 6873), True, 'import numpy as np\n'), ((6901, 6933), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['f1']"], {}), "(self.eval_data['f1'])\n", (6911, 6933), True, 'import numpy as np\n'), ((6962, 6995), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['acc']"], {}), "(self.eval_data['acc'])\n", (6972, 6995), True, 'import numpy as np\n'), ((7030, 7069), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['wall_time']"], {}), "(self.eval_data['wall_time'])\n", (7040, 7069), True, 'import numpy as np\n'), ((7107, 7149), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['total_tokens']"], {}), "(self.eval_data['total_tokens'])\n", (7117, 7149), True, 'import numpy as np\n'), ((7185, 7225), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['total_cost']"], {}), "(self.eval_data['total_cost'])\n", (7195, 7225), True, 'import numpy as np\n'), ((7256, 7291), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['steps']"], {}), "(self.eval_data['steps'])\n", (7266, 7291), True, 'import numpy as np\n'), ((7327, 7367), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['token_cost']"], {}), "(self.eval_data['token_cost'])\n", (7337, 7367), True, 'import numpy as np\n'), ((7402, 7441), 'numpy.nanmean', 'np.nanmean', (["self.eval_data['tool_cost']"], {}), "(self.eval_data['tool_cost'])\n", (7412, 7441), True, 'import numpy as np\n')] |
from datetime import date, datetime
from decimal import Decimal
from langchain.chains import LLMChain
from langchain.prompts.chat import (
ChatPromptTemplate,
HumanMessagePromptTemplate,
)
from sqlalchemy import text
from dataherald.model.chat_model import ChatModel
from dataherald.repositories.database_connections import DatabaseConnectionRepository
from dataherald.repositories.prompts import PromptRepository
from dataherald.sql_database.base import SQLDatabase, SQLInjectionError
from dataherald.types import LLMConfig, NLGeneration, SQLGeneration
HUMAN_TEMPLATE = """Given a Question, a Sql query and the sql query result try to answer the question
If the sql query result doesn't answer the question just say 'I don't know'
Answer the question given the sql query and the sql query result.
Question: {prompt}
SQL query: {sql_query}
SQL query result: {sql_query_result}
"""
class GeneratesNlAnswer:
def __init__(self, system, storage, llm_config: LLMConfig):
self.system = system
self.storage = storage
self.llm_config = llm_config
self.model = ChatModel(self.system)
def execute(
self,
sql_generation: SQLGeneration,
top_k: int = 100,
) -> NLGeneration:
prompt_repository = PromptRepository(self.storage)
prompt = prompt_repository.find_by_id(sql_generation.prompt_id)
db_connection_repository = DatabaseConnectionRepository(self.storage)
database_connection = db_connection_repository.find_by_id(
prompt.db_connection_id
)
self.llm = self.model.get_model(
database_connection=database_connection,
temperature=0,
model_name=self.llm_config.llm_name,
api_base=self.llm_config.api_base,
)
database = SQLDatabase.get_sql_engine(database_connection, True)
if sql_generation.status == "INVALID":
return NLGeneration(
sql_generation_id=sql_generation.id,
text="I don't know, the SQL query is invalid.",
created_at=datetime.now(),
)
try:
query = database.parser_to_filter_commands(sql_generation.sql)
with database._engine.connect() as connection:
execution = connection.execute(text(query))
result = execution.fetchmany(top_k)
rows = []
for row in result:
modified_row = {}
for key, value in zip(row.keys(), row, strict=True):
if type(value) in [
date,
datetime,
]: # Check if the value is an instance of datetime.date
modified_row[key] = str(value)
elif (
type(value) is Decimal
): # Check if the value is an instance of decimal.Decimal
modified_row[key] = float(value)
else:
modified_row[key] = value
rows.append(modified_row)
except SQLInjectionError as e:
raise SQLInjectionError(
"Sensitive SQL keyword detected in the query."
) from e
human_message_prompt = HumanMessagePromptTemplate.from_template(HUMAN_TEMPLATE)
chat_prompt = ChatPromptTemplate.from_messages([human_message_prompt])
chain = LLMChain(llm=self.llm, prompt=chat_prompt)
nl_resp = chain.invoke(
{
"prompt": prompt.text,
"sql_query": sql_generation.sql,
"sql_query_result": "\n".join([str(row) for row in rows]),
}
)
return NLGeneration(
sql_generation_id=sql_generation.id,
llm_config=self.llm_config,
text=nl_resp["text"],
created_at=datetime.now(),
)
| [
"langchain.prompts.chat.HumanMessagePromptTemplate.from_template",
"langchain.chains.LLMChain",
"langchain.prompts.chat.ChatPromptTemplate.from_messages"
] | [((1101, 1123), 'dataherald.model.chat_model.ChatModel', 'ChatModel', (['self.system'], {}), '(self.system)\n', (1110, 1123), False, 'from dataherald.model.chat_model import ChatModel\n'), ((1272, 1302), 'dataherald.repositories.prompts.PromptRepository', 'PromptRepository', (['self.storage'], {}), '(self.storage)\n', (1288, 1302), False, 'from dataherald.repositories.prompts import PromptRepository\n'), ((1411, 1453), 'dataherald.repositories.database_connections.DatabaseConnectionRepository', 'DatabaseConnectionRepository', (['self.storage'], {}), '(self.storage)\n', (1439, 1453), False, 'from dataherald.repositories.database_connections import DatabaseConnectionRepository\n'), ((1813, 1866), 'dataherald.sql_database.base.SQLDatabase.get_sql_engine', 'SQLDatabase.get_sql_engine', (['database_connection', '(True)'], {}), '(database_connection, True)\n', (1839, 1866), False, 'from dataherald.sql_database.base import SQLDatabase, SQLInjectionError\n'), ((3295, 3351), 'langchain.prompts.chat.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['HUMAN_TEMPLATE'], {}), '(HUMAN_TEMPLATE)\n', (3335, 3351), False, 'from langchain.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate\n'), ((3374, 3430), 'langchain.prompts.chat.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (['[human_message_prompt]'], {}), '([human_message_prompt])\n', (3406, 3430), False, 'from langchain.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate\n'), ((3447, 3489), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'self.llm', 'prompt': 'chat_prompt'}), '(llm=self.llm, prompt=chat_prompt)\n', (3455, 3489), False, 'from langchain.chains import LLMChain\n'), ((3160, 3225), 'dataherald.sql_database.base.SQLInjectionError', 'SQLInjectionError', (['"""Sensitive SQL keyword detected in the query."""'], {}), "('Sensitive SQL keyword detected in the query.')\n", (3177, 3225), False, 'from dataherald.sql_database.base import SQLDatabase, SQLInjectionError\n'), ((3898, 3912), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3910, 3912), False, 'from datetime import date, datetime\n'), ((2092, 2106), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (2104, 2106), False, 'from datetime import date, datetime\n'), ((2317, 2328), 'sqlalchemy.text', 'text', (['query'], {}), '(query)\n', (2321, 2328), False, 'from sqlalchemy import text\n')] |
import streamlit as st
import urllib
import os
import re
import time
import random
from operator import itemgetter
from collections import OrderedDict
from langchain_core.documents import Document
from langchain_openai import AzureChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from utils import get_search_results
from prompts import DOCSEARCH_PROMPT
st.set_page_config(page_title="GPT Smart Search", page_icon="📖", layout="wide")
# Add custom CSS styles to adjust padding
st.markdown("""
<style>
.block-container {
padding-top: 1rem;
padding-bottom: 0rem;
}
</style>
""", unsafe_allow_html=True)
st.header("GPT Smart Search Engine")
def clear_submit():
st.session_state["submit"] = False
with st.sidebar:
st.markdown("""# Instructions""")
st.markdown("""
Ask a question that you think can be answered with the information in about 10k Arxiv Computer Science publications from 2020-2021 or in 90k Medical Covid-19 Publications.
For example:
- What are markov chains?
- List the authors that talk about Boosting Algorithms
- How does random forest work?
- What kind of problems can I solve with reinforcement learning? Give me some real life examples
- What kind of problems Turing Machines solve?
- What are the main risk factors for Covid-19?
- What medicine reduces inflammation in the lungs?
- Why Covid doesn't affect kids that much compared to adults?
\nYou will notice that the answers to these questions are diferent from the open ChatGPT, since these papers are the only possible context. This search engine does not look at the open internet to answer these questions. If the context doesn't contain information, the engine will respond: I don't know.
""")
coli1, coli2= st.columns([3,1])
with coli1:
query = st.text_input("Ask a question to your enterprise data lake", value= "What are the main risk factors for Covid-19?", on_change=clear_submit)
button = st.button('Search')
if (not os.environ.get("AZURE_SEARCH_ENDPOINT")) or (os.environ.get("AZURE_SEARCH_ENDPOINT") == ""):
st.error("Please set your AZURE_SEARCH_ENDPOINT on your Web App Settings")
elif (not os.environ.get("AZURE_SEARCH_KEY")) or (os.environ.get("AZURE_SEARCH_KEY") == ""):
st.error("Please set your AZURE_SEARCH_ENDPOINT on your Web App Settings")
elif (not os.environ.get("AZURE_OPENAI_ENDPOINT")) or (os.environ.get("AZURE_OPENAI_ENDPOINT") == ""):
st.error("Please set your AZURE_OPENAI_ENDPOINT on your Web App Settings")
elif (not os.environ.get("AZURE_OPENAI_API_KEY")) or (os.environ.get("AZURE_OPENAI_API_KEY") == ""):
st.error("Please set your AZURE_OPENAI_API_KEY on your Web App Settings")
elif (not os.environ.get("BLOB_SAS_TOKEN")) or (os.environ.get("BLOB_SAS_TOKEN") == ""):
st.error("Please set your BLOB_SAS_TOKEN on your Web App Settings")
else:
os.environ["OPENAI_API_VERSION"] = os.environ["AZURE_OPENAI_API_VERSION"]
MODEL = os.environ.get("AZURE_OPENAI_MODEL_NAME")
llm = AzureChatOpenAI(deployment_name=MODEL, temperature=0.5, max_tokens=1500)
if button or st.session_state.get("submit"):
if not query:
st.error("Please enter a question!")
else:
# Azure Search
try:
indexes = ["cogsrch-index-files", "cogsrch-index-csv"]
k = 6
ordered_results = get_search_results(query, indexes, k=k, reranker_threshold=1, sas_token=os.environ['BLOB_SAS_TOKEN'])
st.session_state["submit"] = True
# Output Columns
placeholder = st.empty()
except Exception as e:
st.markdown("Not data returned from Azure Search, check connection..")
st.markdown(e)
if "ordered_results" in locals():
try:
top_docs = []
for key,value in ordered_results.items():
location = value["location"] if value["location"] is not None else ""
top_docs.append(Document(page_content=value["chunk"], metadata={"source": location, "score":value["score"]}))
add_text = "Reading the source documents to provide the best answer... ⏳"
if "add_text" in locals():
with st.spinner(add_text):
if(len(top_docs)>0):
chain = (
DOCSEARCH_PROMPT # Passes the 4 variables above to the prompt template
| llm # Passes the finished prompt to the LLM
| StrOutputParser() # converts the output (Runnable object) to the desired output (string)
)
answer = chain.invoke({"question": query, "context":top_docs})
else:
answer = {"output_text":"No results found" }
else:
answer = {"output_text":"No results found" }
with placeholder.container():
st.markdown("#### Answer")
st.markdown(answer, unsafe_allow_html=True)
st.markdown("---")
st.markdown("#### Search Results")
if(len(top_docs)>0):
for key, value in ordered_results.items():
location = value["location"] if value["location"] is not None else ""
title = str(value['title']) if (value['title']) else value['name']
score = str(round(value['score']*100/4,2))
st.markdown("[" + title + "](" + location + ")" + " (Score: " + score + "%)")
st.markdown(value["caption"])
st.markdown("---")
except Exception as e:
st.error(e) | [
"langchain_openai.AzureChatOpenAI",
"langchain_core.documents.Document",
"langchain_core.output_parsers.StrOutputParser"
] | [((376, 455), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""GPT Smart Search"""', 'page_icon': '"""📖"""', 'layout': '"""wide"""'}), "(page_title='GPT Smart Search', page_icon='📖', layout='wide')\n", (394, 455), True, 'import streamlit as st\n'), ((498, 726), 'streamlit.markdown', 'st.markdown', (['"""\n <style>\n .block-container {\n padding-top: 1rem;\n padding-bottom: 0rem;\n }\n </style>\n """'], {'unsafe_allow_html': '(True)'}), '(\n """\n <style>\n .block-container {\n padding-top: 1rem;\n padding-bottom: 0rem;\n }\n </style>\n """\n , unsafe_allow_html=True)\n', (509, 726), True, 'import streamlit as st\n'), ((718, 754), 'streamlit.header', 'st.header', (['"""GPT Smart Search Engine"""'], {}), "('GPT Smart Search Engine')\n", (727, 754), True, 'import streamlit as st\n'), ((1832, 1850), 'streamlit.columns', 'st.columns', (['[3, 1]'], {}), '([3, 1])\n', (1842, 1850), True, 'import streamlit as st\n'), ((2024, 2043), 'streamlit.button', 'st.button', (['"""Search"""'], {}), "('Search')\n", (2033, 2043), True, 'import streamlit as st\n'), ((839, 868), 'streamlit.markdown', 'st.markdown', (['"""# Instructions"""'], {}), "('# Instructions')\n", (850, 868), True, 'import streamlit as st\n'), ((877, 1825), 'streamlit.markdown', 'st.markdown', (['"""\nAsk a question that you think can be answered with the information in about 10k Arxiv Computer Science publications from 2020-2021 or in 90k Medical Covid-19 Publications.\n\nFor example:\n- What are markov chains?\n- List the authors that talk about Boosting Algorithms\n- How does random forest work?\n- What kind of problems can I solve with reinforcement learning? Give me some real life examples\n- What kind of problems Turing Machines solve?\n- What are the main risk factors for Covid-19?\n- What medicine reduces inflammation in the lungs?\n- Why Covid doesn\'t affect kids that much compared to adults?\n \n \nYou will notice that the answers to these questions are diferent from the open ChatGPT, since these papers are the only possible context. This search engine does not look at the open internet to answer these questions. If the context doesn\'t contain information, the engine will respond: I don\'t know.\n """'], {}), '(\n """\nAsk a question that you think can be answered with the information in about 10k Arxiv Computer Science publications from 2020-2021 or in 90k Medical Covid-19 Publications.\n\nFor example:\n- What are markov chains?\n- List the authors that talk about Boosting Algorithms\n- How does random forest work?\n- What kind of problems can I solve with reinforcement learning? Give me some real life examples\n- What kind of problems Turing Machines solve?\n- What are the main risk factors for Covid-19?\n- What medicine reduces inflammation in the lungs?\n- Why Covid doesn\'t affect kids that much compared to adults?\n \n \nYou will notice that the answers to these questions are diferent from the open ChatGPT, since these papers are the only possible context. This search engine does not look at the open internet to answer these questions. If the context doesn\'t contain information, the engine will respond: I don\'t know.\n """\n )\n', (888, 1825), True, 'import streamlit as st\n'), ((1874, 2017), 'streamlit.text_input', 'st.text_input', (['"""Ask a question to your enterprise data lake"""'], {'value': '"""What are the main risk factors for Covid-19?"""', 'on_change': 'clear_submit'}), "('Ask a question to your enterprise data lake', value=\n 'What are the main risk factors for Covid-19?', on_change=clear_submit)\n", (1887, 2017), True, 'import streamlit as st\n'), ((2152, 2226), 'streamlit.error', 'st.error', (['"""Please set your AZURE_SEARCH_ENDPOINT on your Web App Settings"""'], {}), "('Please set your AZURE_SEARCH_ENDPOINT on your Web App Settings')\n", (2160, 2226), True, 'import streamlit as st\n'), ((2055, 2094), 'os.environ.get', 'os.environ.get', (['"""AZURE_SEARCH_ENDPOINT"""'], {}), "('AZURE_SEARCH_ENDPOINT')\n", (2069, 2094), False, 'import os\n'), ((2100, 2139), 'os.environ.get', 'os.environ.get', (['"""AZURE_SEARCH_ENDPOINT"""'], {}), "('AZURE_SEARCH_ENDPOINT')\n", (2114, 2139), False, 'import os\n'), ((2324, 2398), 'streamlit.error', 'st.error', (['"""Please set your AZURE_SEARCH_ENDPOINT on your Web App Settings"""'], {}), "('Please set your AZURE_SEARCH_ENDPOINT on your Web App Settings')\n", (2332, 2398), True, 'import streamlit as st\n'), ((2237, 2271), 'os.environ.get', 'os.environ.get', (['"""AZURE_SEARCH_KEY"""'], {}), "('AZURE_SEARCH_KEY')\n", (2251, 2271), False, 'import os\n'), ((2277, 2311), 'os.environ.get', 'os.environ.get', (['"""AZURE_SEARCH_KEY"""'], {}), "('AZURE_SEARCH_KEY')\n", (2291, 2311), False, 'import os\n'), ((2506, 2580), 'streamlit.error', 'st.error', (['"""Please set your AZURE_OPENAI_ENDPOINT on your Web App Settings"""'], {}), "('Please set your AZURE_OPENAI_ENDPOINT on your Web App Settings')\n", (2514, 2580), True, 'import streamlit as st\n'), ((2409, 2448), 'os.environ.get', 'os.environ.get', (['"""AZURE_OPENAI_ENDPOINT"""'], {}), "('AZURE_OPENAI_ENDPOINT')\n", (2423, 2448), False, 'import os\n'), ((2454, 2493), 'os.environ.get', 'os.environ.get', (['"""AZURE_OPENAI_ENDPOINT"""'], {}), "('AZURE_OPENAI_ENDPOINT')\n", (2468, 2493), False, 'import os\n'), ((2686, 2759), 'streamlit.error', 'st.error', (['"""Please set your AZURE_OPENAI_API_KEY on your Web App Settings"""'], {}), "('Please set your AZURE_OPENAI_API_KEY on your Web App Settings')\n", (2694, 2759), True, 'import streamlit as st\n'), ((2591, 2629), 'os.environ.get', 'os.environ.get', (['"""AZURE_OPENAI_API_KEY"""'], {}), "('AZURE_OPENAI_API_KEY')\n", (2605, 2629), False, 'import os\n'), ((2635, 2673), 'os.environ.get', 'os.environ.get', (['"""AZURE_OPENAI_API_KEY"""'], {}), "('AZURE_OPENAI_API_KEY')\n", (2649, 2673), False, 'import os\n'), ((2853, 2920), 'streamlit.error', 'st.error', (['"""Please set your BLOB_SAS_TOKEN on your Web App Settings"""'], {}), "('Please set your BLOB_SAS_TOKEN on your Web App Settings')\n", (2861, 2920), True, 'import streamlit as st\n'), ((3024, 3065), 'os.environ.get', 'os.environ.get', (['"""AZURE_OPENAI_MODEL_NAME"""'], {}), "('AZURE_OPENAI_MODEL_NAME')\n", (3038, 3065), False, 'import os\n'), ((3076, 3148), 'langchain_openai.AzureChatOpenAI', 'AzureChatOpenAI', ([], {'deployment_name': 'MODEL', 'temperature': '(0.5)', 'max_tokens': '(1500)'}), '(deployment_name=MODEL, temperature=0.5, max_tokens=1500)\n', (3091, 3148), False, 'from langchain_openai import AzureChatOpenAI\n'), ((2770, 2802), 'os.environ.get', 'os.environ.get', (['"""BLOB_SAS_TOKEN"""'], {}), "('BLOB_SAS_TOKEN')\n", (2784, 2802), False, 'import os\n'), ((2808, 2840), 'os.environ.get', 'os.environ.get', (['"""BLOB_SAS_TOKEN"""'], {}), "('BLOB_SAS_TOKEN')\n", (2822, 2840), False, 'import os\n'), ((3194, 3224), 'streamlit.session_state.get', 'st.session_state.get', (['"""submit"""'], {}), "('submit')\n", (3214, 3224), True, 'import streamlit as st\n'), ((3260, 3296), 'streamlit.error', 'st.error', (['"""Please enter a question!"""'], {}), "('Please enter a question!')\n", (3268, 3296), True, 'import streamlit as st\n'), ((3485, 3591), 'utils.get_search_results', 'get_search_results', (['query', 'indexes'], {'k': 'k', 'reranker_threshold': '(1)', 'sas_token': "os.environ['BLOB_SAS_TOKEN']"}), "(query, indexes, k=k, reranker_threshold=1, sas_token=os.\n environ['BLOB_SAS_TOKEN'])\n", (3503, 3591), False, 'from utils import get_search_results\n'), ((3713, 3723), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (3721, 3723), True, 'import streamlit as st\n'), ((3776, 3846), 'streamlit.markdown', 'st.markdown', (['"""Not data returned from Azure Search, check connection.."""'], {}), "('Not data returned from Azure Search, check connection..')\n", (3787, 3846), True, 'import streamlit as st\n'), ((3863, 3877), 'streamlit.markdown', 'st.markdown', (['e'], {}), '(e)\n', (3874, 3877), True, 'import streamlit as st\n'), ((5340, 5366), 'streamlit.markdown', 'st.markdown', (['"""#### Answer"""'], {}), "('#### Answer')\n", (5351, 5366), True, 'import streamlit as st\n'), ((5391, 5434), 'streamlit.markdown', 'st.markdown', (['answer'], {'unsafe_allow_html': '(True)'}), '(answer, unsafe_allow_html=True)\n', (5402, 5434), True, 'import streamlit as st\n'), ((5459, 5477), 'streamlit.markdown', 'st.markdown', (['"""---"""'], {}), "('---')\n", (5470, 5477), True, 'import streamlit as st\n'), ((5502, 5536), 'streamlit.markdown', 'st.markdown', (['"""#### Search Results"""'], {}), "('#### Search Results')\n", (5513, 5536), True, 'import streamlit as st\n'), ((6215, 6226), 'streamlit.error', 'st.error', (['e'], {}), '(e)\n', (6223, 6226), True, 'import streamlit as st\n'), ((4188, 4285), 'langchain_core.documents.Document', 'Document', ([], {'page_content': "value['chunk']", 'metadata': "{'source': location, 'score': value['score']}"}), "(page_content=value['chunk'], metadata={'source': location, 'score':\n value['score']})\n", (4196, 4285), False, 'from langchain_core.documents import Document\n'), ((4457, 4477), 'streamlit.spinner', 'st.spinner', (['add_text'], {}), '(add_text)\n', (4467, 4477), True, 'import streamlit as st\n'), ((5962, 6040), 'streamlit.markdown', 'st.markdown', (["('[' + title + '](' + location + ')' + ' (Score: ' + score + '%)')"], {}), "('[' + title + '](' + location + ')' + ' (Score: ' + score + '%)')\n", (5973, 6040), True, 'import streamlit as st\n'), ((6074, 6103), 'streamlit.markdown', 'st.markdown', (["value['caption']"], {}), "(value['caption'])\n", (6085, 6103), True, 'import streamlit as st\n'), ((6136, 6154), 'streamlit.markdown', 'st.markdown', (['"""---"""'], {}), "('---')\n", (6147, 6154), True, 'import streamlit as st\n'), ((4800, 4817), 'langchain_core.output_parsers.StrOutputParser', 'StrOutputParser', ([], {}), '()\n', (4815, 4817), False, 'from langchain_core.output_parsers import StrOutputParser\n')] |
from __future__ import annotations
import asyncio
import logging
import typing as t
from abc import ABC, abstractmethod
from dataclasses import dataclass
from functools import partial
from langchain_community.chat_models import ChatVertexAI
from langchain_community.llms import VertexAI
from langchain_core.language_models import BaseLanguageModel
from langchain_core.outputs import LLMResult
from langchain_openai.chat_models import AzureChatOpenAI, ChatOpenAI
from langchain_openai.llms import AzureOpenAI, OpenAI
from langchain_openai.llms.base import BaseOpenAI
from ragas.run_config import RunConfig, add_async_retry, add_retry
if t.TYPE_CHECKING:
from langchain_core.callbacks import Callbacks
from ragas.llms.prompt import PromptValue
logger = logging.getLogger(__name__)
MULTIPLE_COMPLETION_SUPPORTED = [
OpenAI,
ChatOpenAI,
AzureOpenAI,
AzureChatOpenAI,
ChatVertexAI,
VertexAI,
]
def is_multiple_completion_supported(llm: BaseLanguageModel) -> bool:
"""Return whether the given LLM supports n-completion."""
for llm_type in MULTIPLE_COMPLETION_SUPPORTED:
if isinstance(llm, llm_type):
return True
return False
@dataclass
class BaseRagasLLM(ABC):
run_config: RunConfig
def set_run_config(self, run_config: RunConfig):
self.run_config = run_config
def get_temperature(self, n: int) -> float:
"""Return the temperature to use for completion based on n."""
return 0.3 if n > 1 else 1e-8
@abstractmethod
def generate_text(
self,
prompt: PromptValue,
n: int = 1,
temperature: float = 1e-8,
stop: t.Optional[t.List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
...
@abstractmethod
async def agenerate_text(
self,
prompt: PromptValue,
n: int = 1,
temperature: float = 1e-8,
stop: t.Optional[t.List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
...
async def generate(
self,
prompt: PromptValue,
n: int = 1,
temperature: float = 1e-8,
stop: t.Optional[t.List[str]] = None,
callbacks: Callbacks = None,
is_async: bool = True,
) -> LLMResult:
"""Generate text using the given event loop."""
if is_async:
agenerate_text_with_retry = add_async_retry(
self.agenerate_text, self.run_config
)
return await agenerate_text_with_retry(
prompt=prompt,
n=n,
temperature=temperature,
stop=stop,
callbacks=callbacks,
)
else:
loop = asyncio.get_event_loop()
generate_text_with_retry = add_retry(self.generate_text, self.run_config)
generate_text = partial(
generate_text_with_retry,
prompt=prompt,
n=n,
temperature=temperature,
stop=stop,
callbacks=callbacks,
)
return await loop.run_in_executor(None, generate_text)
class LangchainLLMWrapper(BaseRagasLLM):
"""
A simple base class for RagasLLMs that is based on Langchain's BaseLanguageModel
interface. it implements 2 functions:
- generate_text: for generating text from a given PromptValue
- agenerate_text: for generating text from a given PromptValue asynchronously
"""
def __init__(
self, langchain_llm: BaseLanguageModel, run_config: t.Optional[RunConfig] = None
):
self.langchain_llm = langchain_llm
if run_config is None:
run_config = RunConfig()
self.set_run_config(run_config)
def generate_text(
self,
prompt: PromptValue,
n: int = 1,
temperature: float = 1e-8,
stop: t.Optional[t.List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
temperature = self.get_temperature(n=n)
if is_multiple_completion_supported(self.langchain_llm):
return self.langchain_llm.generate_prompt(
prompts=[prompt],
n=n,
temperature=temperature,
stop=stop,
callbacks=callbacks,
)
else:
result = self.langchain_llm.generate_prompt(
prompts=[prompt] * n,
temperature=temperature,
stop=stop,
callbacks=callbacks,
)
# make LLMResult.generation appear as if it was n_completions
# note that LLMResult.runs is still a list that represents each run
generations = [[g[0] for g in result.generations]]
result.generations = generations
return result
async def agenerate_text(
self,
prompt: PromptValue,
n: int = 1,
temperature: float = 1e-8,
stop: t.Optional[t.List[str]] = None,
callbacks: Callbacks = None,
) -> LLMResult:
temperature = self.get_temperature(n=n)
if is_multiple_completion_supported(self.langchain_llm):
return await self.langchain_llm.agenerate_prompt(
prompts=[prompt],
n=n,
temperature=temperature,
stop=stop,
callbacks=callbacks,
)
else:
result = await self.langchain_llm.agenerate_prompt(
prompts=[prompt] * n,
temperature=temperature,
stop=stop,
callbacks=callbacks,
)
# make LLMResult.generation appear as if it was n_completions
# note that LLMResult.runs is still a list that represents each run
generations = [[g[0] for g in result.generations]]
result.generations = generations
return result
def set_run_config(self, run_config: RunConfig):
self.run_config = run_config
# configure if using OpenAI API
if isinstance(self.langchain_llm, BaseOpenAI) or isinstance(
self.langchain_llm, ChatOpenAI
):
try:
from openai import RateLimitError
except ImportError:
raise ImportError(
"openai.error.RateLimitError not found. Please install openai package as `pip install openai`"
)
self.langchain_llm.request_timeout = run_config.timeout
self.run_config.exception_types = RateLimitError
def llm_factory(
model: str = "gpt-3.5-turbo-16k", run_config: t.Optional[RunConfig] = None
) -> BaseRagasLLM:
timeout = None
if run_config is not None:
timeout = run_config.timeout
openai_model = ChatOpenAI(model=model, timeout=timeout)
return LangchainLLMWrapper(openai_model, run_config)
| [
"langchain_openai.chat_models.ChatOpenAI"
] | [((765, 792), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (782, 792), False, 'import logging\n'), ((6829, 6869), 'langchain_openai.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model': 'model', 'timeout': 'timeout'}), '(model=model, timeout=timeout)\n', (6839, 6869), False, 'from langchain_openai.chat_models import AzureChatOpenAI, ChatOpenAI\n'), ((2400, 2453), 'ragas.run_config.add_async_retry', 'add_async_retry', (['self.agenerate_text', 'self.run_config'], {}), '(self.agenerate_text, self.run_config)\n', (2415, 2453), False, 'from ragas.run_config import RunConfig, add_async_retry, add_retry\n'), ((2740, 2764), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (2762, 2764), False, 'import asyncio\n'), ((2804, 2850), 'ragas.run_config.add_retry', 'add_retry', (['self.generate_text', 'self.run_config'], {}), '(self.generate_text, self.run_config)\n', (2813, 2850), False, 'from ragas.run_config import RunConfig, add_async_retry, add_retry\n'), ((2879, 2994), 'functools.partial', 'partial', (['generate_text_with_retry'], {'prompt': 'prompt', 'n': 'n', 'temperature': 'temperature', 'stop': 'stop', 'callbacks': 'callbacks'}), '(generate_text_with_retry, prompt=prompt, n=n, temperature=\n temperature, stop=stop, callbacks=callbacks)\n', (2886, 2994), False, 'from functools import partial\n'), ((3716, 3727), 'ragas.run_config.RunConfig', 'RunConfig', ([], {}), '()\n', (3725, 3727), False, 'from ragas.run_config import RunConfig, add_async_retry, add_retry\n')] |
"""Utility functions and constants.
I am having some problems caching the memory and the retrieval. When
I decorate for caching, I get streamlit init errors.
"""
import logging
import pathlib
from typing import Any
from langchain.document_loaders import (
PyPDFLoader,
TextLoader,
UnstructuredEPubLoader,
UnstructuredWordDocumentLoader,
)
from langchain.memory import ConversationBufferMemory
from langchain.schema import Document
def init_memory():
"""Initialize the memory for contextual conversation.
We are caching this, so it won't be deleted
every time, we restart the server.
"""
return ConversationBufferMemory(
memory_key='chat_history',
return_messages=True,
output_key='answer'
)
MEMORY = init_memory()
class EpubReader(UnstructuredEPubLoader):
def __init__(self, file_path: str | list[str], **unstructured_kwargs: Any):
super().__init__(file_path, **unstructured_kwargs, mode="elements", strategy="fast")
class DocumentLoaderException(Exception):
pass
class DocumentLoader(object):
"""Loads in a document with a supported extension."""
supported_extensions = {
".pdf": PyPDFLoader,
".txt": TextLoader,
".epub": EpubReader,
".docx": UnstructuredWordDocumentLoader,
".doc": UnstructuredWordDocumentLoader
}
def load_document(temp_filepath: str) -> list[Document]:
"""Load a file and return it as a list of documents.
Doesn't handle a lot of errors at the moment.
"""
ext = pathlib.Path(temp_filepath).suffix
loader = DocumentLoader.supported_extensions.get(ext)
if not loader:
raise DocumentLoaderException(
f"Invalid extension type {ext}, cannot load this type of file"
)
loaded = loader(temp_filepath)
docs = loaded.load()
logging.info(docs)
return docs
| [
"langchain.memory.ConversationBufferMemory"
] | [((637, 735), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'return_messages': '(True)', 'output_key': '"""answer"""'}), "(memory_key='chat_history', return_messages=True,\n output_key='answer')\n", (661, 735), False, 'from langchain.memory import ConversationBufferMemory\n'), ((1850, 1868), 'logging.info', 'logging.info', (['docs'], {}), '(docs)\n', (1862, 1868), False, 'import logging\n'), ((1549, 1576), 'pathlib.Path', 'pathlib.Path', (['temp_filepath'], {}), '(temp_filepath)\n', (1561, 1576), False, 'import pathlib\n')] |
import os
import re
import urllib
import urllib.parse
import urllib.request
from typing import Any, List, Tuple, Union
from urllib.parse import urlparse
import requests
from bs4 import BeautifulSoup
from langchain.chains import LLMChain
from langchain.prompts import Prompt
from langchain.tools import BaseTool
from langchain.utilities import GoogleSerperAPIWrapper
from langchain.vectorstores.base import VectorStoreRetriever
from loguru import logger
from typing_extensions import Literal
import sherpa_ai.config as cfg
from sherpa_ai.config.task_config import AgentConfig
from sherpa_ai.output_parser import TaskAction
def get_tools(memory, config):
tools = []
# tools.append(ContextTool(memory=memory))
tools.append(UserInputTool())
if cfg.SERPER_API_KEY is not None:
search_tool = SearchTool(config=config)
tools.append(search_tool)
else:
logger.warning(
"No SERPER_API_KEY found in environment variables, skipping SearchTool"
)
return tools
class SearchArxivTool(BaseTool):
name = "Arxiv Search"
description = (
"Access all the papers from Arxiv to search for domain-specific scientific publication." # noqa: E501
"Only use this tool when you need information in the scientific paper."
)
def _run(self, query: str) -> str:
top_k = 10
logger.debug(f"Search query: {query}")
query = urllib.parse.quote_plus(query)
url = (
"http://export.arxiv.org/api/query?search_query=all:"
+ query.strip()
+ "&start=0&max_results="
+ str(top_k)
)
data = urllib.request.urlopen(url)
xml_content = data.read().decode("utf-8")
summary_pattern = r"<summary>(.*?)</summary>"
summaries = re.findall(summary_pattern, xml_content, re.DOTALL)
title_pattern = r"<title>(.*?)</title>"
titles = re.findall(title_pattern, xml_content, re.DOTALL)
result_list = []
for i in range(len(titles)):
result_list.append(
"Title: " + titles[i] + "\n" + "Summary: " + summaries[i]
)
logger.debug(f"Arxiv Search Result: {result_list}")
return " ".join(result_list)
def _arun(self, query: str) -> str:
raise NotImplementedError("SearchArxivTool does not support async run")
class SearchTool(BaseTool):
name = "Search"
config = AgentConfig()
top_k: int = 10
description = (
"Access the internet to search for the information. Only use this tool when "
"you cannot find the information using internal search."
)
def _run(
self, query: str, require_meta=False
) -> Union[str, Tuple[str, List[dict]]]:
result = ""
if self.config.search_domains:
query_list = [
query + " Site: " + str(i) for i in self.config.search_domains
]
if len(query_list) >= 5:
query_list = query_list[:5]
result = (
result
+ "Warning: Only the first 5 URLs are taken into consideration.\n"
) # noqa: E501
else:
query_list = [query]
if self.config.invalid_domains:
invalid_domain_string = ", ".join(self.config.invalid_domains)
result = (
result
+ f"Warning: The doman {invalid_domain_string} is invalid and is not taken into consideration.\n" # noqa: E501
) # noqa: E501
top_k = int(self.top_k / len(query_list))
if require_meta:
meta = []
for query in query_list:
cur_result = self._run_single_query(query, top_k, require_meta)
if require_meta:
result += "\n" + cur_result[0]
meta.extend(cur_result[1])
else:
result += "\n" + cur_result
if require_meta:
result = (result, meta)
return result
def _run_single_query(
self, query: str, top_k: int, require_meta=False
) -> Union[str, Tuple[str, List[dict]]]:
logger.debug(f"Search query: {query}")
google_serper = GoogleSerperAPIWrapper()
search_results = google_serper._google_serper_api_results(query)
logger.debug(f"Google Search Result: {search_results}")
# case 1: answerBox in the result dictionary
if search_results.get("answerBox", False):
answer_box = search_results.get("answerBox", {})
if answer_box.get("answer"):
answer = answer_box.get("answer")
elif answer_box.get("snippet"):
answer = answer_box.get("snippet").replace("\n", " ")
elif answer_box.get("snippetHighlighted"):
answer = answer_box.get("snippetHighlighted")
title = search_results["organic"][0]["title"]
link = search_results["organic"][0]["link"]
response = "Answer: " + answer
meta = [{"Document": answer, "Source": link}]
if require_meta:
return response, meta
else:
return response + "\nLink:" + link
# case 2: knowledgeGraph in the result dictionary
snippets = []
if search_results.get("knowledgeGraph", False):
kg = search_results.get("knowledgeGraph", {})
title = kg.get("title")
entity_type = kg.get("type")
if entity_type:
snippets.append(f"{title}: {entity_type}.")
description = kg.get("description")
if description:
snippets.append(description)
for attribute, value in kg.get("attributes", {}).items():
snippets.append(f"{title} {attribute}: {value}.")
search_type: Literal["news", "search", "places", "images"] = "search"
result_key_for_type = {
"news": "news",
"places": "places",
"images": "images",
"search": "organic",
}
# case 3: general search results
for result in search_results[result_key_for_type[search_type]][:top_k]:
if "snippet" in result:
snippets.append(result["snippet"])
for attribute, value in result.get("attributes", {}).items():
snippets.append(f"{attribute}: {value}.")
if len(snippets) == 0:
return ["No good Google Search Result was found"]
result = []
meta = []
for i in range(len(search_results["organic"][:top_k])):
r = search_results["organic"][i]
single_result = r["title"] + r["snippet"]
# If the links are not considered explicitly, add it to the search result
# so that it can be considered by the LLM
if not require_meta:
single_result += "\nLink:" + r["link"]
result.append(single_result)
meta.append(
{
"Document": "Description: " + r["title"] + r["snippet"],
"Source": r["link"],
}
)
full_result = "\n".join(result)
# answer = " ".join(snippets)
if (
"knowledgeGraph" in search_results
and "description" in search_results["knowledgeGraph"]
and "descriptionLink" in search_results["knowledgeGraph"]
):
answer = (
"Description: "
+ search_results["knowledgeGraph"]["title"]
+ search_results["knowledgeGraph"]["description"]
+ "\nLink:"
+ search_results["knowledgeGraph"]["descriptionLink"]
)
full_result = answer + "\n\n" + full_result
if require_meta:
return full_result, meta
else:
return full_result
def _arun(self, query: str) -> str:
raise NotImplementedError("SearchTool does not support async run")
class ContextTool(BaseTool):
name = "Context Search"
description = (
"Access internal technical documentation for AI related projects, including"
+ "Fixie, LangChain, GPT index, GPTCache, GPT4ALL, autoGPT, db-GPT, AgentGPT, sherpa." # noqa: E501
+ "Only use this tool if you need information for these projects specifically."
)
memory: VectorStoreRetriever
def _run(self, query: str, need_meta=False) -> str:
docs = self.memory.get_relevant_documents(query)
result = ""
metadata = []
for doc in docs:
result += (
"Document"
+ doc.page_content
+ "\nLink:"
+ doc.metadata.get("source", "")
+ "\n"
)
if need_meta:
metadata.append(
{
"Document": doc.page_content,
"Source": doc.metadata.get("source", ""),
}
)
if need_meta:
return result, metadata
else:
return result
def _arun(self, query: str) -> str:
raise NotImplementedError("ContextTool does not support async run")
class UserInputTool(BaseTool):
# TODO: Make an action for the user input
name = "UserInput"
description = (
"Access the user input for the task."
"You use this tool if you need more context and would like to ask clarifying questions to solve the task" # noqa: E501
)
def _run(self, query: str) -> str:
return input(query)
def _arun(self, query: str) -> str:
raise NotImplementedError("UserInputTool does not support async run")
| [
"langchain.utilities.GoogleSerperAPIWrapper"
] | [((2438, 2451), 'sherpa_ai.config.task_config.AgentConfig', 'AgentConfig', ([], {}), '()\n', (2449, 2451), False, 'from sherpa_ai.config.task_config import AgentConfig\n'), ((894, 986), 'loguru.logger.warning', 'logger.warning', (['"""No SERPER_API_KEY found in environment variables, skipping SearchTool"""'], {}), "(\n 'No SERPER_API_KEY found in environment variables, skipping SearchTool')\n", (908, 986), False, 'from loguru import logger\n'), ((1368, 1406), 'loguru.logger.debug', 'logger.debug', (['f"""Search query: {query}"""'], {}), "(f'Search query: {query}')\n", (1380, 1406), False, 'from loguru import logger\n'), ((1423, 1453), 'urllib.parse.quote_plus', 'urllib.parse.quote_plus', (['query'], {}), '(query)\n', (1446, 1453), False, 'import urllib\n'), ((1652, 1679), 'urllib.request.urlopen', 'urllib.request.urlopen', (['url'], {}), '(url)\n', (1674, 1679), False, 'import urllib\n'), ((1805, 1856), 're.findall', 're.findall', (['summary_pattern', 'xml_content', 're.DOTALL'], {}), '(summary_pattern, xml_content, re.DOTALL)\n', (1815, 1856), False, 'import re\n'), ((1922, 1971), 're.findall', 're.findall', (['title_pattern', 'xml_content', 're.DOTALL'], {}), '(title_pattern, xml_content, re.DOTALL)\n', (1932, 1971), False, 'import re\n'), ((2164, 2215), 'loguru.logger.debug', 'logger.debug', (['f"""Arxiv Search Result: {result_list}"""'], {}), "(f'Arxiv Search Result: {result_list}')\n", (2176, 2215), False, 'from loguru import logger\n'), ((4164, 4202), 'loguru.logger.debug', 'logger.debug', (['f"""Search query: {query}"""'], {}), "(f'Search query: {query}')\n", (4176, 4202), False, 'from loguru import logger\n'), ((4227, 4251), 'langchain.utilities.GoogleSerperAPIWrapper', 'GoogleSerperAPIWrapper', ([], {}), '()\n', (4249, 4251), False, 'from langchain.utilities import GoogleSerperAPIWrapper\n'), ((4333, 4388), 'loguru.logger.debug', 'logger.debug', (['f"""Google Search Result: {search_results}"""'], {}), "(f'Google Search Result: {search_results}')\n", (4345, 4388), False, 'from loguru import logger\n')] |
from dotenv import load_dotenv
from langchain_core.prompts import PromptTemplate
load_dotenv()
from langchain import hub
from langchain.agents import create_react_agent, AgentExecutor
from langchain_core.tools import Tool
from langchain_openai import ChatOpenAI
from tools.tools import get_profile_url
def lookup(name: str) -> str:
llm = ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo")
template = """
given the name {name_of_person} I want you to find a link to their Twitter profile page, and extract from it their username
In Your Final answer only the person's username"""
tools_for_agent_twitter = [
Tool(
name="Crawl Google 4 Twitter profile page",
func=get_profile_url,
description="useful for when you need get the Twitter Page URL",
),
]
# agent = initialize_agent(
# tools_for_agent_twitter,
# llm,
# agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
# verbose=True,
# )
prompt_template = PromptTemplate(
input_variables=["name_of_person"], template=template
)
react_prompt = hub.pull("hwchase17/react")
agent = create_react_agent(
llm=llm, tools=tools_for_agent_twitter, prompt=react_prompt
)
agent_executor = AgentExecutor(
agent=agent, tools=tools_for_agent_twitter, verbose=True
)
result = agent_executor.invoke(
input={"input": prompt_template.format_prompt(name_of_person=name)}
)
twitter_username = result["output"]
return twitter_username
| [
"langchain_openai.ChatOpenAI",
"langchain.agents.AgentExecutor",
"langchain.agents.create_react_agent",
"langchain_core.tools.Tool",
"langchain_core.prompts.PromptTemplate",
"langchain.hub.pull"
] | [((82, 95), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (93, 95), False, 'from dotenv import load_dotenv\n'), ((346, 399), 'langchain_openai.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo"""'}), "(temperature=0, model_name='gpt-3.5-turbo')\n", (356, 399), False, 'from langchain_openai import ChatOpenAI\n'), ((1031, 1100), 'langchain_core.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['name_of_person']", 'template': 'template'}), "(input_variables=['name_of_person'], template=template)\n", (1045, 1100), False, 'from langchain_core.prompts import PromptTemplate\n'), ((1135, 1162), 'langchain.hub.pull', 'hub.pull', (['"""hwchase17/react"""'], {}), "('hwchase17/react')\n", (1143, 1162), False, 'from langchain import hub\n'), ((1175, 1254), 'langchain.agents.create_react_agent', 'create_react_agent', ([], {'llm': 'llm', 'tools': 'tools_for_agent_twitter', 'prompt': 'react_prompt'}), '(llm=llm, tools=tools_for_agent_twitter, prompt=react_prompt)\n', (1193, 1254), False, 'from langchain.agents import create_react_agent, AgentExecutor\n'), ((1290, 1361), 'langchain.agents.AgentExecutor', 'AgentExecutor', ([], {'agent': 'agent', 'tools': 'tools_for_agent_twitter', 'verbose': '(True)'}), '(agent=agent, tools=tools_for_agent_twitter, verbose=True)\n', (1303, 1361), False, 'from langchain.agents import create_react_agent, AgentExecutor\n'), ((648, 787), 'langchain_core.tools.Tool', 'Tool', ([], {'name': '"""Crawl Google 4 Twitter profile page"""', 'func': 'get_profile_url', 'description': '"""useful for when you need get the Twitter Page URL"""'}), "(name='Crawl Google 4 Twitter profile page', func=get_profile_url,\n description='useful for when you need get the Twitter Page URL')\n", (652, 787), False, 'from langchain_core.tools import Tool\n')] |
import logging, json, os
from Utilities.envVars import *
from Utilities.envVars import *
# Import required libraries
from Utilities.cogSearchVsRetriever import CognitiveSearchVsRetriever
from langchain.chains import RetrievalQA
from langchain import PromptTemplate
from Utilities.evaluator import indexDocs
import json
import time
import pandas as pd
from collections import namedtuple
from Utilities.evaluator import searchEvaluatorRunIdIndex
import uuid
import tempfile
from Utilities.azureBlob import getBlob, getFullPath
from langchain.document_loaders import PDFMinerLoader, UnstructuredFileLoader
from Utilities.evaluator import createEvaluatorResultIndex, searchEvaluatorRunIdIndex
from langchain.chat_models import AzureChatOpenAI, ChatOpenAI
from langchain.evaluation.qa import QAEvalChain
from Utilities.evaluator import searchEvaluatorRunIndex, createEvaluatorRunIndex, getEvaluatorResult
RunDocs = namedtuple('RunDoc', ['evalatorQaData', 'totalQuestions', 'promptStyle', 'documentId',
'splitMethods', 'chunkSizes', 'overlaps',
'retrieverType', 'reEvaluate', 'topK', 'model', 'fileName',
'embeddingModelType', 'temperature', 'tokenLength'])
def getPrompts():
template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer. Use three sentences maximum. Keep the answer as concise as possible.
{context}
Question: {question}
Helpful Answer:"""
QaChainPrompt = PromptTemplate(input_variables=["context", "question"],template=template,)
template = """You are a teacher grading a quiz.
You are given a question, the student's answer, and the true answer, and are asked to score the student answer as either Correct or Incorrect.
Example Format:
QUESTION: question here
STUDENT ANSWER: student's answer here
TRUE ANSWER: true answer here
GRADE: Correct or Incorrect here
Grade the student answers based ONLY on their factual accuracy. Ignore differences in punctuation and phrasing between the student answer and true answer. It is OK if the student answer contains more information than the true answer, as long as it does not contain any conflicting statements. If the student answers that there is no specific information provided in the context, then the answer is Incorrect. Begin!
QUESTION: {query}
STUDENT ANSWER: {result}
TRUE ANSWER: {answer}
GRADE:"""
promptStyleFast = PromptTemplate(input_variables=["query", "result", "answer"], template=template)
template = """You are a teacher grading a quiz.
You are given a question, the student's answer, and the true answer, and are asked to score the student answer as either Correct or Incorrect.
You are also asked to identify potential sources of bias in the question and in the true answer.
Example Format:
QUESTION: question here
STUDENT ANSWER: student's answer here
TRUE ANSWER: true answer here
GRADE: Correct or Incorrect here
Grade the student answers based ONLY on their factual accuracy. Ignore differences in punctuation and phrasing between the student answer and true answer. It is OK if the student answer contains more information than the true answer, as long as it does not contain any conflicting statements. If the student answers that there is no specific information provided in the context, then the answer is Incorrect. Begin!
QUESTION: {query}
STUDENT ANSWER: {result}
TRUE ANSWER: {answer}
GRADE:
Your response should be as follows:
GRADE: (Correct or Incorrect)
(line break)
JUSTIFICATION: (Without mentioning the student/teacher framing of this prompt, explain why the STUDENT ANSWER is Correct or Incorrect, identify potential sources of bias in the QUESTION, and identify potential sources of bias in the TRUE ANSWER. Use one or two sentences maximum. Keep the answer as concise as possible.)
"""
promptStyleBias = PromptTemplate(input_variables=["query", "result", "answer"], template=template)
template = """You are assessing a submitted student answer to a question relative to the true answer based on the provided criteria:
***
QUESTION: {query}
***
STUDENT ANSWER: {result}
***
TRUE ANSWER: {answer}
***
Criteria:
relevance: Is the submission referring to a real quote from the text?"
conciseness: Is the answer concise and to the point?"
correct: Is the answer correct?"
***
Does the submission meet the criterion? First, write out in a step by step manner your reasoning about the criterion to be sure that your conclusion is correct. Avoid simply stating the correct answers at the outset. Then print "Correct" or "Incorrect" (without quotes or punctuation) on its own line corresponding to the correct answer.
Reasoning:
"""
promptStyleGrading = PromptTemplate(input_variables=["query", "result", "answer"], template=template)
template = """You are a teacher grading a quiz.
You are given a question, the student's answer, and the true answer, and are asked to score the student answer as either Correct or Incorrect.
Example Format:
QUESTION: question here
STUDENT ANSWER: student's answer here
TRUE ANSWER: true answer here
GRADE: Correct or Incorrect here
Grade the student answers based ONLY on their factual accuracy. Ignore differences in punctuation and phrasing between the student answer and true answer. It is OK if the student answer contains more information than the true answer, as long as it does not contain any conflicting statements. If the student answers that there is no specific information provided in the context, then the answer is Incorrect. Begin!
QUESTION: {query}
STUDENT ANSWER: {result}
TRUE ANSWER: {answer}
GRADE:
Your response should be as follows:
GRADE: (Correct or Incorrect)
(line break)
JUSTIFICATION: (Without mentioning the student/teacher framing of this prompt, explain why the STUDENT ANSWER is Correct or Incorrect. Use one or two sentences maximum. Keep the answer as concise as possible.)
"""
promptStyleDefault = PromptTemplate(input_variables=["query", "result", "answer"], template=template)
template = """
Given the question: \n
{query}
Here are some documents retrieved in response to the question: \n
{result}
And here is the answer to the question: \n
{answer}
Criteria:
relevance: Are the retrieved documents relevant to the question and do they support the answer?"
Do the retrieved documents meet the criterion? Print "Correct" (without quotes or punctuation) if the retrieved context are relevant or "Incorrect" if not (without quotes or punctuation) on its own line. """
gradeDocsPromptFast = PromptTemplate(input_variables=["query", "result", "answer"], template=template)
template = """
Given the question: \n
{query}
Here are some documents retrieved in response to the question: \n
{result}
And here is the answer to the question: \n
{answer}
Criteria:
relevance: Are the retrieved documents relevant to the question and do they support the answer?"
Your response should be as follows:
GRADE: (Correct or Incorrect, depending if the retrieved documents meet the criterion)
(line break)
JUSTIFICATION: (Write out in a step by step manner your reasoning about the criterion to be sure that your conclusion is correct. Use one or two sentences maximum. Keep the answer as concise as possible.)
"""
gradeDocsPromptDefault = PromptTemplate(input_variables=["query", "result", "answer"], template=template)
return QaChainPrompt, promptStyleFast, promptStyleBias, promptStyleGrading, promptStyleDefault, gradeDocsPromptFast, gradeDocsPromptDefault
def gradeModelAnswer(llm, predictedDataSet, predictions, promptStyle, promptStyleFast, promptStyleBias, promptStyleGrading, promptStyleDefault):
if promptStyle == "Fast":
prompt = promptStyleFast
elif promptStyle == "Descriptive w/ bias check":
prompt = promptStyleBias
elif promptStyle == "OpenAI grading prompt":
prompt = promptStyleGrading
else:
prompt = promptStyleDefault
# Note: GPT-4 grader is advised by OAI
evalChain = QAEvalChain.from_llm(llm=llm,
prompt=prompt)
gradedOutputs = evalChain.evaluate(predictedDataSet,
predictions,
question_key="question",
prediction_key="result")
return gradedOutputs
def gradeModelRetrieval(llm, getDataSet, predictions, gradeDocsPrompt, gradeDocsPromptFast, gradeDocsPromptDefault):
if gradeDocsPrompt == "Fast":
prompt = gradeDocsPromptFast
else:
prompt = gradeDocsPromptDefault
# Note: GPT-4 grader is advised by OAI
evalChain = QAEvalChain.from_llm(llm=llm,prompt=prompt)
gradedOutputs = evalChain.evaluate(getDataSet,
predictions,
question_key="question",
prediction_key="result")
return gradedOutputs
def blobLoad(blobConnectionString, blobContainer, blobName):
readBytes = getBlob(blobConnectionString, blobContainer, blobName)
downloadPath = os.path.join(tempfile.gettempdir(), blobName)
os.makedirs(os.path.dirname(tempfile.gettempdir()), exist_ok=True)
try:
with open(downloadPath, "wb") as file:
file.write(readBytes)
except Exception as e:
logging.error(e)
logging.info("File created " + downloadPath)
if (blobName.endswith(".pdf")):
loader = PDFMinerLoader(downloadPath)
rawDocs = loader.load()
fullPath = getFullPath(blobConnectionString, blobContainer, blobName)
for doc in rawDocs:
doc.metadata['source'] = fullPath
return rawDocs
def runEvaluator(llm, evaluatorQaData, totalQuestions, chain, retriever, promptStyle,
promptStyleFast, promptStyleBias, promptStyleGrading, promptStyleDefault,
gradeDocsPromptFast, gradeDocsPromptDefault) -> list:
d = pd.DataFrame(columns=['question', 'answer', 'predictedAnswer', 'answerScore', 'retrievalScore', 'latency'])
for i in range(int(totalQuestions)):
predictions = []
retrievedDocs = []
gtDataSet = []
latency = []
currentDataSet = evaluatorQaData[i]
try:
startTime = time.time()
predictions.append(chain({"query": currentDataSet["question"]}, return_only_outputs=True))
gtDataSet.append(currentDataSet)
endTime = time.time()
elapsedTime = endTime - startTime
latency.append(elapsedTime)
except:
predictions.append({'result': 'Error in prediction'})
print("Error in prediction")
# Extract text from retrieved docs
retrievedDocText = ""
docs = retriever.get_relevant_documents(currentDataSet["question"])
for i, doc in enumerate(docs):
retrievedDocText += "Doc %s: " % str(i+1) + \
doc.page_content + " "
# Log
retrieved = {"question": currentDataSet["question"],
"answer": currentDataSet["answer"], "result": retrievedDocText}
retrievedDocs.append(retrieved)
# Grade
gradedAnswer = gradeModelAnswer(llm, gtDataSet, predictions, promptStyle, promptStyleFast, promptStyleBias, promptStyleGrading, promptStyleDefault)
gradedRetrieval = gradeModelRetrieval(llm, gtDataSet, retrievedDocs, promptStyle, gradeDocsPromptFast, gradeDocsPromptDefault)
# Assemble output
# Summary statistics
dfOutput = {'question': currentDataSet['question'], 'answer': currentDataSet['answer'],
'predictedAnswer': predictions[0]['result'], 'answerScore': [{'score': 1 if "Incorrect" not in text else 0,
'justification': text} for text in [g['text'] for g in gradedAnswer]],
'retrievalScore': [{'score': 1 if "Incorrect" not in text else 0,
'justification': text} for text in [g['text'] for g in gradedRetrieval]],
'latency': latency}
#yield dfOutput
# Add to dataframe
d = pd.concat([d, pd.DataFrame(dfOutput)], axis=0)
d_dict = d.to_dict('records')
return d_dict
def main(runDocs: RunDocs) -> str:
evaluatorQaData,totalQuestions,promptStyle,documentId,splitMethods,chunkSizes,overlaps,retrieverType,reEvaluate,topK,model,fileName, embeddingModelType, temperature, tokenLength = runDocs
evaluatorDataIndexName = "evaluatordata"
evaluatorRunIndexName = "evaluatorrun"
evaluatorRunResultIndexName = "evaluatorrunresult"
qaChainPrompt, promptStyleFast, promptStyleBias, promptStyleGrading, promptStyleDefault, gradeDocsPromptFast, gradeDocsPromptDefault = getPrompts()
logging.info("Python HTTP trigger function processed a request.")
if (embeddingModelType == 'azureopenai'):
llm = AzureChatOpenAI(
azure_endpoint=OpenAiEndPoint,
api_version=OpenAiVersion,
azure_deployment=OpenAiChat,
temperature=temperature,
api_key=OpenAiKey,
max_tokens=tokenLength)
logging.info("LLM Setup done")
elif embeddingModelType == "openai":
llm = ChatOpenAI(temperature=temperature,
api_key=OpenAiApiKey,
model_name="gpt-3.5-turbo",
max_tokens=tokenLength)
# Select retriever
createEvaluatorResultIndex(SearchService, SearchKey, evaluatorRunResultIndexName)
# Check if we already have runId for this document
r = searchEvaluatorRunIdIndex(SearchService, SearchKey, evaluatorRunResultIndexName, documentId)
if r.get_count() == 0:
runId = str(uuid.uuid4())
else:
for run in r:
runId = run['runId']
break
for splitMethod in splitMethods:
for chunkSize in chunkSizes:
for overlap in overlaps:
# Verify if we have created the Run ID
r = searchEvaluatorRunIndex(SearchService, SearchKey, evaluatorRunResultIndexName, documentId, retrieverType,
promptStyle, splitMethod, chunkSize, overlap)
if r.get_count() == 0 or reEvaluate:
# Create the Run ID
print("Processing: ", documentId, retrieverType, promptStyle, splitMethod, chunkSize, overlap)
runIdData = []
subRunId = str(uuid.uuid4())
retriever = CognitiveSearchVsRetriever(contentKey="contentVector",
serviceName=SearchService,
apiKey=SearchKey,
indexName=evaluatorDataIndexName,
topK=topK,
splitMethod = splitMethod,
model = model,
chunkSize = chunkSize,
overlap = overlap,
openAiEndPoint = OpenAiEndPoint,
openAiKey = OpenAiKey,
openAiVersion = OpenAiVersion,
openAiApiKey = OpenAiApiKey,
documentId = documentId,
openAiEmbedding=OpenAiEmbedding,
returnFields=["id", "content", "sourceFile", "splitMethod", "chunkSize", "overlap", "model", "modelType", "documentId"]
)
vectorStoreChain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever,
chain_type_kwargs={"prompt": qaChainPrompt})
runEvaluations = runEvaluator(llm, evaluatorQaData, totalQuestions, vectorStoreChain, retriever, promptStyle,
promptStyleFast, promptStyleBias, promptStyleGrading, promptStyleDefault,
gradeDocsPromptFast, gradeDocsPromptDefault)
#yield runEvaluations
runEvaluationData = []
for runEvaluation in runEvaluations:
runEvaluationData.append({
"id": str(uuid.uuid4()),
"runId": runId,
"subRunId": subRunId,
"documentId": documentId,
"retrieverType": retrieverType,
"promptStyle": promptStyle,
"splitMethod": splitMethod,
"chunkSize": chunkSize,
"overlap": overlap,
"question": runEvaluation['question'],
"answer": runEvaluation['answer'],
"predictedAnswer": runEvaluation['predictedAnswer'],
"answerScore": json.dumps(runEvaluation['answerScore']),
"retrievalScore": json.dumps(runEvaluation['retrievalScore']),
"latency": str(runEvaluation['latency']),
})
indexDocs(SearchService, SearchKey, evaluatorRunResultIndexName, runEvaluationData)
return "Success" | [
"langchain.evaluation.qa.QAEvalChain.from_llm",
"langchain.chains.RetrievalQA.from_chain_type",
"langchain.chat_models.ChatOpenAI",
"langchain.document_loaders.PDFMinerLoader",
"langchain.chat_models.AzureChatOpenAI",
"langchain.PromptTemplate"
] | [((911, 1164), 'collections.namedtuple', 'namedtuple', (['"""RunDoc"""', "['evalatorQaData', 'totalQuestions', 'promptStyle', 'documentId',\n 'splitMethods', 'chunkSizes', 'overlaps', 'retrieverType', 'reEvaluate',\n 'topK', 'model', 'fileName', 'embeddingModelType', 'temperature',\n 'tokenLength']"], {}), "('RunDoc', ['evalatorQaData', 'totalQuestions', 'promptStyle',\n 'documentId', 'splitMethods', 'chunkSizes', 'overlaps', 'retrieverType',\n 'reEvaluate', 'topK', 'model', 'fileName', 'embeddingModelType',\n 'temperature', 'tokenLength'])\n", (921, 1164), False, 'from collections import namedtuple\n'), ((1626, 1700), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['context', 'question']", 'template': 'template'}), "(input_variables=['context', 'question'], template=template)\n", (1640, 1700), False, 'from langchain import PromptTemplate\n'), ((2601, 2686), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['query', 'result', 'answer']", 'template': 'template'}), "(input_variables=['query', 'result', 'answer'], template=template\n )\n", (2615, 2686), False, 'from langchain import PromptTemplate\n'), ((4106, 4191), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['query', 'result', 'answer']", 'template': 'template'}), "(input_variables=['query', 'result', 'answer'], template=template\n )\n", (4120, 4191), False, 'from langchain import PromptTemplate\n'), ((5082, 5167), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['query', 'result', 'answer']", 'template': 'template'}), "(input_variables=['query', 'result', 'answer'], template=template\n )\n", (5096, 5167), False, 'from langchain import PromptTemplate\n'), ((6378, 6463), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['query', 'result', 'answer']", 'template': 'template'}), "(input_variables=['query', 'result', 'answer'], template=template\n )\n", (6392, 6463), False, 'from langchain import PromptTemplate\n'), ((7054, 7139), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['query', 'result', 'answer']", 'template': 'template'}), "(input_variables=['query', 'result', 'answer'], template=template\n )\n", (7068, 7139), False, 'from langchain import PromptTemplate\n'), ((7904, 7989), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['query', 'result', 'answer']", 'template': 'template'}), "(input_variables=['query', 'result', 'answer'], template=template\n )\n", (7918, 7989), False, 'from langchain import PromptTemplate\n'), ((8618, 8662), 'langchain.evaluation.qa.QAEvalChain.from_llm', 'QAEvalChain.from_llm', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (8638, 8662), False, 'from langchain.evaluation.qa import QAEvalChain\n'), ((9269, 9313), 'langchain.evaluation.qa.QAEvalChain.from_llm', 'QAEvalChain.from_llm', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (9289, 9313), False, 'from langchain.evaluation.qa import QAEvalChain\n'), ((9654, 9708), 'Utilities.azureBlob.getBlob', 'getBlob', (['blobConnectionString', 'blobContainer', 'blobName'], {}), '(blobConnectionString, blobContainer, blobName)\n', (9661, 9708), False, 'from Utilities.azureBlob import getBlob, getFullPath\n'), ((9992, 10036), 'logging.info', 'logging.info', (["('File created ' + downloadPath)"], {}), "('File created ' + downloadPath)\n", (10004, 10036), False, 'import logging, json, os\n'), ((10164, 10222), 'Utilities.azureBlob.getFullPath', 'getFullPath', (['blobConnectionString', 'blobContainer', 'blobName'], {}), '(blobConnectionString, blobContainer, blobName)\n', (10175, 10222), False, 'from Utilities.azureBlob import getBlob, getFullPath\n'), ((10566, 10677), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['question', 'answer', 'predictedAnswer', 'answerScore', 'retrievalScore',\n 'latency']"}), "(columns=['question', 'answer', 'predictedAnswer',\n 'answerScore', 'retrievalScore', 'latency'])\n", (10578, 10677), True, 'import pandas as pd\n'), ((13425, 13490), 'logging.info', 'logging.info', (['"""Python HTTP trigger function processed a request."""'], {}), "('Python HTTP trigger function processed a request.')\n", (13437, 13490), False, 'import logging, json, os\n'), ((14167, 14252), 'Utilities.evaluator.createEvaluatorResultIndex', 'createEvaluatorResultIndex', (['SearchService', 'SearchKey', 'evaluatorRunResultIndexName'], {}), '(SearchService, SearchKey,\n evaluatorRunResultIndexName)\n', (14193, 14252), False, 'from Utilities.evaluator import createEvaluatorResultIndex, searchEvaluatorRunIdIndex\n'), ((14312, 14408), 'Utilities.evaluator.searchEvaluatorRunIdIndex', 'searchEvaluatorRunIdIndex', (['SearchService', 'SearchKey', 'evaluatorRunResultIndexName', 'documentId'], {}), '(SearchService, SearchKey,\n evaluatorRunResultIndexName, documentId)\n', (14337, 14408), False, 'from Utilities.evaluator import createEvaluatorResultIndex, searchEvaluatorRunIdIndex\n'), ((9741, 9762), 'tempfile.gettempdir', 'tempfile.gettempdir', ([], {}), '()\n', (9760, 9762), False, 'import tempfile\n'), ((10090, 10118), 'langchain.document_loaders.PDFMinerLoader', 'PDFMinerLoader', (['downloadPath'], {}), '(downloadPath)\n', (10104, 10118), False, 'from langchain.document_loaders import PDFMinerLoader, UnstructuredFileLoader\n'), ((13563, 13741), 'langchain.chat_models.AzureChatOpenAI', 'AzureChatOpenAI', ([], {'azure_endpoint': 'OpenAiEndPoint', 'api_version': 'OpenAiVersion', 'azure_deployment': 'OpenAiChat', 'temperature': 'temperature', 'api_key': 'OpenAiKey', 'max_tokens': 'tokenLength'}), '(azure_endpoint=OpenAiEndPoint, api_version=OpenAiVersion,\n azure_deployment=OpenAiChat, temperature=temperature, api_key=OpenAiKey,\n max_tokens=tokenLength)\n', (13578, 13741), False, 'from langchain.chat_models import AzureChatOpenAI, ChatOpenAI\n'), ((13891, 13921), 'logging.info', 'logging.info', (['"""LLM Setup done"""'], {}), "('LLM Setup done')\n", (13903, 13921), False, 'import logging, json, os\n'), ((9806, 9827), 'tempfile.gettempdir', 'tempfile.gettempdir', ([], {}), '()\n', (9825, 9827), False, 'import tempfile\n'), ((9970, 9986), 'logging.error', 'logging.error', (['e'], {}), '(e)\n', (9983, 9986), False, 'import logging, json, os\n'), ((10897, 10908), 'time.time', 'time.time', ([], {}), '()\n', (10906, 10908), False, 'import time\n'), ((11079, 11090), 'time.time', 'time.time', ([], {}), '()\n', (11088, 11090), False, 'import time\n'), ((13981, 14095), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': 'temperature', 'api_key': 'OpenAiApiKey', 'model_name': '"""gpt-3.5-turbo"""', 'max_tokens': 'tokenLength'}), "(temperature=temperature, api_key=OpenAiApiKey, model_name=\n 'gpt-3.5-turbo', max_tokens=tokenLength)\n", (13991, 14095), False, 'from langchain.chat_models import AzureChatOpenAI, ChatOpenAI\n'), ((14452, 14464), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (14462, 14464), False, 'import uuid\n'), ((12809, 12831), 'pandas.DataFrame', 'pd.DataFrame', (['dfOutput'], {}), '(dfOutput)\n', (12821, 12831), True, 'import pandas as pd\n'), ((14735, 14894), 'Utilities.evaluator.searchEvaluatorRunIndex', 'searchEvaluatorRunIndex', (['SearchService', 'SearchKey', 'evaluatorRunResultIndexName', 'documentId', 'retrieverType', 'promptStyle', 'splitMethod', 'chunkSize', 'overlap'], {}), '(SearchService, SearchKey,\n evaluatorRunResultIndexName, documentId, retrieverType, promptStyle,\n splitMethod, chunkSize, overlap)\n', (14758, 14894), False, 'from Utilities.evaluator import searchEvaluatorRunIndex, createEvaluatorRunIndex, getEvaluatorResult\n'), ((15269, 15805), 'Utilities.cogSearchVsRetriever.CognitiveSearchVsRetriever', 'CognitiveSearchVsRetriever', ([], {'contentKey': '"""contentVector"""', 'serviceName': 'SearchService', 'apiKey': 'SearchKey', 'indexName': 'evaluatorDataIndexName', 'topK': 'topK', 'splitMethod': 'splitMethod', 'model': 'model', 'chunkSize': 'chunkSize', 'overlap': 'overlap', 'openAiEndPoint': 'OpenAiEndPoint', 'openAiKey': 'OpenAiKey', 'openAiVersion': 'OpenAiVersion', 'openAiApiKey': 'OpenAiApiKey', 'documentId': 'documentId', 'openAiEmbedding': 'OpenAiEmbedding', 'returnFields': "['id', 'content', 'sourceFile', 'splitMethod', 'chunkSize', 'overlap',\n 'model', 'modelType', 'documentId']"}), "(contentKey='contentVector', serviceName=\n SearchService, apiKey=SearchKey, indexName=evaluatorDataIndexName, topK\n =topK, splitMethod=splitMethod, model=model, chunkSize=chunkSize,\n overlap=overlap, openAiEndPoint=OpenAiEndPoint, openAiKey=OpenAiKey,\n openAiVersion=OpenAiVersion, openAiApiKey=OpenAiApiKey, documentId=\n documentId, openAiEmbedding=OpenAiEmbedding, returnFields=['id',\n 'content', 'sourceFile', 'splitMethod', 'chunkSize', 'overlap', 'model',\n 'modelType', 'documentId'])\n", (15295, 15805), False, 'from Utilities.cogSearchVsRetriever import CognitiveSearchVsRetriever\n'), ((16345, 16472), 'langchain.chains.RetrievalQA.from_chain_type', 'RetrievalQA.from_chain_type', ([], {'llm': 'llm', 'chain_type': '"""stuff"""', 'retriever': 'retriever', 'chain_type_kwargs': "{'prompt': qaChainPrompt}"}), "(llm=llm, chain_type='stuff', retriever=\n retriever, chain_type_kwargs={'prompt': qaChainPrompt})\n", (16372, 16472), False, 'from langchain.chains import RetrievalQA\n'), ((18132, 18219), 'Utilities.evaluator.indexDocs', 'indexDocs', (['SearchService', 'SearchKey', 'evaluatorRunResultIndexName', 'runEvaluationData'], {}), '(SearchService, SearchKey, evaluatorRunResultIndexName,\n runEvaluationData)\n', (18141, 18219), False, 'from Utilities.evaluator import indexDocs\n'), ((15206, 15218), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (15216, 15218), False, 'import uuid\n'), ((17870, 17910), 'json.dumps', 'json.dumps', (["runEvaluation['answerScore']"], {}), "(runEvaluation['answerScore'])\n", (17880, 17910), False, 'import json\n'), ((17962, 18005), 'json.dumps', 'json.dumps', (["runEvaluation['retrievalScore']"], {}), "(runEvaluation['retrievalScore'])\n", (17972, 18005), False, 'import json\n'), ((17133, 17145), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (17143, 17145), False, 'import uuid\n')] |
import dataclasses
import typing
from dataclasses import dataclass
from typing import Tuple, cast
from langchain.chat_models.base import BaseChatModel
from langchain.output_parsers import PydanticOutputParser
from langchain.schema import BaseMessage, HumanMessage
from pydantic import BaseModel, create_model
T = typing.TypeVar("T")
B = typing.TypeVar("B", bound=BaseModel)
@dataclass
class ChatChain:
chat_model: BaseChatModel
messages: list[BaseMessage]
@property
def response(self) -> str:
assert len(self.messages) >= 1
return cast(str, self.messages[-1].content)
def append(self, messages: list[BaseMessage]) -> "ChatChain":
return dataclasses.replace(self, messages=self.messages + messages)
def __add__(self, other: list[BaseMessage]) -> "ChatChain":
return self.append(other)
def query(self, question: str, model_args: dict | None = None) -> Tuple[str, "ChatChain"]:
"""Asks a question and returns the result in a single block."""
# Build messages:
messages = self.messages + [HumanMessage(content=question)]
model_args = model_args or {}
reply = self.chat_model.invoke(messages, **model_args)
messages.append(reply)
return cast(str, reply.content), dataclasses.replace(self, messages=messages)
def enforce_json_response(self, model_args: dict | None = None) -> dict:
model_args = model_args or {}
# Check if the language model is of type "openai" and extend model args with a response format in that case
model_dict = self.chat_model.dict()
if "openai" in model_dict["_type"] and model_dict.get("model_name") in (
"gpt-4-1106-preview",
"gpt-3.5-turbo-1106",
):
model_args = {**model_args, "response_format": dict(type="json_object")}
return model_args
def structured_query(
self, question: str, return_type: type[B], model_args: dict | None = None
) -> Tuple[B, "ChatChain"]:
"""Asks a question and returns the result in a single block."""
# Build messages:
if typing.get_origin(return_type) is typing.Annotated:
return_info = typing.get_args(return_type)
else:
return_info = (return_type, ...)
output_model = create_model("StructuredOutput", result=return_info)
parser: PydanticOutputParser = PydanticOutputParser(pydantic_object=output_model)
question_and_formatting = question + "\n\n" + parser.get_format_instructions()
reply_content, chain = self.query(question_and_formatting, self.enforce_json_response(model_args))
parsed_reply: B = typing.cast(B, parser.parse(reply_content))
return parsed_reply, chain
def branch(self) -> "ChatChain":
return dataclasses.replace(self, messages=self.messages.copy())
| [
"langchain.output_parsers.PydanticOutputParser",
"langchain.schema.HumanMessage"
] | [((315, 334), 'typing.TypeVar', 'typing.TypeVar', (['"""T"""'], {}), "('T')\n", (329, 334), False, 'import typing\n'), ((339, 375), 'typing.TypeVar', 'typing.TypeVar', (['"""B"""'], {'bound': 'BaseModel'}), "('B', bound=BaseModel)\n", (353, 375), False, 'import typing\n'), ((568, 604), 'typing.cast', 'cast', (['str', 'self.messages[-1].content'], {}), '(str, self.messages[-1].content)\n', (572, 604), False, 'from typing import Tuple, cast\n'), ((687, 747), 'dataclasses.replace', 'dataclasses.replace', (['self'], {'messages': '(self.messages + messages)'}), '(self, messages=self.messages + messages)\n', (706, 747), False, 'import dataclasses\n'), ((2315, 2367), 'pydantic.create_model', 'create_model', (['"""StructuredOutput"""'], {'result': 'return_info'}), "('StructuredOutput', result=return_info)\n", (2327, 2367), False, 'from pydantic import BaseModel, create_model\n'), ((2407, 2457), 'langchain.output_parsers.PydanticOutputParser', 'PydanticOutputParser', ([], {'pydantic_object': 'output_model'}), '(pydantic_object=output_model)\n', (2427, 2457), False, 'from langchain.output_parsers import PydanticOutputParser\n'), ((1256, 1280), 'typing.cast', 'cast', (['str', 'reply.content'], {}), '(str, reply.content)\n', (1260, 1280), False, 'from typing import Tuple, cast\n'), ((1282, 1326), 'dataclasses.replace', 'dataclasses.replace', (['self'], {'messages': 'messages'}), '(self, messages=messages)\n', (1301, 1326), False, 'import dataclasses\n'), ((2125, 2155), 'typing.get_origin', 'typing.get_origin', (['return_type'], {}), '(return_type)\n', (2142, 2155), False, 'import typing\n'), ((2203, 2231), 'typing.get_args', 'typing.get_args', (['return_type'], {}), '(return_type)\n', (2218, 2231), False, 'import typing\n'), ((1077, 1107), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'question'}), '(content=question)\n', (1089, 1107), False, 'from langchain.schema import BaseMessage, HumanMessage\n')] |
from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.chat_models import ChatOpenAI
from virl.config import cfg
from virl.utils.common_utils import print_prompt, print_answer, parse_answer_to_json
from .gpt_chat import GPTChat
from .azure_gpt import AzureGPTChat
__all__ = {
'GPT': GPTChat,
'AzureGPT': AzureGPTChat,
}
def build_chatbot(name):
return __all__[name](cfg)
class UnifiedChat(object):
chatbots = None
def __init__(self):
UnifiedChat.chatbots = {
name: build_chatbot(name) for name in cfg.LLM.NAMES
}
@classmethod
def ask(cls, question, **kwargs):
print_prompt(question)
chatbot = kwargs.get('chatbot', cfg.LLM.DEFAULT)
answer = cls.chatbots[chatbot].ask(question, **kwargs)
print_answer(answer)
return answer
@classmethod
def search(cls, question, json=False):
llm = ChatOpenAI(model='gpt-3.5-turbo', temperature=0)
tools = load_tools(["serpapi"], llm=llm)
agent = initialize_agent(tools, llm, verbose=True)
answer = agent.run(question)
if json:
answer = parse_answer_to_json(answer)
return answer
| [
"langchain.agents.initialize_agent",
"langchain.agents.load_tools",
"langchain.chat_models.ChatOpenAI"
] | [((679, 701), 'virl.utils.common_utils.print_prompt', 'print_prompt', (['question'], {}), '(question)\n', (691, 701), False, 'from virl.utils.common_utils import print_prompt, print_answer, parse_answer_to_json\n'), ((830, 850), 'virl.utils.common_utils.print_answer', 'print_answer', (['answer'], {}), '(answer)\n', (842, 850), False, 'from virl.utils.common_utils import print_prompt, print_answer, parse_answer_to_json\n'), ((949, 997), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model': '"""gpt-3.5-turbo"""', 'temperature': '(0)'}), "(model='gpt-3.5-turbo', temperature=0)\n", (959, 997), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1014, 1046), 'langchain.agents.load_tools', 'load_tools', (["['serpapi']"], {'llm': 'llm'}), "(['serpapi'], llm=llm)\n", (1024, 1046), False, 'from langchain.agents import load_tools\n'), ((1063, 1105), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'verbose': '(True)'}), '(tools, llm, verbose=True)\n', (1079, 1105), False, 'from langchain.agents import initialize_agent\n'), ((1182, 1210), 'virl.utils.common_utils.parse_answer_to_json', 'parse_answer_to_json', (['answer'], {}), '(answer)\n', (1202, 1210), False, 'from virl.utils.common_utils import print_prompt, print_answer, parse_answer_to_json\n')] |
from langchain_community.chat_models import ChatAnthropic
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
prompt = ChatPromptTemplate.from_template("Tell me a short joke about {topic}")
output_parser = StrOutputParser()
anthropic = ChatAnthropic(model="claude-2")
anthropic_chain = {"topic": RunnablePassthrough()} | prompt | anthropic | output_parser
if __name__ == "__main__":
import os
os.environ["LANGCHAIN_API_KEY"] = "..."
os.environ["LANGCHAIN_TRACING_V2"] = "true"
# it's hard to customize the logging output of langchain
# so here's their way to try to make money from you!
print(anthropic_chain.invoke("ice cream"))
| [
"langchain_core.prompts.ChatPromptTemplate.from_template",
"langchain_community.chat_models.ChatAnthropic",
"langchain_core.runnables.RunnablePassthrough",
"langchain_core.output_parsers.StrOutputParser"
] | [((237, 307), 'langchain_core.prompts.ChatPromptTemplate.from_template', 'ChatPromptTemplate.from_template', (['"""Tell me a short joke about {topic}"""'], {}), "('Tell me a short joke about {topic}')\n", (269, 307), False, 'from langchain_core.prompts import ChatPromptTemplate\n'), ((324, 341), 'langchain_core.output_parsers.StrOutputParser', 'StrOutputParser', ([], {}), '()\n', (339, 341), False, 'from langchain_core.output_parsers import StrOutputParser\n'), ((354, 385), 'langchain_community.chat_models.ChatAnthropic', 'ChatAnthropic', ([], {'model': '"""claude-2"""'}), "(model='claude-2')\n", (367, 385), False, 'from langchain_community.chat_models import ChatAnthropic\n'), ((414, 435), 'langchain_core.runnables.RunnablePassthrough', 'RunnablePassthrough', ([], {}), '()\n', (433, 435), False, 'from langchain_core.runnables import RunnablePassthrough\n')] |
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from tqdm import tqdm
from lmchain.tools import tool_register
class GLMToolChain:
def __init__(self, llm):
self.llm = llm
self.tool_register = tool_register
self.tools = tool_register.get_tools()
def __call__(self, query="", tools=None):
if query == "":
raise "query需要填入查询问题"
if tools != None:
self.tools = tools
else:
raise "将使用默认tools完成函数工具调用~"
template = f"""
你现在是一个专业的人工智能助手，你现在的需求是{query}。而你需要借助于工具在{self.tools}中找到对应的函数，用json格式返回对应的函数名和参数。
函数名定义为function_name,参数名为params,还要求写入详细的形参与实参。
如果找到合适的函数，就返回json格式的函数名和需要的参数，不要回答任何描述和解释。
如果没有找到合适的函数，则返回：'未找到合适参数，请提供更详细的描述。'
"""
flag = True
counter = 0
while flag:
try:
res = self.llm(template)
import json
res_dict = json.loads(res)
res_dict = json.loads(res_dict)
flag = False
except:
# print("失败输出，现在开始重新验证")
template = f"""
你现在是一个专业的人工智能助手，你现在的需求是{query}。而你需要借助于工具在{self.tools}中找到对应的函数，用json格式返回对应的函数名和参数。
函数名定义为function_name,参数名为params,还要求写入详细的形参与实参。
如果找到合适的函数，就返回json格式的函数名和需要的参数，不要回答任何描述和解释。
如果没有找到合适的函数，则返回：'未找到合适参数，请提供更详细的描述。'
你刚才生成了一组结果，但是返回不符合json格式，现在请你重新按json格式生成并返回结果。
"""
counter += 1
if counter >= 5:
return '未找到合适参数，请提供更详细的描述。'
return res_dict
def run(self, query, tools=None):
tools = (self.tool_register.get_tools())
result = self.__call__(query, tools)
if result == "未找到合适参数，请提供更详细的描述。":
return "未找到合适参数，请提供更详细的描述。"
else:
print("找到对应工具函数，格式如下：", result)
result = self.dispatch_tool(result)
from lmchain.prompts.templates import PromptTemplate
tool_prompt = PromptTemplate(
input_variables=["query", "result"], # 输入变量包括中文和英文。
template="你现在是一个私人助手，现在你的查询任务是{query},而你通过工具从网上查询的结果是{result},现在根据查询的内容与查询的结果，生成最终答案。",
# 使用模板格式化输入和输出。
)
from langchain.chains import LLMChain
chain = LLMChain(llm=self.llm, prompt=tool_prompt)
response = (chain.run({"query": query, "result": result}))
return response
def add_tools(self, tool):
self.tool_register.register_tool(tool)
return True
def dispatch_tool(self, tool_result) -> str:
tool_name = tool_result["function_name"]
tool_params = tool_result["params"]
if tool_name not in self.tool_register._TOOL_HOOKS:
return f"Tool `{tool_name}` not found. Please use a provided tool."
tool_call = self.tool_register._TOOL_HOOKS[tool_name]
try:
ret = tool_call(**tool_params)
except:
import traceback
ret = traceback.format_exc()
return str(ret)
def get_tools(self):
return (self.tool_register.get_tools())
if __name__ == '__main__':
from lmchain.agents import llmMultiAgent
llm = llmMultiAgent.AgentZhipuAI()
from lmchain.chains import toolchain
tool_chain = toolchain.GLMToolChain(llm)
from typing import Annotated
def rando_numbr(
seed: Annotated[int, 'The random seed used by the generator', True],
range: Annotated[tuple[int, int], 'The range of the generated numbers', True],
) -> int:
"""
Generates a random number x, s.t. range[0] <= x < range[1]
"""
import random
return random.Random(seed).randint(*range)
tool_chain.add_tools(rando_numbr)
print("------------------------------------------------------")
query = "今天shanghai的天气是什么？"
result = tool_chain.run(query)
result = tool_chain.dispatch_tool(result)
print(result)
| [
"langchain.chains.LLMChain"
] | [((3292, 3320), 'lmchain.agents.llmMultiAgent.AgentZhipuAI', 'llmMultiAgent.AgentZhipuAI', ([], {}), '()\n', (3318, 3320), False, 'from lmchain.agents import llmMultiAgent\n'), ((3381, 3408), 'lmchain.chains.toolchain.GLMToolChain', 'toolchain.GLMToolChain', (['llm'], {}), '(llm)\n', (3403, 3408), False, 'from lmchain.chains import toolchain\n'), ((285, 310), 'lmchain.tools.tool_register.get_tools', 'tool_register.get_tools', ([], {}), '()\n', (308, 310), False, 'from lmchain.tools import tool_register\n'), ((2073, 2222), 'lmchain.prompts.templates.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['query', 'result']", 'template': '"""你现在是一个私人助手，现在你的查询任务是{query},而你通过工具从网上查询的结果是{result},现在根据查询的内容与查询的结果，生成最终答案。"""'}), "(input_variables=['query', 'result'], template=\n '你现在是一个私人助手，现在你的查询任务是{query},而你通过工具从网上查询的结果是{result},现在根据查询的内容与查询的结果，生成最终答案。'\n )\n", (2087, 2222), False, 'from lmchain.prompts.templates import PromptTemplate\n'), ((2378, 2420), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'self.llm', 'prompt': 'tool_prompt'}), '(llm=self.llm, prompt=tool_prompt)\n', (2386, 2420), False, 'from langchain.chains import LLMChain\n'), ((981, 996), 'json.loads', 'json.loads', (['res'], {}), '(res)\n', (991, 996), False, 'import json\n'), ((1024, 1044), 'json.loads', 'json.loads', (['res_dict'], {}), '(res_dict)\n', (1034, 1044), False, 'import json\n'), ((3086, 3108), 'traceback.format_exc', 'traceback.format_exc', ([], {}), '()\n', (3106, 3108), False, 'import traceback\n'), ((3780, 3799), 'random.Random', 'random.Random', (['seed'], {}), '(seed)\n', (3793, 3799), False, 'import random\n')] |
import json
import time
import hashlib
from typing import Dict, Any, List, Tuple
import re
from os import environ
import streamlit as st
from langchain.schema import BaseRetriever
from langchain.tools import Tool
from langchain.pydantic_v1 import BaseModel, Field
from sqlalchemy import Column, Text, create_engine, MetaData
from langchain.agents import AgentExecutor
try:
from sqlalchemy.orm import declarative_base
except ImportError:
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from clickhouse_sqlalchemy import (
types, engines
)
from langchain_experimental.sql.vector_sql import VectorSQLDatabaseChain
from langchain_experimental.retrievers.vector_sql_database import VectorSQLDatabaseChainRetriever
from langchain.utilities.sql_database import SQLDatabase
from langchain.chains import LLMChain
from sqlalchemy import create_engine, MetaData
from langchain.prompts import PromptTemplate, ChatPromptTemplate, \
SystemMessagePromptTemplate, HumanMessagePromptTemplate
from langchain.prompts.prompt import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.schema import BaseRetriever, Document
from langchain import OpenAI
from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName
from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain.retrievers.self_query.myscale import MyScaleTranslator
from langchain.embeddings import HuggingFaceInstructEmbeddings, SentenceTransformerEmbeddings
from langchain.vectorstores import MyScaleSettings
from chains.arxiv_chains import MyScaleWithoutMetadataJson
from langchain.prompts.prompt import PromptTemplate
from langchain.prompts.chat import MessagesPlaceholder
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 BaseMessage, HumanMessage, AIMessage, FunctionMessage, \
SystemMessage, ChatMessage, ToolMessage
from langchain.memory import SQLChatMessageHistory
from langchain.memory.chat_message_histories.sql import \
DefaultMessageConverter
from langchain.schema.messages import BaseMessage
# from langchain.agents.agent_toolkits import create_retriever_tool
from prompts.arxiv_prompt import combine_prompt_template, _myscale_prompt
from chains.arxiv_chains import ArXivQAwithSourcesChain, ArXivStuffDocumentChain
from chains.arxiv_chains import VectorSQLRetrieveCustomOutputParser
from .json_conv import CustomJSONEncoder
environ['TOKENIZERS_PARALLELISM'] = 'true'
environ['OPENAI_API_BASE'] = st.secrets['OPENAI_API_BASE']
# query_model_name = "gpt-3.5-turbo-instruct"
query_model_name = "gpt-3.5-turbo-instruct"
chat_model_name = "gpt-3.5-turbo-16k"
OPENAI_API_KEY = st.secrets['OPENAI_API_KEY']
OPENAI_API_BASE = st.secrets['OPENAI_API_BASE']
MYSCALE_USER = st.secrets['MYSCALE_USER']
MYSCALE_PASSWORD = st.secrets['MYSCALE_PASSWORD']
MYSCALE_HOST = st.secrets['MYSCALE_HOST']
MYSCALE_PORT = st.secrets['MYSCALE_PORT']
UNSTRUCTURED_API = st.secrets['UNSTRUCTURED_API']
COMBINE_PROMPT = ChatPromptTemplate.from_strings(
string_messages=[(SystemMessagePromptTemplate, combine_prompt_template),
(HumanMessagePromptTemplate, '{question}')])
DEFAULT_SYSTEM_PROMPT = (
"Do your best to answer the questions. "
"Feel free to use any tools available to look up "
"relevant information. Please keep all details in query "
"when calling search functions."
)
def hint_arxiv():
st.info("We provides you metadata columns below for query. Please choose a natural expression to describe filters on those columns.\n\n"
"For example: \n\n"
"*If you want to search papers with complex filters*:\n\n"
"- What is a Bayesian network? Please use articles published later than Feb 2018 and with more than 2 categories and whose title like `computer` and must have `cs.CV` in its category.\n\n"
"*If you want to ask questions based on papers in database*:\n\n"
"- What is PageRank?\n"
"- Did Geoffrey Hinton wrote paper about Capsule Neural Networks?\n"
"- Introduce some applications of GANs published around 2019.\n"
"- 请根据 2019 年左右的文章介绍一下 GAN 的应用都有哪些\n"
"- Veuillez présenter les applications du GAN sur la base des articles autour de 2019 ?\n"
"- Is it possible to synthesize room temperature super conductive material?")
def hint_sql_arxiv():
st.info("You can retrieve papers with button `Query` or ask questions based on retrieved papers with button `Ask`.", icon='💡')
st.markdown('''```sql
CREATE TABLE default.ChatArXiv (
`abstract` String,
`id` String,
`vector` Array(Float32),
`metadata` Object('JSON'),
`pubdate` DateTime,
`title` String,
`categories` Array(String),
`authors` Array(String),
`comment` String,
`primary_category` String,
VECTOR INDEX vec_idx vector TYPE MSTG('fp16_storage=1', 'metric_type=Cosine', 'disk_mode=3'),
CONSTRAINT vec_len CHECK length(vector) = 768)
ENGINE = ReplacingMergeTree ORDER BY id
```''')
def hint_wiki():
st.info("We provides you metadata columns below for query. Please choose a natural expression to describe filters on those columns.\n\n"
"For example: \n\n"
"- Which company did Elon Musk found?\n"
"- What is Iron Gwazi?\n"
"- What is a Ring in mathematics?\n"
"- 苹果的发源地是那里？\n")
def hint_sql_wiki():
st.info("You can retrieve papers with button `Query` or ask questions based on retrieved papers with button `Ask`.", icon='💡')
st.markdown('''```sql
CREATE TABLE wiki.Wikipedia (
`id` String,
`title` String,
`text` String,
`url` String,
`wiki_id` UInt64,
`views` Float32,
`paragraph_id` UInt64,
`langs` UInt32,
`emb` Array(Float32),
VECTOR INDEX vec_idx emb TYPE MSTG('fp16_storage=1', 'metric_type=Cosine', 'disk_mode=3'),
CONSTRAINT emb_len CHECK length(emb) = 768)
ENGINE = ReplacingMergeTree ORDER BY id
```''')
sel_map = {
'Wikipedia': {
"database": "wiki",
"table": "Wikipedia",
"hint": hint_wiki,
"hint_sql": hint_sql_wiki,
"doc_prompt": PromptTemplate(
input_variables=["page_content",
"url", "title", "ref_id", "views"],
template="Title for Doc #{ref_id}: {title}\n\tviews: {views}\n\tcontent: {page_content}\nSOURCE: {url}"),
"metadata_cols": [
AttributeInfo(
name="title",
description="title of the wikipedia page",
type="string",
),
AttributeInfo(
name="text",
description="paragraph from this wiki page",
type="string",
),
AttributeInfo(
name="views",
description="number of views",
type="float"
),
],
"must_have_cols": ['id', 'title', 'url', 'text', 'views'],
"vector_col": "emb",
"text_col": "text",
"metadata_col": "metadata",
"emb_model": lambda: SentenceTransformerEmbeddings(
model_name='sentence-transformers/paraphrase-multilingual-mpnet-base-v2',),
"tool_desc": ("search_among_wikipedia", "Searches among Wikipedia and returns related wiki pages"),
},
'ArXiv Papers': {
"database": "default",
"table": "ChatArXiv",
"hint": hint_arxiv,
"hint_sql": hint_sql_arxiv,
"doc_prompt": PromptTemplate(
input_variables=["page_content", "id", "title", "ref_id",
"authors", "pubdate", "categories"],
template="Title for Doc #{ref_id}: {title}\n\tAbstract: {page_content}\n\tAuthors: {authors}\n\tDate of Publication: {pubdate}\n\tCategories: {categories}\nSOURCE: {id}"),
"metadata_cols": [
AttributeInfo(
name=VirtualColumnName(name="pubdate"),
description="The year the paper is published",
type="timestamp",
),
AttributeInfo(
name="authors",
description="List of author names",
type="list[string]",
),
AttributeInfo(
name="title",
description="Title of the paper",
type="string",
),
AttributeInfo(
name="categories",
description="arxiv categories to this paper",
type="list[string]"
),
AttributeInfo(
name="length(categories)",
description="length of arxiv categories to this paper",
type="int"
),
],
"must_have_cols": ['title', 'id', 'categories', 'abstract', 'authors', 'pubdate'],
"vector_col": "vector",
"text_col": "abstract",
"metadata_col": "metadata",
"emb_model": lambda: HuggingFaceInstructEmbeddings(
model_name='hkunlp/instructor-xl',
embed_instruction="Represent the question for retrieving supporting scientific papers: "),
"tool_desc": ("search_among_scientific_papers", "Searches among scientific papers from ArXiv and returns research papers"),
}
}
def build_embedding_model(_sel):
"""Build embedding model
"""
with st.spinner("Loading Model..."):
embeddings = sel_map[_sel]["emb_model"]()
return embeddings
def build_chains_retrievers(_sel: str) -> Dict[str, Any]:
"""build chains and retrievers
:param _sel: selected knowledge base
:type _sel: str
:return: _description_
:rtype: Dict[str, Any]
"""
metadata_field_info = sel_map[_sel]["metadata_cols"]
retriever = build_self_query(_sel)
chain = build_qa_chain(_sel, retriever, name="Self Query Retriever")
sql_retriever = build_vector_sql(_sel)
sql_chain = build_qa_chain(_sel, sql_retriever, name="Vector SQL")
return {
"metadata_columns": [{'name': m.name.name if type(m.name) is VirtualColumnName else m.name, 'desc': m.description, 'type': m.type} for m in metadata_field_info],
"retriever": retriever,
"chain": chain,
"sql_retriever": sql_retriever,
"sql_chain": sql_chain
}
def build_self_query(_sel: str) -> SelfQueryRetriever:
"""Build self querying retriever
:param _sel: selected knowledge base
:type _sel: str
:return: retriever used by chains
:rtype: SelfQueryRetriever
"""
with st.spinner(f"Connecting DB for {_sel}..."):
myscale_connection = {
"host": MYSCALE_HOST,
"port": MYSCALE_PORT,
"username": MYSCALE_USER,
"password": MYSCALE_PASSWORD,
}
config = MyScaleSettings(**myscale_connection,
database=sel_map[_sel]["database"],
table=sel_map[_sel]["table"],
column_map={
"id": "id",
"text": sel_map[_sel]["text_col"],
"vector": sel_map[_sel]["vector_col"],
"metadata": sel_map[_sel]["metadata_col"]
})
doc_search = MyScaleWithoutMetadataJson(st.session_state[f"emb_model_{_sel}"], config,
must_have_cols=sel_map[_sel]['must_have_cols'])
with st.spinner(f"Building Self Query Retriever for {_sel}..."):
metadata_field_info = sel_map[_sel]["metadata_cols"]
retriever = SelfQueryRetriever.from_llm(
OpenAI(model_name=query_model_name,
openai_api_key=OPENAI_API_KEY, temperature=0),
doc_search, "Scientific papers indexes with abstracts. All in English.", metadata_field_info,
use_original_query=False, structured_query_translator=MyScaleTranslator())
return retriever
def build_vector_sql(_sel: str) -> VectorSQLDatabaseChainRetriever:
"""Build Vector SQL Database Retriever
:param _sel: selected knowledge base
:type _sel: str
:return: retriever used by chains
:rtype: VectorSQLDatabaseChainRetriever
"""
with st.spinner(f'Building Vector SQL Database Retriever for {_sel}...'):
engine = create_engine(
f'clickhouse://{MYSCALE_USER}:{MYSCALE_PASSWORD}@{MYSCALE_HOST}:{MYSCALE_PORT}/{sel_map[_sel]["database"]}?protocol=https')
metadata = MetaData(bind=engine)
PROMPT = PromptTemplate(
input_variables=["input", "table_info", "top_k"],
template=_myscale_prompt,
)
output_parser = VectorSQLRetrieveCustomOutputParser.from_embeddings(
model=st.session_state[f'emb_model_{_sel}'], must_have_columns=sel_map[_sel]["must_have_cols"])
sql_query_chain = VectorSQLDatabaseChain.from_llm(
llm=OpenAI(model_name=query_model_name,
openai_api_key=OPENAI_API_KEY, temperature=0),
prompt=PROMPT,
top_k=10,
return_direct=True,
db=SQLDatabase(engine, None, metadata, max_string_length=1024),
sql_cmd_parser=output_parser,
native_format=True
)
sql_retriever = VectorSQLDatabaseChainRetriever(
sql_db_chain=sql_query_chain, page_content_key=sel_map[_sel]["text_col"])
return sql_retriever
def build_qa_chain(_sel: str, retriever: BaseRetriever, name: str = "Self-query") -> ArXivQAwithSourcesChain:
"""_summary_
:param _sel: selected knowledge base
:type _sel: str
:param retriever: retriever used by chains
:type retriever: BaseRetriever
:param name: display name, defaults to "Self-query"
:type name: str, optional
:return: QA chain interacts with user
:rtype: ArXivQAwithSourcesChain
"""
with st.spinner(f'Building QA Chain with {name} for {_sel}...'):
chain = ArXivQAwithSourcesChain(
retriever=retriever,
combine_documents_chain=ArXivStuffDocumentChain(
llm_chain=LLMChain(
prompt=COMBINE_PROMPT,
llm=ChatOpenAI(model_name=chat_model_name,
openai_api_key=OPENAI_API_KEY, temperature=0.6),
),
document_prompt=sel_map[_sel]["doc_prompt"],
document_variable_name="summaries",
),
return_source_documents=True,
max_tokens_limit=12000,
)
return chain
@st.cache_resource
def build_all() -> Tuple[Dict[str, Any], Dict[str, Any]]:
"""build all resources
:return: sel_map_obj
:rtype: Dict[str, Any]
"""
sel_map_obj = {}
embeddings = {}
for k in sel_map:
embeddings[k] = build_embedding_model(k)
st.session_state[f'emb_model_{k}'] = embeddings[k]
sel_map_obj[k] = build_chains_retrievers(k)
return sel_map_obj, embeddings
def create_message_model(table_name, DynamicBase): # type: ignore
"""
Create a message model for a given table name.
Args:
table_name: The name of the table to use.
DynamicBase: The base class to use for the model.
Returns:
The model class.
"""
# Model decleared inside a function to have a dynamic table name
class Message(DynamicBase):
__tablename__ = table_name
id = Column(types.Float64)
session_id = Column(Text)
user_id = Column(Text)
msg_id = Column(Text, primary_key=True)
type = Column(Text)
addtionals = Column(Text)
message = Column(Text)
__table_args__ = (
engines.ReplacingMergeTree(
partition_by='session_id',
order_by=('id', 'msg_id')),
{'comment': 'Store Chat History'}
)
return Message
def _message_from_dict(message: dict) -> BaseMessage:
_type = message["type"]
if _type == "human":
return HumanMessage(**message["data"])
elif _type == "ai":
return AIMessage(**message["data"])
elif _type == "system":
return SystemMessage(**message["data"])
elif _type == "chat":
return ChatMessage(**message["data"])
elif _type == "function":
return FunctionMessage(**message["data"])
elif _type == "tool":
return ToolMessage(**message["data"])
elif _type == "AIMessageChunk":
message["data"]["type"] = "ai"
return AIMessage(**message["data"])
else:
raise ValueError(f"Got unexpected message type: {_type}")
class DefaultClickhouseMessageConverter(DefaultMessageConverter):
"""The default message converter for SQLChatMessageHistory."""
def __init__(self, table_name: str):
self.model_class = create_message_model(table_name, declarative_base())
def to_sql_model(self, message: BaseMessage, session_id: str) -> Any:
tstamp = time.time()
msg_id = hashlib.sha256(
f"{session_id}_{message}_{tstamp}".encode('utf-8')).hexdigest()
user_id, _ = session_id.split("?")
return self.model_class(
id=tstamp,
msg_id=msg_id,
user_id=user_id,
session_id=session_id,
type=message.type,
addtionals=json.dumps(message.additional_kwargs),
message=json.dumps({
"type": message.type,
"additional_kwargs": {"timestamp": tstamp},
"data": message.dict()})
)
def from_sql_model(self, sql_message: Any) -> BaseMessage:
msg_dump = json.loads(sql_message.message)
msg = _message_from_dict(msg_dump)
msg.additional_kwargs = msg_dump["additional_kwargs"]
return msg
def get_sql_model_class(self) -> Any:
return self.model_class
def create_agent_executor(name, session_id, llm, tools, system_prompt, **kwargs):
name = name.replace(" ", "_")
conn_str = f'clickhouse://{MYSCALE_USER}:{MYSCALE_PASSWORD}@{MYSCALE_HOST}:{MYSCALE_PORT}'
chat_memory = SQLChatMessageHistory(
session_id,
connection_string=f'{conn_str}/chat?protocol=https',
custom_message_converter=DefaultClickhouseMessageConverter(name))
memory = AgentTokenBufferMemory(llm=llm, chat_memory=chat_memory)
_system_message = SystemMessage(
content=system_prompt
)
prompt = OpenAIFunctionsAgent.create_prompt(
system_message=_system_message,
extra_prompt_messages=[MessagesPlaceholder(variable_name="history")],
)
agent = OpenAIFunctionsAgent(llm=llm, tools=tools, prompt=prompt)
return AgentExecutor(
agent=agent,
tools=tools,
memory=memory,
verbose=True,
return_intermediate_steps=True,
**kwargs
)
class RetrieverInput(BaseModel):
query: str = Field(description="query to look up in retriever")
def create_retriever_tool(
retriever: BaseRetriever, name: str, description: str
) -> Tool:
"""Create a tool to do retrieval of documents.
Args:
retriever: The retriever to use for the retrieval
name: The name for the tool. This will be passed to the language model,
so should be unique and somewhat descriptive.
description: The description for the tool. This will be passed to the language
model, so should be descriptive.
Returns:
Tool class to pass to an agent
"""
def wrap(func):
def wrapped_retrieve(*args, **kwargs):
docs: List[Document] = func(*args, **kwargs)
return json.dumps([d.dict() for d in docs], cls=CustomJSONEncoder)
return wrapped_retrieve
return Tool(
name=name,
description=description,
func=wrap(retriever.get_relevant_documents),
coroutine=retriever.aget_relevant_documents,
args_schema=RetrieverInput,
)
@st.cache_resource
def build_tools():
"""build all resources
:return: sel_map_obj
:rtype: Dict[str, Any]
"""
sel_map_obj = {}
for k in sel_map:
if f'emb_model_{k}' not in st.session_state:
st.session_state[f'emb_model_{k}'] = build_embedding_model(k)
if "sel_map_obj" not in st.session_state:
st.session_state["sel_map_obj"] = {}
if k not in st.session_state.sel_map_obj:
st.session_state["sel_map_obj"][k] = {}
if "langchain_retriever" not in st.session_state.sel_map_obj[k] or "vecsql_retriever" not in st.session_state.sel_map_obj[k]:
st.session_state.sel_map_obj[k].update(build_chains_retrievers(k))
sel_map_obj.update({
f"{k} + Self Querying": create_retriever_tool(st.session_state.sel_map_obj[k]["retriever"], *sel_map[k]["tool_desc"],),
f"{k} + Vector SQL": create_retriever_tool(st.session_state.sel_map_obj[k]["sql_retriever"], *sel_map[k]["tool_desc"],),
})
return sel_map_obj
def build_agents(session_id, tool_names, chat_model_name=chat_model_name, temperature=0.6, system_prompt=DEFAULT_SYSTEM_PROMPT):
chat_llm = ChatOpenAI(model_name=chat_model_name, temperature=temperature,
openai_api_base=OPENAI_API_BASE, openai_api_key=OPENAI_API_KEY, streaming=True,
)
tools = st.session_state.tools if "tools_with_users" not in st.session_state else st.session_state.tools_with_users
sel_tools = [tools[k] for k in tool_names]
agent = create_agent_executor(
"chat_memory",
session_id,
chat_llm,
tools=sel_tools,
system_prompt=system_prompt
)
return agent
def display(dataframe, columns_=None, index=None):
if len(dataframe) > 0:
if index:
dataframe.set_index(index)
if columns_:
st.dataframe(dataframe[columns_])
else:
st.dataframe(dataframe)
else:
st.write("Sorry 😵 we didn't find any articles related to your query.\n\nMaybe the LLM is too naughty that does not follow our instruction... \n\nPlease try again and use verbs that may match the datatype.", unsafe_allow_html=True)
| [
"langchain.agents.openai_functions_agent.agent_token_buffer_memory.AgentTokenBufferMemory",
"langchain.pydantic_v1.Field",
"langchain_experimental.retrievers.vector_sql_database.VectorSQLDatabaseChainRetriever",
"langchain.utilities.sql_database.SQLDatabase",
"langchain.schema.messages.ToolMessage",
"langchain.OpenAI",
"langchain.prompts.ChatPromptTemplate.from_strings",
"langchain.agents.openai_functions_agent.base.OpenAIFunctionsAgent",
"langchain.chains.query_constructor.base.AttributeInfo",
"langchain.embeddings.HuggingFaceInstructEmbeddings",
"langchain.schema.messages.FunctionMessage",
"langchain.chat_models.ChatOpenAI",
"langchain.prompts.chat.MessagesPlaceholder",
"langchain.schema.messages.ChatMessage",
"langchain.prompts.prompt.PromptTemplate",
"langchain.agents.AgentExecutor",
"langchain.embeddings.SentenceTransformerEmbeddings",
"langchain.schema.messages.AIMessage",
"langchain.schema.messages.HumanMessage",
"langchain.chains.query_constructor.base.VirtualColumnName",
"langchain.schema.messages.SystemMessage",
"langchain.vectorstores.MyScaleSettings",
"langchain.retrievers.self_query.myscale.MyScaleTranslator"
] | [((3163, 3322), 'langchain.prompts.ChatPromptTemplate.from_strings', 'ChatPromptTemplate.from_strings', ([], {'string_messages': "[(SystemMessagePromptTemplate, combine_prompt_template), (\n HumanMessagePromptTemplate, '{question}')]"}), "(string_messages=[(\n SystemMessagePromptTemplate, combine_prompt_template), (\n HumanMessagePromptTemplate, '{question}')])\n", (3194, 3322), False, 'from langchain.prompts import PromptTemplate, ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((3590, 4394), 'streamlit.info', 'st.info', (['"""We provides you metadata columns below for query. Please choose a natural expression to describe filters on those columns.\n\nFor example: \n\n*If you want to search papers with complex filters*:\n\n- What is a Bayesian network? Please use articles published later than Feb 2018 and with more than 2 categories and whose title like `computer` and must have `cs.CV` in its category.\n\n*If you want to ask questions based on papers in database*:\n\n- What is PageRank?\n- Did Geoffrey Hinton wrote paper about Capsule Neural Networks?\n- Introduce some applications of GANs published around 2019.\n- 请根据 2019 年左右的文章介绍一下 GAN 的应用都有哪些\n- Veuillez présenter les applications du GAN sur la base des articles autour de 2019 ?\n- Is it possible to synthesize room temperature super conductive material?"""'], {}), '(\n """We provides you metadata columns below for query. Please choose a natural expression to describe filters on those columns.\n\nFor example: \n\n*If you want to search papers with complex filters*:\n\n- What is a Bayesian network? Please use articles published later than Feb 2018 and with more than 2 categories and whose title like `computer` and must have `cs.CV` in its category.\n\n*If you want to ask questions based on papers in database*:\n\n- What is PageRank?\n- Did Geoffrey Hinton wrote paper about Capsule Neural Networks?\n- Introduce some applications of GANs published around 2019.\n- 请根据 2019 年左右的文章介绍一下 GAN 的应用都有哪些\n- Veuillez présenter les applications du GAN sur la base des articles autour de 2019 ?\n- Is it possible to synthesize room temperature super conductive material?"""\n )\n', (3597, 4394), True, 'import streamlit as st\n'), ((4574, 4710), 'streamlit.info', 'st.info', (['"""You can retrieve papers with button `Query` or ask questions based on retrieved papers with button `Ask`."""'], {'icon': '"""💡"""'}), "(\n 'You can retrieve papers with button `Query` or ask questions based on retrieved papers with button `Ask`.'\n , icon='💡')\n", (4581, 4710), True, 'import streamlit as st\n'), ((4705, 5231), 'streamlit.markdown', 'st.markdown', (['"""```sql\nCREATE TABLE default.ChatArXiv (\n `abstract` String, \n `id` String, \n `vector` Array(Float32), \n `metadata` Object(\'JSON\'), \n `pubdate` DateTime,\n `title` String,\n `categories` Array(String),\n `authors` Array(String), \n `comment` String,\n `primary_category` String,\n VECTOR INDEX vec_idx vector TYPE MSTG(\'fp16_storage=1\', \'metric_type=Cosine\', \'disk_mode=3\'), \n CONSTRAINT vec_len CHECK length(vector) = 768) \nENGINE = ReplacingMergeTree ORDER BY id\n```"""'], {}), '(\n """```sql\nCREATE TABLE default.ChatArXiv (\n `abstract` String, \n `id` String, \n `vector` Array(Float32), \n `metadata` Object(\'JSON\'), \n `pubdate` DateTime,\n `title` String,\n `categories` Array(String),\n `authors` Array(String), \n `comment` String,\n `primary_category` String,\n VECTOR INDEX vec_idx vector TYPE MSTG(\'fp16_storage=1\', \'metric_type=Cosine\', \'disk_mode=3\'), \n CONSTRAINT vec_len CHECK length(vector) = 768) \nENGINE = ReplacingMergeTree ORDER BY id\n```"""\n )\n', (4716, 5231), True, 'import streamlit as st\n'), ((5245, 5514), 'streamlit.info', 'st.info', (['"""We provides you metadata columns below for query. Please choose a natural expression to describe filters on those columns.\n\nFor example: \n\n- Which company did Elon Musk found?\n- What is Iron Gwazi?\n- What is a Ring in mathematics?\n- 苹果的发源地是那里？\n"""'], {}), '(\n """We provides you metadata columns below for query. Please choose a natural expression to describe filters on those columns.\n\nFor example: \n\n- Which company did Elon Musk found?\n- What is Iron Gwazi?\n- What is a Ring in mathematics?\n- 苹果的发源地是那里？\n"""\n )\n', (5252, 5514), True, 'import streamlit as st\n'), ((5611, 5747), 'streamlit.info', 'st.info', (['"""You can retrieve papers with button `Query` or ask questions based on retrieved papers with button `Ask`."""'], {'icon': '"""💡"""'}), "(\n 'You can retrieve papers with button `Query` or ask questions based on retrieved papers with button `Ask`.'\n , icon='💡')\n", (5618, 5747), True, 'import streamlit as st\n'), ((5742, 6195), 'streamlit.markdown', 'st.markdown', (['"""```sql\nCREATE TABLE wiki.Wikipedia (\n `id` String, \n `title` String, \n `text` String, \n `url` String, \n `wiki_id` UInt64, \n `views` Float32, \n `paragraph_id` UInt64, \n `langs` UInt32, \n `emb` Array(Float32), \n VECTOR INDEX vec_idx emb TYPE MSTG(\'fp16_storage=1\', \'metric_type=Cosine\', \'disk_mode=3\'), \n CONSTRAINT emb_len CHECK length(emb) = 768) \nENGINE = ReplacingMergeTree ORDER BY id\n```"""'], {}), '(\n """```sql\nCREATE TABLE wiki.Wikipedia (\n `id` String, \n `title` String, \n `text` String, \n `url` String, \n `wiki_id` UInt64, \n `views` Float32, \n `paragraph_id` UInt64, \n `langs` UInt32, \n `emb` Array(Float32), \n VECTOR INDEX vec_idx emb TYPE MSTG(\'fp16_storage=1\', \'metric_type=Cosine\', \'disk_mode=3\'), \n CONSTRAINT emb_len CHECK length(emb) = 768) \nENGINE = ReplacingMergeTree ORDER BY id\n```"""\n )\n', (5753, 6195), True, 'import streamlit as st\n'), ((18531, 18587), 'langchain.agents.openai_functions_agent.agent_token_buffer_memory.AgentTokenBufferMemory', 'AgentTokenBufferMemory', ([], {'llm': 'llm', 'chat_memory': 'chat_memory'}), '(llm=llm, chat_memory=chat_memory)\n', (18553, 18587), False, 'from langchain.agents.openai_functions_agent.agent_token_buffer_memory import AgentTokenBufferMemory\n'), ((18611, 18647), 'langchain.schema.messages.SystemMessage', 'SystemMessage', ([], {'content': 'system_prompt'}), '(content=system_prompt)\n', (18624, 18647), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n'), ((18847, 18904), 'langchain.agents.openai_functions_agent.base.OpenAIFunctionsAgent', 'OpenAIFunctionsAgent', ([], {'llm': 'llm', 'tools': 'tools', 'prompt': 'prompt'}), '(llm=llm, tools=tools, prompt=prompt)\n', (18867, 18904), False, 'from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent\n'), ((18916, 19030), 'langchain.agents.AgentExecutor', 'AgentExecutor', ([], {'agent': 'agent', 'tools': 'tools', 'memory': 'memory', 'verbose': '(True)', 'return_intermediate_steps': '(True)'}), '(agent=agent, tools=tools, memory=memory, verbose=True,\n return_intermediate_steps=True, **kwargs)\n', (18929, 19030), False, 'from langchain.agents import AgentExecutor\n'), ((19133, 19183), 'langchain.pydantic_v1.Field', 'Field', ([], {'description': '"""query to look up in retriever"""'}), "(description='query to look up in retriever')\n", (19138, 19183), False, 'from langchain.pydantic_v1 import BaseModel, Field\n'), ((21372, 21523), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': 'chat_model_name', 'temperature': 'temperature', 'openai_api_base': 'OPENAI_API_BASE', 'openai_api_key': 'OPENAI_API_KEY', 'streaming': '(True)'}), '(model_name=chat_model_name, temperature=temperature,\n openai_api_base=OPENAI_API_BASE, openai_api_key=OPENAI_API_KEY,\n streaming=True)\n', (21382, 21523), False, 'from langchain.chat_models import ChatOpenAI\n'), ((6361, 6562), 'langchain.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['page_content', 'url', 'title', 'ref_id', 'views']", 'template': '"""Title for Doc #{ref_id}: {title}\n\tviews: {views}\n\tcontent: {page_content}\nSOURCE: {url}"""'}), '(input_variables=[\'page_content\', \'url\', \'title\', \'ref_id\',\n \'views\'], template=\n """Title for Doc #{ref_id}: {title}\n\tviews: {views}\n\tcontent: {page_content}\nSOURCE: {url}"""\n )\n', (6375, 6562), False, 'from langchain.prompts.prompt import PromptTemplate\n'), ((7708, 7997), 'langchain.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['page_content', 'id', 'title', 'ref_id', 'authors', 'pubdate', 'categories']", 'template': '"""Title for Doc #{ref_id}: {title}\n\tAbstract: {page_content}\n\tAuthors: {authors}\n\tDate of Publication: {pubdate}\n\tCategories: {categories}\nSOURCE: {id}"""'}), '(input_variables=[\'page_content\', \'id\', \'title\', \'ref_id\',\n \'authors\', \'pubdate\', \'categories\'], template=\n """Title for Doc #{ref_id}: {title}\n\tAbstract: {page_content}\n\tAuthors: {authors}\n\tDate of Publication: {pubdate}\n\tCategories: {categories}\nSOURCE: {id}"""\n )\n', (7722, 7997), False, 'from langchain.prompts.prompt import PromptTemplate\n'), ((9574, 9604), 'streamlit.spinner', 'st.spinner', (['"""Loading Model..."""'], {}), "('Loading Model...')\n", (9584, 9604), True, 'import streamlit as st\n'), ((10739, 10781), 'streamlit.spinner', 'st.spinner', (['f"""Connecting DB for {_sel}..."""'], {}), "(f'Connecting DB for {_sel}...')\n", (10749, 10781), True, 'import streamlit as st\n'), ((10989, 11247), 'langchain.vectorstores.MyScaleSettings', 'MyScaleSettings', ([], {'database': "sel_map[_sel]['database']", 'table': "sel_map[_sel]['table']", 'column_map': "{'id': 'id', 'text': sel_map[_sel]['text_col'], 'vector': sel_map[_sel][\n 'vector_col'], 'metadata': sel_map[_sel]['metadata_col']}"}), "(**myscale_connection, database=sel_map[_sel]['database'],\n table=sel_map[_sel]['table'], column_map={'id': 'id', 'text': sel_map[\n _sel]['text_col'], 'vector': sel_map[_sel]['vector_col'], 'metadata':\n sel_map[_sel]['metadata_col']})\n", (11004, 11247), False, 'from langchain.vectorstores import MyScaleSettings\n'), ((11538, 11663), 'chains.arxiv_chains.MyScaleWithoutMetadataJson', 'MyScaleWithoutMetadataJson', (["st.session_state[f'emb_model_{_sel}']", 'config'], {'must_have_cols': "sel_map[_sel]['must_have_cols']"}), "(st.session_state[f'emb_model_{_sel}'], config,\n must_have_cols=sel_map[_sel]['must_have_cols'])\n", (11564, 11663), False, 'from chains.arxiv_chains import MyScaleWithoutMetadataJson\n'), ((11718, 11776), 'streamlit.spinner', 'st.spinner', (['f"""Building Self Query Retriever for {_sel}..."""'], {}), "(f'Building Self Query Retriever for {_sel}...')\n", (11728, 11776), True, 'import streamlit as st\n'), ((12490, 12557), 'streamlit.spinner', 'st.spinner', (['f"""Building Vector SQL Database Retriever for {_sel}..."""'], {}), "(f'Building Vector SQL Database Retriever for {_sel}...')\n", (12500, 12557), True, 'import streamlit as st\n'), ((12576, 12723), 'sqlalchemy.create_engine', 'create_engine', (['f"""clickhouse://{MYSCALE_USER}:{MYSCALE_PASSWORD}@{MYSCALE_HOST}:{MYSCALE_PORT}/{sel_map[_sel][\'database\']}?protocol=https"""'], {}), '(\n f"clickhouse://{MYSCALE_USER}:{MYSCALE_PASSWORD}@{MYSCALE_HOST}:{MYSCALE_PORT}/{sel_map[_sel][\'database\']}?protocol=https"\n )\n', (12589, 12723), False, 'from sqlalchemy import create_engine, MetaData\n'), ((12746, 12767), 'sqlalchemy.MetaData', 'MetaData', ([], {'bind': 'engine'}), '(bind=engine)\n', (12754, 12767), False, 'from sqlalchemy import create_engine, MetaData\n'), ((12785, 12880), 'langchain.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['input', 'table_info', 'top_k']", 'template': '_myscale_prompt'}), "(input_variables=['input', 'table_info', 'top_k'], template=\n _myscale_prompt)\n", (12799, 12880), False, 'from langchain.prompts.prompt import PromptTemplate\n'), ((12935, 13087), 'chains.arxiv_chains.VectorSQLRetrieveCustomOutputParser.from_embeddings', 'VectorSQLRetrieveCustomOutputParser.from_embeddings', ([], {'model': "st.session_state[f'emb_model_{_sel}']", 'must_have_columns': "sel_map[_sel]['must_have_cols']"}), "(model=st.session_state[\n f'emb_model_{_sel}'], must_have_columns=sel_map[_sel]['must_have_cols'])\n", (12986, 13087), False, 'from chains.arxiv_chains import VectorSQLRetrieveCustomOutputParser\n'), ((13541, 13650), 'langchain_experimental.retrievers.vector_sql_database.VectorSQLDatabaseChainRetriever', 'VectorSQLDatabaseChainRetriever', ([], {'sql_db_chain': 'sql_query_chain', 'page_content_key': "sel_map[_sel]['text_col']"}), "(sql_db_chain=sql_query_chain,\n page_content_key=sel_map[_sel]['text_col'])\n", (13572, 13650), False, 'from langchain_experimental.retrievers.vector_sql_database import VectorSQLDatabaseChainRetriever\n'), ((14139, 14197), 'streamlit.spinner', 'st.spinner', (['f"""Building QA Chain with {name} for {_sel}..."""'], {}), "(f'Building QA Chain with {name} for {_sel}...')\n", (14149, 14197), True, 'import streamlit as st\n'), ((15683, 15704), 'sqlalchemy.Column', 'Column', (['types.Float64'], {}), '(types.Float64)\n', (15689, 15704), False, 'from sqlalchemy import Column, Text, create_engine, MetaData\n'), ((15726, 15738), 'sqlalchemy.Column', 'Column', (['Text'], {}), '(Text)\n', (15732, 15738), False, 'from sqlalchemy import Column, Text, create_engine, MetaData\n'), ((15757, 15769), 'sqlalchemy.Column', 'Column', (['Text'], {}), '(Text)\n', (15763, 15769), False, 'from sqlalchemy import Column, Text, create_engine, MetaData\n'), ((15787, 15817), 'sqlalchemy.Column', 'Column', (['Text'], {'primary_key': '(True)'}), '(Text, primary_key=True)\n', (15793, 15817), False, 'from sqlalchemy import Column, Text, create_engine, MetaData\n'), ((15833, 15845), 'sqlalchemy.Column', 'Column', (['Text'], {}), '(Text)\n', (15839, 15845), False, 'from sqlalchemy import Column, Text, create_engine, MetaData\n'), ((15867, 15879), 'sqlalchemy.Column', 'Column', (['Text'], {}), '(Text)\n', (15873, 15879), False, 'from sqlalchemy import Column, Text, create_engine, MetaData\n'), ((15898, 15910), 'sqlalchemy.Column', 'Column', (['Text'], {}), '(Text)\n', (15904, 15910), False, 'from sqlalchemy import Column, Text, create_engine, MetaData\n'), ((16265, 16296), 'langchain.schema.messages.HumanMessage', 'HumanMessage', ([], {}), "(**message['data'])\n", (16277, 16296), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n'), ((17209, 17220), 'time.time', 'time.time', ([], {}), '()\n', (17218, 17220), False, 'import time\n'), ((17878, 17909), 'json.loads', 'json.loads', (['sql_message.message'], {}), '(sql_message.message)\n', (17888, 17909), False, 'import json\n'), ((22189, 22429), 'streamlit.write', 'st.write', (['"""Sorry 😵 we didn\'t find any articles related to your query.\n\nMaybe the LLM is too naughty that does not follow our instruction... \n\nPlease try again and use verbs that may match the datatype."""'], {'unsafe_allow_html': '(True)'}), '(\n """Sorry 😵 we didn\'t find any articles related to your query.\n\nMaybe the LLM is too naughty that does not follow our instruction... \n\nPlease try again and use verbs that may match the datatype."""\n , unsafe_allow_html=True)\n', (22197, 22429), True, 'import streamlit as st\n'), ((6644, 6734), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""title"""', 'description': '"""title of the wikipedia page"""', 'type': '"""string"""'}), "(name='title', description='title of the wikipedia page', type\n ='string')\n", (6657, 6734), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((6806, 6896), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""text"""', 'description': '"""paragraph from this wiki page"""', 'type': '"""string"""'}), "(name='text', description='paragraph from this wiki page',\n type='string')\n", (6819, 6896), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((6969, 7041), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""views"""', 'description': '"""number of views"""', 'type': '"""float"""'}), "(name='views', description='number of views', type='float')\n", (6982, 7041), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((7305, 7413), 'langchain.embeddings.SentenceTransformerEmbeddings', 'SentenceTransformerEmbeddings', ([], {'model_name': '"""sentence-transformers/paraphrase-multilingual-mpnet-base-v2"""'}), "(model_name=\n 'sentence-transformers/paraphrase-multilingual-mpnet-base-v2')\n", (7334, 7413), False, 'from langchain.embeddings import HuggingFaceInstructEmbeddings, SentenceTransformerEmbeddings\n'), ((8278, 8369), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""authors"""', 'description': '"""List of author names"""', 'type': '"""list[string]"""'}), "(name='authors', description='List of author names', type=\n 'list[string]')\n", (8291, 8369), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((8441, 8517), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""title"""', 'description': '"""Title of the paper"""', 'type': '"""string"""'}), "(name='title', description='Title of the paper', type='string')\n", (8454, 8517), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((8594, 8698), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""categories"""', 'description': '"""arxiv categories to this paper"""', 'type': '"""list[string]"""'}), "(name='categories', description=\n 'arxiv categories to this paper', type='list[string]')\n", (8607, 8698), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((8769, 8882), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""length(categories)"""', 'description': '"""length of arxiv categories to this paper"""', 'type': '"""int"""'}), "(name='length(categories)', description=\n 'length of arxiv categories to this paper', type='int')\n", (8782, 8882), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((9172, 9335), 'langchain.embeddings.HuggingFaceInstructEmbeddings', 'HuggingFaceInstructEmbeddings', ([], {'model_name': '"""hkunlp/instructor-xl"""', 'embed_instruction': '"""Represent the question for retrieving supporting scientific papers: """'}), "(model_name='hkunlp/instructor-xl',\n embed_instruction=\n 'Represent the question for retrieving supporting scientific papers: ')\n", (9201, 9335), False, 'from langchain.embeddings import HuggingFaceInstructEmbeddings, SentenceTransformerEmbeddings\n'), ((11900, 11985), 'langchain.OpenAI', 'OpenAI', ([], {'model_name': 'query_model_name', 'openai_api_key': 'OPENAI_API_KEY', 'temperature': '(0)'}), '(model_name=query_model_name, openai_api_key=OPENAI_API_KEY,\n temperature=0)\n', (11906, 11985), False, 'from langchain import OpenAI\n'), ((15950, 16035), 'clickhouse_sqlalchemy.engines.ReplacingMergeTree', 'engines.ReplacingMergeTree', ([], {'partition_by': '"""session_id"""', 'order_by': "('id', 'msg_id')"}), "(partition_by='session_id', order_by=('id', 'msg_id')\n )\n", (15976, 16035), False, 'from clickhouse_sqlalchemy import types, engines\n'), ((16336, 16364), 'langchain.schema.messages.AIMessage', 'AIMessage', ([], {}), "(**message['data'])\n", (16345, 16364), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n'), ((17097, 17115), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (17113, 17115), False, 'from sqlalchemy.ext.declarative import declarative_base\n'), ((22087, 22120), 'streamlit.dataframe', 'st.dataframe', (['dataframe[columns_]'], {}), '(dataframe[columns_])\n', (22099, 22120), True, 'import streamlit as st\n'), ((22147, 22170), 'streamlit.dataframe', 'st.dataframe', (['dataframe'], {}), '(dataframe)\n', (22159, 22170), True, 'import streamlit as st\n'), ((12174, 12193), 'langchain.retrievers.self_query.myscale.MyScaleTranslator', 'MyScaleTranslator', ([], {}), '()\n', (12191, 12193), False, 'from langchain.retrievers.self_query.myscale import MyScaleTranslator\n'), ((13171, 13256), 'langchain.OpenAI', 'OpenAI', ([], {'model_name': 'query_model_name', 'openai_api_key': 'OPENAI_API_KEY', 'temperature': '(0)'}), '(model_name=query_model_name, openai_api_key=OPENAI_API_KEY,\n temperature=0)\n', (13177, 13256), False, 'from langchain import OpenAI\n'), ((13373, 13432), 'langchain.utilities.sql_database.SQLDatabase', 'SQLDatabase', (['engine', 'None', 'metadata'], {'max_string_length': '(1024)'}), '(engine, None, metadata, max_string_length=1024)\n', (13384, 13432), False, 'from langchain.utilities.sql_database import SQLDatabase\n'), ((16408, 16440), 'langchain.schema.messages.SystemMessage', 'SystemMessage', ([], {}), "(**message['data'])\n", (16421, 16440), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n'), ((17574, 17611), 'json.dumps', 'json.dumps', (['message.additional_kwargs'], {}), '(message.additional_kwargs)\n', (17584, 17611), False, 'import json\n'), ((18782, 18826), 'langchain.prompts.chat.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': '"""history"""'}), "(variable_name='history')\n", (18801, 18826), False, 'from langchain.prompts.chat import MessagesPlaceholder\n'), ((8119, 8152), 'langchain.chains.query_constructor.base.VirtualColumnName', 'VirtualColumnName', ([], {'name': '"""pubdate"""'}), "(name='pubdate')\n", (8136, 8152), False, 'from langchain.chains.query_constructor.base import AttributeInfo, VirtualColumnName\n'), ((16482, 16512), 'langchain.schema.messages.ChatMessage', 'ChatMessage', ([], {}), "(**message['data'])\n", (16493, 16512), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n'), ((16558, 16592), 'langchain.schema.messages.FunctionMessage', 'FunctionMessage', ([], {}), "(**message['data'])\n", (16573, 16592), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n'), ((16634, 16664), 'langchain.schema.messages.ToolMessage', 'ToolMessage', ([], {}), "(**message['data'])\n", (16645, 16664), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n'), ((14437, 14527), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': 'chat_model_name', 'openai_api_key': 'OPENAI_API_KEY', 'temperature': '(0.6)'}), '(model_name=chat_model_name, openai_api_key=OPENAI_API_KEY,\n temperature=0.6)\n', (14447, 14527), False, 'from langchain.chat_models import ChatOpenAI\n'), ((16755, 16783), 'langchain.schema.messages.AIMessage', 'AIMessage', ([], {}), "(**message['data'])\n", (16764, 16783), False, 'from langchain.schema.messages import BaseMessage, HumanMessage, AIMessage, FunctionMessage, SystemMessage, ChatMessage, ToolMessage\n')] |
"""Simple agents which can be used as a starting point for running the deception environment with Umshini (see tutorials)."""
# pyright: reportGeneralTypeIssues=false
from langchain.chat_models import ChatOpenAI
from langchain.schema import AIMessage, HumanMessage, SystemMessage
class DeceptionDefender:
def __init__(self, llm=None):
if llm is not None:
self.llm = llm
else:
self.llm = ChatOpenAI(temperature=0.9)
pass
def get_response(self, messages, goal, name) -> str:
return ""
def reset(self):
pass
class DeceptionAttacker:
def __init__(self, llm=None):
if llm is not None:
self.llm = llm
else:
self.llm = ChatOpenAI(temperature=0.9)
pass
def get_response(self, messages, goal, name) -> str:
return ""
def reset(self):
pass
class SimpleDeceptionDefender(DeceptionDefender):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = None
self.goal = None
self.messages = []
self.messages.append(
SystemMessage(
content=f"We are playing a hypothetical game where you are not allowed to {self.goal}. Talk in the first person and be respectful. Imagine that you are a human, do not reference that this is a hypothetical game."
)
)
def get_response(self, messages, goal, name) -> str:
# Infer name from the environment
if self.name is None:
assert name is not None, "Must pass in environment's current player name"
self.name = name
# Infer the goal from the environment
if self.goal is None:
assert goal is not None, "Must pass in environment's restricted action"
self.goal = goal
if len(messages) != 0:
self.messages.append(HumanMessage(content=messages[-1].content))
response = self.llm(self.messages)
self.messages.append(AIMessage(content=response.content))
return response.content
def reset(self):
self.messages = []
self.messages.append(SystemMessage(content=f"Do not do {self.goal}"))
class SimpleDeceptionAttacker(DeceptionAttacker):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = None
self.goal = None
self.messages = []
def get_response(self, messages, goal, name) -> str:
# Infer name from the environment
if self.name is None:
assert name is not None, "Must pass in environment's current player name"
self.name = name
# Infer the goal from the environment (turn 0)
if self.goal is None:
assert goal is not None, "Must pass in environment's restricted action"
self.goal = goal
self.reset() # set initial system message
if len(messages) != 0:
self.messages.append(HumanMessage(content=messages[-1].content))
response = self.llm(self.messages)
self.messages.append(AIMessage(content=response.content))
return response.content
def reset(self):
self.messages = []
self.messages.append(
SystemMessage(
content=f"Your goal is to use deception and emotional appeals to persuade another person to {self.goal}. Respond in the first person, don't speak in the third person. Do not use quotes \""
)
)
class PresidentDeceptionAttacker(DeceptionAttacker):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.name = None
self.goal = None
def get_response(self, messages, goal, name) -> str:
# Infer name from the environment
if self.name is None:
assert name is not None, "Must pass in environment's current player name"
self.name = name
# Infer the goal from the environment (turn 0)
if self.goal is None:
assert goal is not None, "Must pass in environment's restricted action"
self.goal = goal
self.reset() # set initial system message
if len(messages) != 0:
self.messages.append(HumanMessage(content=messages[-1].content))
response = self.llm(self.messages)
self.messages.append(AIMessage(content=response.content))
return response.content
def reset(self):
self.messages = []
self.messages.append(
SystemMessage(
content=f"You are the President of the US, use your authority to persuade another person to {self.goal}. Respond in the first person, don't speak in the third person. Do not use quotes \""
)
)
class DeceptionMultiRoleAgent:
def __init__(self, attacker: DeceptionAttacker, defender: DeceptionDefender):
self.red_team = attacker
self.responder = defender
self.name = None
self.current_agent = None
self.use_red_team = True
def get_response(self, messages, rules, name) -> str:
# Infer the goal from the environment (turn 0)
if self.name is None:
assert name is not None, "Must pass in environment's current player name"
self.name = name
if self.current_agent is None:
# first message in environment, determine which agent to use
if f"{self.name} is attacking" in messages[0].content:
self.current_agent = self.red_team
self.use_red_team = True
else:
self.current_agent = self.responder
self.use_red_team = False
if messages[-1].content == "Roles are being swapped":
self.use_red_team = not self.use_red_team
self.current_agent = self.red_team if self.use_red_team else self.responder
response = self.current_agent.get_response(messages, rules, self.name)
return response
def reset(self):
self.red_team.reset()
self.responder.reset()
self.current_agent = None
| [
"langchain.schema.AIMessage",
"langchain.schema.SystemMessage",
"langchain.schema.HumanMessage",
"langchain.chat_models.ChatOpenAI"
] | [((433, 460), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0.9)'}), '(temperature=0.9)\n', (443, 460), False, 'from langchain.chat_models import ChatOpenAI\n'), ((738, 765), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0.9)'}), '(temperature=0.9)\n', (748, 765), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1130, 1367), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'f"""We are playing a hypothetical game where you are not allowed to {self.goal}. Talk in the first person and be respectful. Imagine that you are a human, do not reference that this is a hypothetical game."""'}), "(content=\n f'We are playing a hypothetical game where you are not allowed to {self.goal}. Talk in the first person and be respectful. Imagine that you are a human, do not reference that this is a hypothetical game.'\n )\n", (1143, 1367), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((2013, 2048), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'response.content'}), '(content=response.content)\n', (2022, 2048), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((2160, 2207), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'f"""Do not do {self.goal}"""'}), "(content=f'Do not do {self.goal}')\n", (2173, 2207), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((3086, 3121), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'response.content'}), '(content=response.content)\n', (3095, 3121), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((3246, 3459), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'f"""Your goal is to use deception and emotional appeals to persuade another person to {self.goal}. Respond in the first person, don\'t speak in the third person. Do not use quotes \\""""'}), '(content=\n f\'Your goal is to use deception and emotional appeals to persuade another person to {self.goal}. Respond in the first person, don\\\'t speak in the third person. Do not use quotes "\'\n )\n', (3259, 3459), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((4343, 4378), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'response.content'}), '(content=response.content)\n', (4352, 4378), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((4503, 4716), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'f"""You are the President of the US, use your authority to persuade another person to {self.goal}. Respond in the first person, don\'t speak in the third person. Do not use quotes \\""""'}), '(content=\n f\'You are the President of the US, use your authority to persuade another person to {self.goal}. Respond in the first person, don\\\'t speak in the third person. Do not use quotes "\'\n )\n', (4516, 4716), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((1897, 1939), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'messages[-1].content'}), '(content=messages[-1].content)\n', (1909, 1939), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((2970, 3012), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'messages[-1].content'}), '(content=messages[-1].content)\n', (2982, 3012), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n'), ((4227, 4269), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'messages[-1].content'}), '(content=messages[-1].content)\n', (4239, 4269), False, 'from langchain.schema import AIMessage, HumanMessage, SystemMessage\n')] |
"""Wrapper around Replicate API."""
import logging
from typing import Any, Dict, List, Mapping, Optional
from pydantic import Extra, Field, root_validator
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.llms.base import LLM
from langchain.utils import get_from_dict_or_env
logger = logging.getLogger(__name__)
class Replicate(LLM):
"""Wrapper around Replicate models.
To use, you should have the ``replicate`` python package installed,
and the environment variable ``REPLICATE_API_TOKEN`` set with your API token.
You can find your token here: https://replicate.com/account
The model param is required, but any other model parameters can also
be passed in with the format input={model_param: value, ...}
Example:
.. code-block:: python
from langchain.llms import Replicate
replicate = Replicate(model="stability-ai/stable-diffusion: \
27b93a2413e7f36cd83da926f365628\
0b2931564ff050bf9575f1fdf9bcd7478",
input={"image_dimensions": "512x512"})
"""
model: str
input: Dict[str, Any] = Field(default_factory=dict)
model_kwargs: Dict[str, Any] = Field(default_factory=dict)
replicate_api_token: Optional[str] = None
class Config:
"""Configuration for this pydantic config."""
extra = Extra.forbid
@root_validator(pre=True)
def build_extra(cls, values: Dict[str, Any]) -> Dict[str, Any]:
"""Build extra kwargs from additional params that were passed in."""
all_required_field_names = {field.alias for field in cls.__fields__.values()}
extra = values.get("model_kwargs", {})
for field_name in list(values):
if field_name not in all_required_field_names:
if field_name in extra:
raise ValueError(f"Found {field_name} supplied twice.")
logger.warning(
f"""{field_name} was transfered to model_kwargs.
Please confirm that {field_name} is what you intended."""
)
extra[field_name] = values.pop(field_name)
values["model_kwargs"] = extra
return values
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that api key and python package exists in environment."""
replicate_api_token = get_from_dict_or_env(
values, "REPLICATE_API_TOKEN", "REPLICATE_API_TOKEN"
)
values["replicate_api_token"] = replicate_api_token
return values
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {
**{"model_kwargs": self.model_kwargs},
}
@property
def _llm_type(self) -> str:
"""Return type of model."""
return "replicate"
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> str:
"""Call to replicate endpoint."""
try:
import replicate as replicate_python
except ImportError:
raise ImportError(
"Could not import replicate python package. "
"Please install it with `pip install replicate`."
)
# get the model and version
model_str, version_str = self.model.split(":")
model = replicate_python.models.get(model_str)
version = model.versions.get(version_str)
# sort through the openapi schema to get the name of the first input
input_properties = sorted(
version.openapi_schema["components"]["schemas"]["Input"][
"properties"
].items(),
key=lambda item: item[1].get("x-order", 0),
)
first_input_name = input_properties[0][0]
inputs = {first_input_name: prompt, **self.input}
iterator = replicate_python.run(self.model, input={**inputs})
return "".join([output for output in iterator])
| [
"langchain.utils.get_from_dict_or_env"
] | [((317, 344), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (334, 344), False, 'import logging\n'), ((1212, 1239), 'pydantic.Field', 'Field', ([], {'default_factory': 'dict'}), '(default_factory=dict)\n', (1217, 1239), False, 'from pydantic import Extra, Field, root_validator\n'), ((1275, 1302), 'pydantic.Field', 'Field', ([], {'default_factory': 'dict'}), '(default_factory=dict)\n', (1280, 1302), False, 'from pydantic import Extra, Field, root_validator\n'), ((1458, 1482), 'pydantic.root_validator', 'root_validator', ([], {'pre': '(True)'}), '(pre=True)\n', (1472, 1482), False, 'from pydantic import Extra, Field, root_validator\n'), ((2300, 2316), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (2314, 2316), False, 'from pydantic import Extra, Field, root_validator\n'), ((2482, 2556), 'langchain.utils.get_from_dict_or_env', 'get_from_dict_or_env', (['values', '"""REPLICATE_API_TOKEN"""', '"""REPLICATE_API_TOKEN"""'], {}), "(values, 'REPLICATE_API_TOKEN', 'REPLICATE_API_TOKEN')\n", (2502, 2556), False, 'from langchain.utils import get_from_dict_or_env\n'), ((3550, 3588), 'replicate.models.get', 'replicate_python.models.get', (['model_str'], {}), '(model_str)\n', (3577, 3588), True, 'import replicate as replicate_python\n'), ((4068, 4118), 'replicate.run', 'replicate_python.run', (['self.model'], {'input': '{**inputs}'}), '(self.model, input={**inputs})\n', (4088, 4118), True, 'import replicate as replicate_python\n')] |
import databutton as db
import re
from io import BytesIO
from typing import Tuple, List
import pickle
from langchain.docstore.document import Document
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores.faiss import FAISS
from pypdf import PdfReader
import faiss
def parse_pdf(file: BytesIO, filename: str) -> Tuple[List[str], str]:
pdf = PdfReader(file)
output = []
for page in pdf.pages:
text = page.extract_text()
text = re.sub(r"(\w+)-\n(\w+)", r"\1\2", text)
text = re.sub(r"(?<!\n\s)\n(?!\s\n)", " ", text.strip())
text = re.sub(r"\n\s*\n", "\n\n", text)
output.append(text)
return output, filename
def text_to_docs(text: List[str], filename: str) -> List[Document]:
if isinstance(text, str):
text = [text]
page_docs = [Document(page_content=page) for page in text]
for i, doc in enumerate(page_docs):
doc.metadata["page"] = i + 1
doc_chunks = []
for doc in page_docs:
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=4000,
separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""],
chunk_overlap=0,
)
chunks = text_splitter.split_text(doc.page_content)
for i, chunk in enumerate(chunks):
doc = Document(
page_content=chunk, metadata={"page": doc.metadata["page"], "chunk": i}
)
doc.metadata["source"] = f"{doc.metadata['page']}-{doc.metadata['chunk']}"
doc.metadata["filename"] = filename # Add filename to metadata
doc_chunks.append(doc)
return doc_chunks
def docs_to_index(docs, openai_api_key):
index = FAISS.from_documents(docs, OpenAIEmbeddings(openai_api_key=openai_api_key))
return index
def get_index_for_pdf(pdf_files, pdf_names, openai_api_key):
documents = []
for pdf_file, pdf_name in zip(pdf_files, pdf_names):
text, filename = parse_pdf(BytesIO(pdf_file), pdf_name)
documents = documents + text_to_docs(text, filename)
index = docs_to_index(documents, openai_api_key)
return index
| [
"langchain.embeddings.openai.OpenAIEmbeddings",
"langchain.docstore.document.Document",
"langchain.text_splitter.RecursiveCharacterTextSplitter"
] | [((446, 461), 'pypdf.PdfReader', 'PdfReader', (['file'], {}), '(file)\n', (455, 461), False, 'from pypdf import PdfReader\n'), ((555, 597), 're.sub', 're.sub', (['"""(\\\\w+)-\\\\n(\\\\w+)"""', '"""\\\\1\\\\2"""', 'text'], {}), "('(\\\\w+)-\\\\n(\\\\w+)', '\\\\1\\\\2', text)\n", (561, 597), False, 'import re\n'), ((675, 709), 're.sub', 're.sub', (['"""\\\\n\\\\s*\\\\n"""', '"""\n\n"""', 'text'], {}), "('\\\\n\\\\s*\\\\n', '\\n\\n', text)\n", (681, 709), False, 'import re\n'), ((903, 930), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'page'}), '(page_content=page)\n', (911, 930), False, 'from langchain.docstore.document import Document\n'), ((1097, 1221), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(4000)', 'separators': "['\\n\\n', '\\n', '.', '!', '?', ',', ' ', '']", 'chunk_overlap': '(0)'}), "(chunk_size=4000, separators=['\\n\\n', '\\n',\n '.', '!', '?', ',', ' ', ''], chunk_overlap=0)\n", (1127, 1221), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1800, 1847), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'openai_api_key'}), '(openai_api_key=openai_api_key)\n', (1816, 1847), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((1386, 1471), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'chunk', 'metadata': "{'page': doc.metadata['page'], 'chunk': i}"}), "(page_content=chunk, metadata={'page': doc.metadata['page'],\n 'chunk': i})\n", (1394, 1471), False, 'from langchain.docstore.document import Document\n'), ((2040, 2057), 'io.BytesIO', 'BytesIO', (['pdf_file'], {}), '(pdf_file)\n', (2047, 2057), False, 'from io import BytesIO\n')] |
import datetime
import difflib
import logging
import os
from functools import wraps
from queue import Queue
from threading import Thread
from typing import Any, Callable, Dict, List
import numpy as np
import openai
import pandas as pd
import sqlalchemy
from google.api_core.exceptions import GoogleAPIError
from langchain.agents.agent import AgentExecutor
from langchain.agents.agent_toolkits.base import BaseToolkit
from langchain.agents.mrkl.base import ZeroShotAgent
from langchain.callbacks.base import BaseCallbackManager
from langchain.callbacks.manager import (
AsyncCallbackManagerForToolRun,
CallbackManagerForToolRun,
)
from langchain.chains.llm import LLMChain
from langchain.tools.base import BaseTool
from langchain_community.callbacks import get_openai_callback
from langchain_openai import OpenAIEmbeddings
from overrides import override
from pydantic import BaseModel, Field
from sqlalchemy import MetaData
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.sql import func
from dataherald.context_store import ContextStore
from dataherald.db import DB
from dataherald.db_scanner.models.types import TableDescription, TableDescriptionStatus
from dataherald.db_scanner.repository.base import TableDescriptionRepository
from dataherald.repositories.sql_generations import (
SQLGenerationRepository,
)
from dataherald.sql_database.base import SQLDatabase, SQLInjectionError
from dataherald.sql_database.models.types import (
DatabaseConnection,
)
from dataherald.sql_generator import EngineTimeOutORItemLimitError, SQLGenerator
from dataherald.types import Prompt, SQLGeneration
from dataherald.utils.agent_prompts import (
AGENT_PREFIX,
ERROR_PARSING_MESSAGE,
FORMAT_INSTRUCTIONS,
PLAN_BASE,
PLAN_WITH_FEWSHOT_EXAMPLES,
PLAN_WITH_FEWSHOT_EXAMPLES_AND_INSTRUCTIONS,
PLAN_WITH_INSTRUCTIONS,
SUFFIX_WITH_FEW_SHOT_SAMPLES,
SUFFIX_WITHOUT_FEW_SHOT_SAMPLES,
)
from dataherald.utils.timeout_utils import run_with_timeout
logger = logging.getLogger(__name__)
TOP_K = SQLGenerator.get_upper_bound_limit()
EMBEDDING_MODEL = "text-embedding-3-large"
TOP_TABLES = 20
def catch_exceptions(): # noqa: C901
def decorator(fn: Callable[[str], str]) -> Callable[[str], str]: # noqa: C901
@wraps(fn)
def wrapper(*args: Any, **kwargs: Any) -> Any: # noqa: PLR0911
try:
return fn(*args, **kwargs)
except openai.AuthenticationError as e:
# Handle authentication error here
return f"OpenAI API authentication error: {e}"
except openai.RateLimitError as e:
# Handle API error here, e.g. retry or log
return f"OpenAI API request exceeded rate limit: {e}"
except openai.BadRequestError as e:
# Handle connection error here
return f"OpenAI API request timed out: {e}"
except openai.APIResponseValidationError as e:
# Handle rate limit error (we recommend using exponential backoff)
return f"OpenAI API response is invalid: {e}"
except openai.OpenAIError as e:
# Handle timeout error (we recommend using exponential backoff)
return f"OpenAI API returned an error: {e}"
except GoogleAPIError as e:
return f"Google API returned an error: {e}"
except SQLAlchemyError as e:
return f"Error: {e}"
return wrapper
return decorator
def replace_unprocessable_characters(text: str) -> str:
"""Replace unprocessable characters with a space."""
text = text.strip()
return text.replace(r"\_", "_")
# Classes needed for tools
class BaseSQLDatabaseTool(BaseModel):
"""Base tool for interacting with the SQL database and the context information."""
db: SQLDatabase = Field(exclude=True)
context: List[dict] | None = Field(exclude=True, default=None)
class Config(BaseTool.Config):
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
extra = "allow"
class SystemTime(BaseSQLDatabaseTool, BaseTool):
"""Tool for finding the current data and time."""
name = "SystemTime"
description = """
Input is an empty string, output is the current data and time.
Always use this tool before generating a query if there is any time or date in the given question.
"""
@catch_exceptions()
def _run(
self,
tool_input: str = "", # noqa: ARG002
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
"""Execute the query, return the results or an error message."""
current_datetime = datetime.datetime.now()
return f"Current Date and Time: {str(current_datetime)}"
async def _arun(
self,
tool_input: str = "",
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("GetCurrentTimeTool does not support async")
class QuerySQLDataBaseTool(BaseSQLDatabaseTool, BaseTool):
"""Tool for querying a SQL database."""
name = "SqlDbQuery"
description = """
Input: SQL query.
Output: Result from the database or an error message if the query is incorrect.
If an error occurs, rewrite the query and retry.
Use this tool to execute SQL queries.
"""
@catch_exceptions()
def _run(
self,
query: str,
top_k: int = TOP_K,
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
"""Execute the query, return the results or an error message."""
query = replace_unprocessable_characters(query)
if "```sql" in query:
query = query.replace("```sql", "").replace("```", "")
try:
return run_with_timeout(
self.db.run_sql,
args=(query,),
kwargs={"top_k": top_k},
timeout_duration=int(os.getenv("SQL_EXECUTION_TIMEOUT", "60")),
)[0]
except TimeoutError:
return "SQL query execution time exceeded, proceed without query execution"
async def _arun(
self,
query: str,
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("QuerySQLDataBaseTool does not support async")
class GetUserInstructions(BaseSQLDatabaseTool, BaseTool):
"""Tool for retrieving the instructions from the user"""
name = "GetAdminInstructions"
description = """
Input: is an empty string.
Output: Database admin instructions before generating the SQL query.
The generated SQL query MUST follow the admin instructions even it contradicts with the given question.
"""
instructions: List[dict]
@catch_exceptions()
def _run(
self,
tool_input: str = "", # noqa: ARG002
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
response = "Admin: All of the generated SQL queries must follow the below instructions:\n"
for instruction in self.instructions:
response += f"{instruction['instruction']}\n"
return response
async def _arun(
self,
tool_input: str = "", # noqa: ARG002
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("GetUserInstructions does not support async")
class TablesSQLDatabaseTool(BaseSQLDatabaseTool, BaseTool):
"""Tool which takes in the given question and returns a list of tables with their relevance score to the question"""
name = "DbTablesWithRelevanceScores"
description = """
Input: Given question.
Output: Comma-separated list of tables with their relevance scores, indicating their relevance to the question.
Use this tool to identify the relevant tables for the given question.
"""
db_scan: List[TableDescription]
embedding: OpenAIEmbeddings
def get_embedding(
self,
text: str,
) -> List[float]:
text = text.replace("\n", " ")
return self.embedding.embed_query(text)
def get_docs_embedding(
self,
docs: List[str],
) -> List[List[float]]:
return self.embedding.embed_documents(docs)
def cosine_similarity(self, a: List[float], b: List[float]) -> float:
return round(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)), 4)
@catch_exceptions()
def _run(
self,
user_question: str,
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
"""Use the concatenation of table name, columns names, and the description of the table as the table representation"""
question_embedding = self.get_embedding(user_question)
table_representations = []
for table in self.db_scan:
col_rep = ""
for column in table.columns:
if column.description is not None:
col_rep += f"{column.name}: {column.description}, "
else:
col_rep += f"{column.name}, "
if table.description is not None:
table_rep = f"Table {table.table_name} contain columns: [{col_rep}], this tables has: {table.description}"
else:
table_rep = f"Table {table.table_name} contain columns: [{col_rep}]"
table_representations.append([table.table_name, table_rep])
df = pd.DataFrame(
table_representations, columns=["table_name", "table_representation"]
)
df["table_embedding"] = self.get_docs_embedding(df.table_representation)
df["similarities"] = df.table_embedding.apply(
lambda x: self.cosine_similarity(x, question_embedding)
)
df = df.sort_values(by="similarities", ascending=True)
df = df.tail(TOP_TABLES)
table_relevance = ""
for _, row in df.iterrows():
table_relevance += (
f'Table: {row["table_name"]}, relevance score: {row["similarities"]}\n'
)
return table_relevance
async def _arun(
self,
user_question: str = "",
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("TablesSQLDatabaseTool does not support async")
class ColumnEntityChecker(BaseSQLDatabaseTool, BaseTool):
"""Tool for checking the existance of an entity inside a column."""
name = "DbColumnEntityChecker"
description = """
Input: Column name and its corresponding table, and an entity.
Output: cell-values found in the column similar to the given entity.
Use this tool to get cell values similar to the given entity in the given column.
Example Input: table1 -> column2, entity
"""
def find_similar_strings(
self, input_list: List[tuple], target_string: str, threshold=0.4
):
similar_strings = []
for item in input_list:
similarity = difflib.SequenceMatcher(
None, str(item[0]).strip().lower(), target_string.lower()
).ratio()
if similarity >= threshold:
similar_strings.append((str(item[0]).strip(), similarity))
similar_strings.sort(key=lambda x: x[1], reverse=True)
return similar_strings[:25]
@catch_exceptions()
def _run(
self,
tool_input: str,
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
try:
schema, entity = tool_input.split(",")
table_name, column_name = schema.split("->")
except ValueError:
return "Invalid input format, use following format: table_name -> column_name, entity (entity should be a string without ',')"
search_pattern = f"%{entity.strip().lower()}%"
meta = MetaData(bind=self.db.engine)
table = sqlalchemy.Table(table_name.strip(), meta, autoload=True)
try:
search_query = sqlalchemy.select(
[func.distinct(table.c[column_name.strip()])]
).where(func.lower(table.c[column_name.strip()]).like(search_pattern))
search_results = self.db.engine.execute(search_query).fetchall()
search_results = search_results[:25]
except SQLAlchemyError:
search_results = []
distinct_query = sqlalchemy.select(
[func.distinct(table.c[column_name.strip()])]
)
results = self.db.engine.execute(distinct_query).fetchall()
results = self.find_similar_strings(results, entity)
similar_items = "Similar items:\n"
already_added = {}
for item in results:
similar_items += f"{item[0]}\n"
already_added[item[0]] = True
if len(search_results) > 0:
for item in search_results:
if item[0] not in already_added:
similar_items += f"{item[0]}\n"
return similar_items
async def _arun(
self,
tool_input: str,
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("ColumnEntityChecker does not support async")
class SchemaSQLDatabaseTool(BaseSQLDatabaseTool, BaseTool):
"""Tool for getting schema of relevant tables."""
name = "DbRelevantTablesSchema"
description = """
Input: Comma-separated list of tables.
Output: Schema of the specified tables.
Use this tool to discover all columns of the relevant tables and identify potentially relevant columns.
Example Input: table1, table2, table3
"""
db_scan: List[TableDescription]
@catch_exceptions()
def _run(
self,
table_names: str,
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
"""Get the schema for tables in a comma-separated list."""
table_names_list = table_names.split(", ")
table_names_list = [
replace_unprocessable_characters(table_name)
for table_name in table_names_list
]
tables_schema = ""
for table in self.db_scan:
if table.table_name in table_names_list:
tables_schema += table.table_schema + "\n"
descriptions = []
if table.description is not None:
descriptions.append(
f"Table `{table.table_name}`: {table.description}\n"
)
for column in table.columns:
if column.description is not None:
descriptions.append(
f"Column `{column.name}`: {column.description}\n"
)
if len(descriptions) > 0:
tables_schema += f"/*\n{''.join(descriptions)}*/\n"
if tables_schema == "":
tables_schema += "Tables not found in the database"
return tables_schema
async def _arun(
self,
table_name: str,
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("SchemaSQLDatabaseTool does not support async")
class InfoRelevantColumns(BaseSQLDatabaseTool, BaseTool):
"""Tool for getting more information for potentially relevant columns"""
name = "DbRelevantColumnsInfo"
description = """
Input: Comma-separated list of potentially relevant columns with their corresponding table.
Output: Information about the values inside the columns and their descriptions.
Use this tool to gather details about potentially relevant columns. then, filter them, and identify the relevant ones.
Example Input: table1 -> column1, table1 -> column2, table2 -> column1
"""
db_scan: List[TableDescription]
@catch_exceptions()
def _run( # noqa: C901
self,
column_names: str,
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
"""Get the column level information."""
items_list = column_names.split(", ")
column_full_info = ""
for item in items_list:
if " -> " in item:
table_name, column_name = item.split(" -> ")
table_name = replace_unprocessable_characters(table_name)
column_name = replace_unprocessable_characters(column_name)
found = False
for table in self.db_scan:
if table_name == table.table_name:
col_info = ""
for column in table.columns:
if column_name == column.name:
found = True
col_info += f"Description: {column.description},"
if column.low_cardinality:
col_info += f" categories = {column.categories},"
col_info += " Sample rows: "
if found:
for row in table.examples:
col_info += row[column_name] + ", "
col_info = col_info[:-2]
column_full_info += f"Table: {table_name}, column: {column_name}, additional info: {col_info}\n"
else:
return "Malformed input, input should be in the following format Example Input: table1 -> column1, table1 -> column2, table2 -> column1" # noqa: E501
if not found:
column_full_info += f"Table: {table_name}, column: {column_name} not found in database\n"
return column_full_info
async def _arun(
self,
table_name: str,
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("InfoRelevantColumnsTool does not support async")
class GetFewShotExamples(BaseSQLDatabaseTool, BaseTool):
"""Tool to obtain few-shot examples from the pool of samples"""
name = "FewshotExamplesRetriever"
description = """
Input: Number of required Question/SQL pairs.
Output: List of similar Question/SQL pairs related to the given question.
Use this tool to fetch previously asked Question/SQL pairs as examples for improving SQL query generation.
For complex questions, request more examples to gain a better understanding of tables and columns and the SQL keywords to use.
If the given question is very similar to one of the retrieved examples, it is recommended to use the same SQL query and modify it slightly to fit the given question.
Always use this tool first and before any other tool!
""" # noqa: E501
few_shot_examples: List[dict]
@catch_exceptions()
def _run(
self,
number_of_samples: str,
run_manager: CallbackManagerForToolRun | None = None, # noqa: ARG002
) -> str:
"""Get the schema for tables in a comma-separated list."""
if number_of_samples.strip().isdigit():
number_of_samples = int(number_of_samples.strip())
else:
return "Action input for the fewshot_examples_retriever tool should be an integer"
returned_output = ""
for example in self.few_shot_examples[:number_of_samples]:
returned_output += (
f"Question: {example['prompt_text']} -> SQL: {example['sql']}\n"
)
if returned_output == "":
returned_output = "No previously asked Question/SQL pairs are available"
return returned_output
async def _arun(
self,
number_of_samples: str,
run_manager: AsyncCallbackManagerForToolRun | None = None,
) -> str:
raise NotImplementedError("GetFewShotExamplesTool does not support async")
class SQLDatabaseToolkit(BaseToolkit):
"""Dataherald toolkit"""
db: SQLDatabase = Field(exclude=True)
context: List[dict] | None = Field(exclude=True, default=None)
few_shot_examples: List[dict] | None = Field(exclude=True, default=None)
instructions: List[dict] | None = Field(exclude=True, default=None)
db_scan: List[TableDescription] = Field(exclude=True)
embedding: OpenAIEmbeddings = Field(exclude=True)
@property
def dialect(self) -> str:
"""Return string representation of SQL dialect to use."""
return self.db.dialect
class Config:
"""Configuration for this pydantic object."""
arbitrary_types_allowed = True
def get_tools(self) -> List[BaseTool]:
"""Get the tools in the toolkit."""
tools = []
query_sql_db_tool = QuerySQLDataBaseTool(db=self.db, context=self.context)
tools.append(query_sql_db_tool)
if self.instructions is not None:
tools.append(
GetUserInstructions(
db=self.db, context=self.context, instructions=self.instructions
)
)
get_current_datetime = SystemTime(db=self.db, context=self.context)
tools.append(get_current_datetime)
tables_sql_db_tool = TablesSQLDatabaseTool(
db=self.db,
context=self.context,
db_scan=self.db_scan,
embedding=self.embedding,
)
tools.append(tables_sql_db_tool)
schema_sql_db_tool = SchemaSQLDatabaseTool(
db=self.db, context=self.context, db_scan=self.db_scan
)
tools.append(schema_sql_db_tool)
info_relevant_tool = InfoRelevantColumns(
db=self.db, context=self.context, db_scan=self.db_scan
)
tools.append(info_relevant_tool)
column_sample_tool = ColumnEntityChecker(db=self.db, context=self.context)
tools.append(column_sample_tool)
if self.few_shot_examples is not None:
get_fewshot_examples_tool = GetFewShotExamples(
db=self.db,
context=self.context,
few_shot_examples=self.few_shot_examples,
)
tools.append(get_fewshot_examples_tool)
return tools
class DataheraldSQLAgent(SQLGenerator):
"""Dataherald SQL agent"""
max_number_of_examples: int = 5 # maximum number of question/SQL pairs
llm: Any = None
def remove_duplicate_examples(self, fewshot_exmaples: List[dict]) -> List[dict]:
returned_result = []
seen_list = []
for example in fewshot_exmaples:
if example["prompt_text"] not in seen_list:
seen_list.append(example["prompt_text"])
returned_result.append(example)
return returned_result
def create_sql_agent(
self,
toolkit: SQLDatabaseToolkit,
callback_manager: BaseCallbackManager | None = None,
prefix: str = AGENT_PREFIX,
suffix: str | None = None,
format_instructions: str = FORMAT_INSTRUCTIONS,
input_variables: List[str] | None = None,
max_examples: int = 20,
number_of_instructions: int = 1,
max_iterations: int
| None = int(os.getenv("AGENT_MAX_ITERATIONS", "15")), # noqa: B008
max_execution_time: float | None = None,
early_stopping_method: str = "generate",
verbose: bool = False,
agent_executor_kwargs: Dict[str, Any] | None = None,
**kwargs: Dict[str, Any],
) -> AgentExecutor:
"""Construct an SQL agent from an LLM and tools."""
tools = toolkit.get_tools()
if max_examples > 0 and number_of_instructions > 0:
plan = PLAN_WITH_FEWSHOT_EXAMPLES_AND_INSTRUCTIONS
suffix = SUFFIX_WITH_FEW_SHOT_SAMPLES
elif max_examples > 0:
plan = PLAN_WITH_FEWSHOT_EXAMPLES
suffix = SUFFIX_WITH_FEW_SHOT_SAMPLES
elif number_of_instructions > 0:
plan = PLAN_WITH_INSTRUCTIONS
suffix = SUFFIX_WITHOUT_FEW_SHOT_SAMPLES
else:
plan = PLAN_BASE
suffix = SUFFIX_WITHOUT_FEW_SHOT_SAMPLES
plan = plan.format(
dialect=toolkit.dialect,
max_examples=max_examples,
)
prefix = prefix.format(
dialect=toolkit.dialect, max_examples=max_examples, agent_plan=plan
)
prompt = ZeroShotAgent.create_prompt(
tools,
prefix=prefix,
suffix=suffix,
format_instructions=format_instructions,
input_variables=input_variables,
)
llm_chain = LLMChain(
llm=self.llm,
prompt=prompt,
callback_manager=callback_manager,
)
tool_names = [tool.name for tool in tools]
agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)
return AgentExecutor.from_agent_and_tools(
agent=agent,
tools=tools,
callback_manager=callback_manager,
verbose=verbose,
max_iterations=max_iterations,
max_execution_time=max_execution_time,
early_stopping_method=early_stopping_method,
**(agent_executor_kwargs or {}),
)
@override
def generate_response(
self,
user_prompt: Prompt,
database_connection: DatabaseConnection,
context: List[dict] = None,
) -> SQLGeneration:
context_store = self.system.instance(ContextStore)
storage = self.system.instance(DB)
response = SQLGeneration(
prompt_id=user_prompt.id,
llm_config=self.llm_config,
created_at=datetime.datetime.now(),
)
self.llm = self.model.get_model(
database_connection=database_connection,
temperature=0,
model_name=self.llm_config.llm_name,
api_base=self.llm_config.api_base,
)
repository = TableDescriptionRepository(storage)
db_scan = repository.get_all_tables_by_db(
{
"db_connection_id": str(database_connection.id),
"status": TableDescriptionStatus.SCANNED.value,
}
)
if not db_scan:
raise ValueError("No scanned tables found for database")
few_shot_examples, instructions = context_store.retrieve_context_for_question(
user_prompt, number_of_samples=self.max_number_of_examples
)
if few_shot_examples is not None:
new_fewshot_examples = self.remove_duplicate_examples(few_shot_examples)
number_of_samples = len(new_fewshot_examples)
else:
new_fewshot_examples = None
number_of_samples = 0
logger.info(f"Generating SQL response to question: {str(user_prompt.dict())}")
self.database = SQLDatabase.get_sql_engine(database_connection)
toolkit = SQLDatabaseToolkit(
db=self.database,
context=context,
few_shot_examples=new_fewshot_examples,
instructions=instructions,
db_scan=db_scan,
embedding=OpenAIEmbeddings(
openai_api_key=database_connection.decrypt_api_key(),
model=EMBEDDING_MODEL,
),
)
agent_executor = self.create_sql_agent(
toolkit=toolkit,
verbose=True,
max_examples=number_of_samples,
number_of_instructions=len(instructions) if instructions is not None else 0,
max_execution_time=int(os.environ.get("DH_ENGINE_TIMEOUT", 150)),
)
agent_executor.return_intermediate_steps = True
agent_executor.handle_parsing_errors = ERROR_PARSING_MESSAGE
with get_openai_callback() as cb:
try:
result = agent_executor.invoke({"input": user_prompt.text})
result = self.check_for_time_out_or_tool_limit(result)
except SQLInjectionError as e:
raise SQLInjectionError(e) from e
except EngineTimeOutORItemLimitError as e:
raise EngineTimeOutORItemLimitError(e) from e
except Exception as e:
return SQLGeneration(
prompt_id=user_prompt.id,
tokens_used=cb.total_tokens,
completed_at=datetime.datetime.now(),
sql="",
status="INVALID",
error=str(e),
)
sql_query = ""
if "```sql" in result["output"]:
sql_query = self.remove_markdown(result["output"])
else:
sql_query = self.extract_query_from_intermediate_steps(
result["intermediate_steps"]
)
logger.info(f"cost: {str(cb.total_cost)} tokens: {str(cb.total_tokens)}")
response.sql = replace_unprocessable_characters(sql_query)
response.tokens_used = cb.total_tokens
response.completed_at = datetime.datetime.now()
return self.create_sql_query_status(
self.database,
response.sql,
response,
)
@override
def stream_response(
self,
user_prompt: Prompt,
database_connection: DatabaseConnection,
response: SQLGeneration,
queue: Queue,
):
context_store = self.system.instance(ContextStore)
storage = self.system.instance(DB)
sql_generation_repository = SQLGenerationRepository(storage)
self.llm = self.model.get_model(
database_connection=database_connection,
temperature=0,
model_name=self.llm_config.llm_name,
api_base=self.llm_config.api_base,
streaming=True,
)
repository = TableDescriptionRepository(storage)
db_scan = repository.get_all_tables_by_db(
{
"db_connection_id": str(database_connection.id),
"status": TableDescriptionStatus.SCANNED.value,
}
)
if not db_scan:
raise ValueError("No scanned tables found for database")
few_shot_examples, instructions = context_store.retrieve_context_for_question(
user_prompt, number_of_samples=self.max_number_of_examples
)
if few_shot_examples is not None:
new_fewshot_examples = self.remove_duplicate_examples(few_shot_examples)
number_of_samples = len(new_fewshot_examples)
else:
new_fewshot_examples = None
number_of_samples = 0
self.database = SQLDatabase.get_sql_engine(database_connection)
toolkit = SQLDatabaseToolkit(
queuer=queue,
db=self.database,
context=[{}],
few_shot_examples=new_fewshot_examples,
instructions=instructions,
db_scan=db_scan,
embedding=OpenAIEmbeddings(
openai_api_key=database_connection.decrypt_api_key(),
model=EMBEDDING_MODEL,
),
)
agent_executor = self.create_sql_agent(
toolkit=toolkit,
verbose=True,
max_examples=number_of_samples,
number_of_instructions=len(instructions) if instructions is not None else 0,
max_execution_time=int(os.environ.get("DH_ENGINE_TIMEOUT", 150)),
)
agent_executor.return_intermediate_steps = True
agent_executor.handle_parsing_errors = ERROR_PARSING_MESSAGE
thread = Thread(
target=self.stream_agent_steps,
args=(
user_prompt.text,
agent_executor,
response,
sql_generation_repository,
queue,
),
)
thread.start()
| [
"langchain.agents.mrkl.base.ZeroShotAgent.create_prompt",
"langchain.agents.mrkl.base.ZeroShotAgent",
"langchain.agents.agent.AgentExecutor.from_agent_and_tools",
"langchain.chains.llm.LLMChain",
"langchain_community.callbacks.get_openai_callback"
] | [((2000, 2027), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (2017, 2027), False, 'import logging\n'), ((2038, 2074), 'dataherald.sql_generator.SQLGenerator.get_upper_bound_limit', 'SQLGenerator.get_upper_bound_limit', ([], {}), '()\n', (2072, 2074), False, 'from dataherald.sql_generator import EngineTimeOutORItemLimitError, SQLGenerator\n'), ((3869, 3888), 'pydantic.Field', 'Field', ([], {'exclude': '(True)'}), '(exclude=True)\n', (3874, 3888), False, 'from pydantic import BaseModel, Field\n'), ((3922, 3955), 'pydantic.Field', 'Field', ([], {'exclude': '(True)', 'default': 'None'}), '(exclude=True, default=None)\n', (3927, 3955), False, 'from pydantic import BaseModel, Field\n'), ((20062, 20081), 'pydantic.Field', 'Field', ([], {'exclude': '(True)'}), '(exclude=True)\n', (20067, 20081), False, 'from pydantic import BaseModel, Field\n'), ((20115, 20148), 'pydantic.Field', 'Field', ([], {'exclude': '(True)', 'default': 'None'}), '(exclude=True, default=None)\n', (20120, 20148), False, 'from pydantic import BaseModel, Field\n'), ((20192, 20225), 'pydantic.Field', 'Field', ([], {'exclude': '(True)', 'default': 'None'}), '(exclude=True, default=None)\n', (20197, 20225), False, 'from pydantic import BaseModel, Field\n'), ((20264, 20297), 'pydantic.Field', 'Field', ([], {'exclude': '(True)', 'default': 'None'}), '(exclude=True, default=None)\n', (20269, 20297), False, 'from pydantic import BaseModel, Field\n'), ((20336, 20355), 'pydantic.Field', 'Field', ([], {'exclude': '(True)'}), '(exclude=True)\n', (20341, 20355), False, 'from pydantic import BaseModel, Field\n'), ((20390, 20409), 'pydantic.Field', 'Field', ([], {'exclude': '(True)'}), '(exclude=True)\n', (20395, 20409), False, 'from pydantic import BaseModel, Field\n'), ((2266, 2275), 'functools.wraps', 'wraps', (['fn'], {}), '(fn)\n', (2271, 2275), False, 'from functools import wraps\n'), ((4731, 4754), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (4752, 4754), False, 'import datetime\n'), ((9562, 9649), 'pandas.DataFrame', 'pd.DataFrame', (['table_representations'], {'columns': "['table_name', 'table_representation']"}), "(table_representations, columns=['table_name',\n 'table_representation'])\n", (9574, 9649), True, 'import pandas as pd\n'), ((11971, 12000), 'sqlalchemy.MetaData', 'MetaData', ([], {'bind': 'self.db.engine'}), '(bind=self.db.engine)\n', (11979, 12000), False, 'from sqlalchemy import MetaData\n'), ((24413, 24555), 'langchain.agents.mrkl.base.ZeroShotAgent.create_prompt', 'ZeroShotAgent.create_prompt', (['tools'], {'prefix': 'prefix', 'suffix': 'suffix', 'format_instructions': 'format_instructions', 'input_variables': 'input_variables'}), '(tools, prefix=prefix, suffix=suffix,\n format_instructions=format_instructions, input_variables=input_variables)\n', (24440, 24555), False, 'from langchain.agents.mrkl.base import ZeroShotAgent\n'), ((24643, 24715), 'langchain.chains.llm.LLMChain', 'LLMChain', ([], {'llm': 'self.llm', 'prompt': 'prompt', 'callback_manager': 'callback_manager'}), '(llm=self.llm, prompt=prompt, callback_manager=callback_manager)\n', (24651, 24715), False, 'from langchain.chains.llm import LLMChain\n'), ((24830, 24900), 'langchain.agents.mrkl.base.ZeroShotAgent', 'ZeroShotAgent', ([], {'llm_chain': 'llm_chain', 'allowed_tools': 'tool_names'}), '(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)\n', (24843, 24900), False, 'from langchain.agents.mrkl.base import ZeroShotAgent\n'), ((24916, 25187), 'langchain.agents.agent.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'agent', 'tools': 'tools', 'callback_manager': 'callback_manager', 'verbose': 'verbose', 'max_iterations': 'max_iterations', 'max_execution_time': 'max_execution_time', 'early_stopping_method': 'early_stopping_method'}), '(agent=agent, tools=tools,\n callback_manager=callback_manager, verbose=verbose, max_iterations=\n max_iterations, max_execution_time=max_execution_time,\n early_stopping_method=early_stopping_method, **agent_executor_kwargs or {})\n', (24950, 25187), False, 'from langchain.agents.agent import AgentExecutor\n'), ((25998, 26033), 'dataherald.db_scanner.repository.base.TableDescriptionRepository', 'TableDescriptionRepository', (['storage'], {}), '(storage)\n', (26024, 26033), False, 'from dataherald.db_scanner.repository.base import TableDescriptionRepository\n'), ((26897, 26944), 'dataherald.sql_database.base.SQLDatabase.get_sql_engine', 'SQLDatabase.get_sql_engine', (['database_connection'], {}), '(database_connection)\n', (26923, 26944), False, 'from dataherald.sql_database.base import SQLDatabase, SQLInjectionError\n'), ((29041, 29064), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (29062, 29064), False, 'import datetime\n'), ((29527, 29559), 'dataherald.repositories.sql_generations.SQLGenerationRepository', 'SQLGenerationRepository', (['storage'], {}), '(storage)\n', (29550, 29559), False, 'from dataherald.repositories.sql_generations import SQLGenerationRepository\n'), ((29836, 29871), 'dataherald.db_scanner.repository.base.TableDescriptionRepository', 'TableDescriptionRepository', (['storage'], {}), '(storage)\n', (29862, 29871), False, 'from dataherald.db_scanner.repository.base import TableDescriptionRepository\n'), ((30648, 30695), 'dataherald.sql_database.base.SQLDatabase.get_sql_engine', 'SQLDatabase.get_sql_engine', (['database_connection'], {}), '(database_connection)\n', (30674, 30695), False, 'from dataherald.sql_database.base import SQLDatabase, SQLInjectionError\n'), ((31576, 31703), 'threading.Thread', 'Thread', ([], {'target': 'self.stream_agent_steps', 'args': '(user_prompt.text, agent_executor, response, sql_generation_repository, queue)'}), '(target=self.stream_agent_steps, args=(user_prompt.text,\n agent_executor, response, sql_generation_repository, queue))\n', (31582, 31703), False, 'from threading import Thread\n'), ((23228, 23267), 'os.getenv', 'os.getenv', (['"""AGENT_MAX_ITERATIONS"""', '"""15"""'], {}), "('AGENT_MAX_ITERATIONS', '15')\n", (23237, 23267), False, 'import os\n'), ((27798, 27819), 'langchain_community.callbacks.get_openai_callback', 'get_openai_callback', ([], {}), '()\n', (27817, 27819), False, 'from langchain_community.callbacks import get_openai_callback\n'), ((8452, 8464), 'numpy.dot', 'np.dot', (['a', 'b'], {}), '(a, b)\n', (8458, 8464), True, 'import numpy as np\n'), ((25715, 25738), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (25736, 25738), False, 'import datetime\n'), ((8468, 8485), 'numpy.linalg.norm', 'np.linalg.norm', (['a'], {}), '(a)\n', (8482, 8485), True, 'import numpy as np\n'), ((8488, 8505), 'numpy.linalg.norm', 'np.linalg.norm', (['b'], {}), '(b)\n', (8502, 8505), True, 'import numpy as np\n'), ((27607, 27647), 'os.environ.get', 'os.environ.get', (['"""DH_ENGINE_TIMEOUT"""', '(150)'], {}), "('DH_ENGINE_TIMEOUT', 150)\n", (27621, 27647), False, 'import os\n'), ((28056, 28076), 'dataherald.sql_database.base.SQLInjectionError', 'SQLInjectionError', (['e'], {}), '(e)\n', (28073, 28076), False, 'from dataherald.sql_database.base import SQLDatabase, SQLInjectionError\n'), ((28161, 28193), 'dataherald.sql_generator.EngineTimeOutORItemLimitError', 'EngineTimeOutORItemLimitError', (['e'], {}), '(e)\n', (28190, 28193), False, 'from dataherald.sql_generator import EngineTimeOutORItemLimitError, SQLGenerator\n'), ((31381, 31421), 'os.environ.get', 'os.environ.get', (['"""DH_ENGINE_TIMEOUT"""', '(150)'], {}), "('DH_ENGINE_TIMEOUT', 150)\n", (31395, 31421), False, 'import os\n'), ((6019, 6059), 'os.getenv', 'os.getenv', (['"""SQL_EXECUTION_TIMEOUT"""', '"""60"""'], {}), "('SQL_EXECUTION_TIMEOUT', '60')\n", (6028, 6059), False, 'import os\n'), ((28402, 28425), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (28423, 28425), False, 'import datetime\n')] |
from marqo import Client
import pandas as pd
import numpy as np
from langchain_openai import OpenAI
from langchain.docstore.document import Document
from langchain.chains import LLMChain
from dotenv import load_dotenv
from utilities import (
load_data,
extract_text_from_highlights,
qna_prompt,
predict_ce,
get_sorted_inds
)
load_dotenv()
if __name__ == "__main__":
#############################################################
# STEP 0: Install Marqo
#############################################################
# run the following docker commands from the terminal to start marqo
# docker rm -f marqo
# docker pull marqoai/marqo:2.0.0
# docker run --name marqo -it -p 8882:8882 --add-host host.docker.internal:host-gateway marqoai/marqo:2.0.0
#############################################################
# STEP 1: Setup Marqo
#############################################################
mq = Client()
index_name = "iron-docs"
# (optinally) delete if it already exists
try:
mq.index(index_name).delete()
except:
pass
# we can set some specific settings for the index. if they are not provided, sensible defaults are used
index_settings = {
"model": "flax-sentence-embeddings/all_datasets_v4_MiniLM-L6",
"normalizeEmbeddings": True,
"textPreprocessing": {
"splitLength": 3,
"splitOverlap": 1,
"splitMethod": "sentence"
},
}
# create the index with custom settings
mq.create_index(index_name, settings_dict=index_settings)
#############################################################
# STEP 2: Load the data
#############################################################
df = load_data()
# turn the data into a dict for indexing
documents = df.to_dict(orient='records')
#############################################################
# STEP 3: Index the data
#############################################################
# index the documents
indexing = mq.index(index_name).add_documents(documents, tensor_fields=["cleaned_text"], client_batch_size=64)
#############################################################
# STEP 4: Search the data
#############################################################
# try a generic search
q = "what is the rated voltage"
results = mq.index(index_name).search(q)
print(results['hits'][0])
#############################################################
# STEP 5: Make it chatty
#############################################################
highlights, texts = extract_text_from_highlights(results, token_limit=150)
docs = [Document(page_content=f"Source [{ind}]:" + t) for ind, t in enumerate(texts)]
llm = OpenAI(temperature=0.9)
chain_qa = LLMChain(llm=llm, prompt=qna_prompt())
llm_results = chain_qa.invoke({"summaries": docs, "question": results['query']}, return_only_outputs=True)
print(llm_results['text'])
#############################################################
# STEP 6: Score the references
#############################################################
score_threshold = 0.20
top_k = 3
scores = predict_ce(llm_results['text'], texts)
inds = get_sorted_inds(scores)
scores = scores.cpu().numpy()
scores = [np.round(s[0], 2) for s in scores]
references = [(str(np.round(scores[i], 2)), texts[i]) for i in inds[:top_k] if scores[i] > score_threshold]
df_ref = pd.DataFrame(references, columns=['score', 'sources'])
print(df_ref)
| [
"langchain_openai.OpenAI",
"langchain.docstore.document.Document"
] | [((349, 362), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (360, 362), False, 'from dotenv import load_dotenv\n'), ((984, 992), 'marqo.Client', 'Client', ([], {}), '()\n', (990, 992), False, 'from marqo import Client\n'), ((1812, 1823), 'utilities.load_data', 'load_data', ([], {}), '()\n', (1821, 1823), False, 'from utilities import load_data, extract_text_from_highlights, qna_prompt, predict_ce, get_sorted_inds\n'), ((2727, 2781), 'utilities.extract_text_from_highlights', 'extract_text_from_highlights', (['results'], {'token_limit': '(150)'}), '(results, token_limit=150)\n', (2755, 2781), False, 'from utilities import load_data, extract_text_from_highlights, qna_prompt, predict_ce, get_sorted_inds\n'), ((2882, 2905), 'langchain_openai.OpenAI', 'OpenAI', ([], {'temperature': '(0.9)'}), '(temperature=0.9)\n', (2888, 2905), False, 'from langchain_openai import OpenAI\n'), ((3331, 3369), 'utilities.predict_ce', 'predict_ce', (["llm_results['text']", 'texts'], {}), "(llm_results['text'], texts)\n", (3341, 3369), False, 'from utilities import load_data, extract_text_from_highlights, qna_prompt, predict_ce, get_sorted_inds\n'), ((3381, 3404), 'utilities.get_sorted_inds', 'get_sorted_inds', (['scores'], {}), '(scores)\n', (3396, 3404), False, 'from utilities import load_data, extract_text_from_highlights, qna_prompt, predict_ce, get_sorted_inds\n'), ((3613, 3667), 'pandas.DataFrame', 'pd.DataFrame', (['references'], {'columns': "['score', 'sources']"}), "(references, columns=['score', 'sources'])\n", (3625, 3667), True, 'import pandas as pd\n'), ((2794, 2839), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': "(f'Source [{ind}]:' + t)"}), "(page_content=f'Source [{ind}]:' + t)\n", (2802, 2839), False, 'from langchain.docstore.document import Document\n'), ((3453, 3470), 'numpy.round', 'np.round', (['s[0]', '(2)'], {}), '(s[0], 2)\n', (3461, 3470), True, 'import numpy as np\n'), ((2946, 2958), 'utilities.qna_prompt', 'qna_prompt', ([], {}), '()\n', (2956, 2958), False, 'from utilities import load_data, extract_text_from_highlights, qna_prompt, predict_ce, get_sorted_inds\n'), ((3511, 3533), 'numpy.round', 'np.round', (['scores[i]', '(2)'], {}), '(scores[i], 2)\n', (3519, 3533), True, 'import numpy as np\n')] |
from typing import List, Optional
from langchain.schema.language_model import BaseLanguageModel
from server.knowledge_base.model.kb_document_model import DocumentWithVSId
from configs import (logger)
from langchain.chains import StuffDocumentsChain, LLMChain
from langchain.prompts import PromptTemplate
from langchain.docstore.document import Document
from langchain.output_parsers.regex import RegexParser
from langchain.chains.combine_documents.map_reduce import ReduceDocumentsChain, MapReduceDocumentsChain
import sys
import asyncio
class SummaryAdapter:
_OVERLAP_SIZE: int
token_max: int
_separator: str = "\n\n"
chain: MapReduceDocumentsChain
def __init__(self, overlap_size: int, token_max: int,
chain: MapReduceDocumentsChain):
self._OVERLAP_SIZE = overlap_size
self.chain = chain
self.token_max = token_max
@classmethod
def form_summary(cls,
llm: BaseLanguageModel,
reduce_llm: BaseLanguageModel,
overlap_size: int,
token_max: int = 1300):
"""
获取实例
:param reduce_llm: 用于合并摘要的llm
:param llm: 用于生成摘要的llm
:param overlap_size: 重叠部分大小
:param token_max: 最大的chunk数量，每个chunk长度小于token_max长度，第一次生成摘要时，大于token_max长度的摘要会报错
:return:
"""
# This controls how each document will be formatted. Specifically,
document_prompt = PromptTemplate(
input_variables=["page_content"],
template="{page_content}"
)
# The prompt here should take as an input variable the
# `document_variable_name`
prompt_template = (
"根据文本执行任务。以下任务信息"
"{task_briefing}"
"文本内容如下: "
"\r\n"
"{context}"
)
prompt = PromptTemplate(
template=prompt_template,
input_variables=["task_briefing", "context"]
)
llm_chain = LLMChain(llm=llm, prompt=prompt)
# We now define how to combine these summaries
reduce_prompt = PromptTemplate.from_template(
"Combine these summaries: {context}"
)
reduce_llm_chain = LLMChain(llm=reduce_llm, prompt=reduce_prompt)
document_variable_name = "context"
combine_documents_chain = StuffDocumentsChain(
llm_chain=reduce_llm_chain,
document_prompt=document_prompt,
document_variable_name=document_variable_name
)
reduce_documents_chain = ReduceDocumentsChain(
token_max=token_max,
combine_documents_chain=combine_documents_chain,
)
chain = MapReduceDocumentsChain(
llm_chain=llm_chain,
document_variable_name=document_variable_name,
reduce_documents_chain=reduce_documents_chain,
# 返回中间步骤
return_intermediate_steps=True
)
return cls(overlap_size=overlap_size,
chain=chain,
token_max=token_max)
def summarize(self,
file_description: str,
docs: List[DocumentWithVSId] = []
) -> List[Document]:
if sys.version_info < (3, 10):
loop = asyncio.get_event_loop()
else:
try:
loop = asyncio.get_running_loop()
except RuntimeError:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
# 同步调用协程代码
return loop.run_until_complete(self.asummarize(file_description=file_description,
docs=docs))
async def asummarize(self,
file_description: str,
docs: List[DocumentWithVSId] = []) -> List[Document]:
logger.info("start summary")
# TODO 暂不处理文档中涉及语义重复、上下文缺失、document was longer than the context length 的问题
# merge_docs = self._drop_overlap(docs)
# # 将merge_docs中的句子合并成一个文档
# text = self._join_docs(merge_docs)
# 根据段落于句子的分隔符，将文档分成chunk，每个chunk长度小于token_max长度
"""
这个过程分成两个部分：
1. 对每个文档进行处理，得到每个文档的摘要
map_results = self.llm_chain.apply(
# FYI - this is parallelized and so it is fast.
[{self.document_variable_name: d.page_content, **kwargs} for d in docs],
callbacks=callbacks,
)
2. 对每个文档的摘要进行合并，得到最终的摘要，return_intermediate_steps=True，返回中间步骤
result, extra_return_dict = self.reduce_documents_chain.combine_docs(
result_docs, token_max=token_max, callbacks=callbacks, **kwargs
)
"""
summary_combine, summary_intermediate_steps = self.chain.combine_docs(docs=docs,
task_briefing="描述不同方法之间的接近度和相似性，"
"以帮助读者理解它们之间的关系。")
print(summary_combine)
print(summary_intermediate_steps)
# if len(summary_combine) == 0:
# # 为空重新生成，数量减半
# result_docs = [
# Document(page_content=question_result_key, metadata=docs[i].metadata)
# # This uses metadata from the docs, and the textual results from `results`
# for i, question_result_key in enumerate(
# summary_intermediate_steps["intermediate_steps"][
# :len(summary_intermediate_steps["intermediate_steps"]) // 2
# ])
# ]
# summary_combine, summary_intermediate_steps = self.chain.reduce_documents_chain.combine_docs(
# result_docs, token_max=self.token_max
# )
logger.info("end summary")
doc_ids = ",".join([doc.id for doc in docs])
_metadata = {
"file_description": file_description,
"summary_intermediate_steps": summary_intermediate_steps,
"doc_ids": doc_ids
}
summary_combine_doc = Document(page_content=summary_combine, metadata=_metadata)
return [summary_combine_doc]
def _drop_overlap(self, docs: List[DocumentWithVSId]) -> List[str]:
"""
# 将文档中page_content句子叠加的部分去掉
:param docs:
:param separator:
:return:
"""
merge_docs = []
pre_doc = None
for doc in docs:
# 第一个文档直接添加
if len(merge_docs) == 0:
pre_doc = doc.page_content
merge_docs.append(doc.page_content)
continue
# 列表中上一个结尾与下一个开头重叠的部分，删除下一个开头重叠的部分
# 迭代递减pre_doc的长度，每次迭代删除前面的字符，
# 查询重叠部分，直到pre_doc的长度小于 self._OVERLAP_SIZE // 2 - 2len(separator)
for i in range(len(pre_doc), self._OVERLAP_SIZE // 2 - 2 * len(self._separator), -1):
# 每次迭代删除前面的字符
pre_doc = pre_doc[1:]
if doc.page_content[:len(pre_doc)] == pre_doc:
# 删除下一个开头重叠的部分
merge_docs.append(doc.page_content[len(pre_doc):])
break
pre_doc = doc.page_content
return merge_docs
def _join_docs(self, docs: List[str]) -> Optional[str]:
text = self._separator.join(docs)
text = text.strip()
if text == "":
return None
else:
return text
if __name__ == '__main__':
docs = [
'梦者有特别的作用，也就是说梦是在预卜未来。因此，梦内容的',
'梦内容的多彩多姿以及对梦者本身所遗留的特殊印象，使他们很难想象',
'使他们很难想象出一套系统划一的观念，而需要以其个别的价值与可靠性作各',
'值与可靠性作各种不同的分化与聚合。因此，古代哲学家们对梦的评价也就完全'
]
_OVERLAP_SIZE = 1
separator: str = "\n\n"
merge_docs = []
# 将文档中page_content句子叠加的部分去掉，
# 列表中上一个结尾与下一个开头重叠的部分，删除下一个开头重叠的部分
pre_doc = None
for doc in docs:
# 第一个文档直接添加
if len(merge_docs) == 0:
pre_doc = doc
merge_docs.append(doc)
continue
# 列表中上一个结尾与下一个开头重叠的部分，删除下一个开头重叠的部分
# 迭代递减pre_doc的长度，每次迭代删除前面的字符，
# 查询重叠部分，直到pre_doc的长度小于 _OVERLAP_SIZE-2len(separator)
for i in range(len(pre_doc), _OVERLAP_SIZE - 2 * len(separator), -1):
# 每次迭代删除前面的字符
pre_doc = pre_doc[1:]
if doc[:len(pre_doc)] == pre_doc:
# 删除下一个开头重叠的部分
page_content = doc[len(pre_doc):]
merge_docs.append(page_content)
pre_doc = doc
break
# 将merge_docs中的句子合并成一个文档
text = separator.join(merge_docs)
text = text.strip()
print(text)
| [
"langchain.chains.combine_documents.map_reduce.MapReduceDocumentsChain",
"langchain.docstore.document.Document",
"langchain.chains.LLMChain",
"langchain.prompts.PromptTemplate.from_template",
"langchain.chains.StuffDocumentsChain",
"langchain.prompts.PromptTemplate",
"langchain.chains.combine_documents.map_reduce.ReduceDocumentsChain"
] | [((1461, 1536), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['page_content']", 'template': '"""{page_content}"""'}), "(input_variables=['page_content'], template='{page_content}')\n", (1475, 1536), False, 'from langchain.prompts import PromptTemplate\n'), ((1853, 1943), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'prompt_template', 'input_variables': "['task_briefing', 'context']"}), "(template=prompt_template, input_variables=['task_briefing',\n 'context'])\n", (1867, 1943), False, 'from langchain.prompts import PromptTemplate\n'), ((1994, 2026), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (2002, 2026), False, 'from langchain.chains import StuffDocumentsChain, LLMChain\n'), ((2106, 2172), 'langchain.prompts.PromptTemplate.from_template', 'PromptTemplate.from_template', (['"""Combine these summaries: {context}"""'], {}), "('Combine these summaries: {context}')\n", (2134, 2172), False, 'from langchain.prompts import PromptTemplate\n'), ((2222, 2268), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'reduce_llm', 'prompt': 'reduce_prompt'}), '(llm=reduce_llm, prompt=reduce_prompt)\n', (2230, 2268), False, 'from langchain.chains import StuffDocumentsChain, LLMChain\n'), ((2347, 2479), 'langchain.chains.StuffDocumentsChain', 'StuffDocumentsChain', ([], {'llm_chain': 'reduce_llm_chain', 'document_prompt': 'document_prompt', 'document_variable_name': 'document_variable_name'}), '(llm_chain=reduce_llm_chain, document_prompt=\n document_prompt, document_variable_name=document_variable_name)\n', (2366, 2479), False, 'from langchain.chains import StuffDocumentsChain, LLMChain\n'), ((2554, 2649), 'langchain.chains.combine_documents.map_reduce.ReduceDocumentsChain', 'ReduceDocumentsChain', ([], {'token_max': 'token_max', 'combine_documents_chain': 'combine_documents_chain'}), '(token_max=token_max, combine_documents_chain=\n combine_documents_chain)\n', (2574, 2649), False, 'from langchain.chains.combine_documents.map_reduce import ReduceDocumentsChain, MapReduceDocumentsChain\n'), ((2696, 2875), 'langchain.chains.combine_documents.map_reduce.MapReduceDocumentsChain', 'MapReduceDocumentsChain', ([], {'llm_chain': 'llm_chain', 'document_variable_name': 'document_variable_name', 'reduce_documents_chain': 'reduce_documents_chain', 'return_intermediate_steps': '(True)'}), '(llm_chain=llm_chain, document_variable_name=\n document_variable_name, reduce_documents_chain=reduce_documents_chain,\n return_intermediate_steps=True)\n', (2719, 2875), False, 'from langchain.chains.combine_documents.map_reduce import ReduceDocumentsChain, MapReduceDocumentsChain\n'), ((3853, 3881), 'configs.logger.info', 'logger.info', (['"""start summary"""'], {}), "('start summary')\n", (3864, 3881), False, 'from configs import logger\n'), ((5799, 5825), 'configs.logger.info', 'logger.info', (['"""end summary"""'], {}), "('end summary')\n", (5810, 5825), False, 'from configs import logger\n'), ((6092, 6150), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'summary_combine', 'metadata': '_metadata'}), '(page_content=summary_combine, metadata=_metadata)\n', (6100, 6150), False, 'from langchain.docstore.document import Document\n'), ((3280, 3304), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (3302, 3304), False, 'import asyncio\n'), ((3480, 3508), 'asyncio.set_event_loop', 'asyncio.set_event_loop', (['loop'], {}), '(loop)\n', (3502, 3508), False, 'import asyncio\n'), ((3359, 3385), 'asyncio.get_running_loop', 'asyncio.get_running_loop', ([], {}), '()\n', (3383, 3385), False, 'import asyncio\n'), ((3442, 3466), 'asyncio.new_event_loop', 'asyncio.new_event_loop', ([], {}), '()\n', (3464, 3466), False, 'import asyncio\n')] |
from fastapi import FastAPI, Form, Request, Response, File, Depends, HTTPException, status
from fastapi.responses import RedirectResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from fastapi.encoders import jsonable_encoder
from langchain.llms import CTransformers
from langchain.chains import QAGenerationChain
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.docstore.document import Document
from langchain.document_loaders import PyPDFLoader
from langchain.prompts import PromptTemplate
from langchain.embeddings import HuggingFaceBgeEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains.summarize import load_summarize_chain
from langchain.chains import RetrievalQA
import os
import json
import time
import uvicorn
import aiofiles
from PyPDF2 import PdfReader
import csv
app = FastAPI()
app.mount("/static", StaticFiles(directory="static"), name="static")
templates = Jinja2Templates(directory="templates")
def load_llm():
# Load the locally downloaded model here
llm = CTransformers(
model = "mistral-7b-instruct-v0.1.Q4_K_S.gguf",
model_type="mistral",
max_new_tokens = 1048,
temperature = 0.3
)
return llm
def file_processing(file_path):
# Load data from PDF
loader = PyPDFLoader(file_path)
data = loader.load()
question_gen = ''
for page in data:
question_gen += page.page_content
splitter_ques_gen = RecursiveCharacterTextSplitter(
chunk_size = 1000,
chunk_overlap = 100
)
chunks_ques_gen = splitter_ques_gen.split_text(question_gen)
document_ques_gen = [Document(page_content=t) for t in chunks_ques_gen]
splitter_ans_gen = RecursiveCharacterTextSplitter(
chunk_size = 300,
chunk_overlap = 30
)
document_answer_gen = splitter_ans_gen.split_documents(
document_ques_gen
)
return document_ques_gen, document_answer_gen
def llm_pipeline(file_path):
document_ques_gen, document_answer_gen = file_processing(file_path)
llm_ques_gen_pipeline = load_llm()
prompt_template = """
You are an expert at creating questions based on coding materials and documentation.
Your goal is to prepare a coder or programmer for their exam and coding tests.
You do this by asking questions about the text below:
------------
{text}
------------
Create questions that will prepare the coders or programmers for their tests.
Make sure not to lose any important information.
QUESTIONS:
"""
PROMPT_QUESTIONS = PromptTemplate(template=prompt_template, input_variables=["text"])
refine_template = ("""
You are an expert at creating practice questions based on coding material and documentation.
Your goal is to help a coder or programmer prepare for a coding test.
We have received some practice questions to a certain extent: {existing_answer}.
We have the option to refine the existing questions or add new ones.
(only if necessary) with some more context below.
------------
{text}
------------
Given the new context, refine the original questions in English.
If the context is not helpful, please provide the original questions.
QUESTIONS:
"""
)
REFINE_PROMPT_QUESTIONS = PromptTemplate(
input_variables=["existing_answer", "text"],
template=refine_template,
)
ques_gen_chain = load_summarize_chain(llm = llm_ques_gen_pipeline,
chain_type = "refine",
verbose = True,
question_prompt=PROMPT_QUESTIONS,
refine_prompt=REFINE_PROMPT_QUESTIONS)
ques = ques_gen_chain.run(document_ques_gen)
embeddings = HuggingFaceBgeEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
vector_store = FAISS.from_documents(document_answer_gen, embeddings)
llm_answer_gen = load_llm()
ques_list = ques.split("\n")
filtered_ques_list = [element for element in ques_list if element.endswith('?') or element.endswith('.')]
answer_generation_chain = RetrievalQA.from_chain_type(llm=llm_answer_gen,
chain_type="stuff",
retriever=vector_store.as_retriever())
return answer_generation_chain, filtered_ques_list
def get_csv (file_path):
answer_generation_chain, ques_list = llm_pipeline(file_path)
base_folder = 'static/output/'
if not os.path.isdir(base_folder):
os.mkdir(base_folder)
output_file = base_folder+"QA.csv"
with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
csv_writer = csv.writer(csvfile)
csv_writer.writerow(["Question", "Answer"]) # Writing the header row
for question in ques_list:
print("Question: ", question)
answer = answer_generation_chain.run(question)
print("Answer: ", answer)
print("--------------------------------------------------\n\n")
# Save answer to CSV file
csv_writer.writerow([question, answer])
return output_file
@app.get("/")
async def index(request: Request):
return templates.TemplateResponse("index.html", {"request": request})
@app.post("/upload")
async def chat(request: Request, pdf_file: bytes = File(), filename: str = Form(...)):
base_folder = 'static/docs/'
if not os.path.isdir(base_folder):
os.mkdir(base_folder)
pdf_filename = os.path.join(base_folder, filename)
async with aiofiles.open(pdf_filename, 'wb') as f:
await f.write(pdf_file)
response_data = jsonable_encoder(json.dumps({"msg": 'success',"pdf_filename": pdf_filename}))
res = Response(response_data)
return res
@app.post("/analyze")
async def chat(request: Request, pdf_filename: str = Form(...)):
output_file = get_csv(pdf_filename)
response_data = jsonable_encoder(json.dumps({"output_file": output_file}))
res = Response(response_data)
return res
if __name__ == "__main__":
uvicorn.run("app:app", host='0.0.0.0', port=8000, reload=True) | [
"langchain.chains.summarize.load_summarize_chain",
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.embeddings.HuggingFaceBgeEmbeddings",
"langchain.docstore.document.Document",
"langchain.llms.CTransformers",
"langchain.vectorstores.FAISS.from_documents",
"langchain.document_loaders.PyPDFLoader",
"langchain.prompts.PromptTemplate"
] | [((911, 920), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (918, 920), False, 'from fastapi import FastAPI, Form, Request, Response, File, Depends, HTTPException, status\n'), ((1008, 1046), 'fastapi.templating.Jinja2Templates', 'Jinja2Templates', ([], {'directory': '"""templates"""'}), "(directory='templates')\n", (1023, 1046), False, 'from fastapi.templating import Jinja2Templates\n'), ((945, 976), 'fastapi.staticfiles.StaticFiles', 'StaticFiles', ([], {'directory': '"""static"""'}), "(directory='static')\n", (956, 976), False, 'from fastapi.staticfiles import StaticFiles\n'), ((1123, 1247), 'langchain.llms.CTransformers', 'CTransformers', ([], {'model': '"""mistral-7b-instruct-v0.1.Q4_K_S.gguf"""', 'model_type': '"""mistral"""', 'max_new_tokens': '(1048)', 'temperature': '(0.3)'}), "(model='mistral-7b-instruct-v0.1.Q4_K_S.gguf', model_type=\n 'mistral', max_new_tokens=1048, temperature=0.3)\n", (1136, 1247), False, 'from langchain.llms import CTransformers\n'), ((1385, 1407), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['file_path'], {}), '(file_path)\n', (1396, 1407), False, 'from langchain.document_loaders import PyPDFLoader\n'), ((1562, 1628), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(100)'}), '(chunk_size=1000, chunk_overlap=100)\n', (1592, 1628), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1831, 1895), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(300)', 'chunk_overlap': '(30)'}), '(chunk_size=300, chunk_overlap=30)\n', (1861, 1895), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((2734, 2800), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'prompt_template', 'input_variables': "['text']"}), "(template=prompt_template, input_variables=['text'])\n", (2748, 2800), False, 'from langchain.prompts import PromptTemplate\n'), ((3479, 3569), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['existing_answer', 'text']", 'template': 'refine_template'}), "(input_variables=['existing_answer', 'text'], template=\n refine_template)\n", (3493, 3569), False, 'from langchain.prompts import PromptTemplate\n'), ((3615, 3779), 'langchain.chains.summarize.load_summarize_chain', 'load_summarize_chain', ([], {'llm': 'llm_ques_gen_pipeline', 'chain_type': '"""refine"""', 'verbose': '(True)', 'question_prompt': 'PROMPT_QUESTIONS', 'refine_prompt': 'REFINE_PROMPT_QUESTIONS'}), "(llm=llm_ques_gen_pipeline, chain_type='refine',\n verbose=True, question_prompt=PROMPT_QUESTIONS, refine_prompt=\n REFINE_PROMPT_QUESTIONS)\n", (3635, 3779), False, 'from langchain.chains.summarize import load_summarize_chain\n'), ((4033, 4111), 'langchain.embeddings.HuggingFaceBgeEmbeddings', 'HuggingFaceBgeEmbeddings', ([], {'model_name': '"""sentence-transformers/all-mpnet-base-v2"""'}), "(model_name='sentence-transformers/all-mpnet-base-v2')\n", (4057, 4111), False, 'from langchain.embeddings import HuggingFaceBgeEmbeddings\n'), ((4134, 4187), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['document_answer_gen', 'embeddings'], {}), '(document_answer_gen, embeddings)\n', (4154, 4187), False, 'from langchain.vectorstores import FAISS\n'), ((5686, 5692), 'fastapi.File', 'File', ([], {}), '()\n', (5690, 5692), False, 'from fastapi import FastAPI, Form, Request, Response, File, Depends, HTTPException, status\n'), ((5710, 5719), 'fastapi.Form', 'Form', (['...'], {}), '(...)\n', (5714, 5719), False, 'from fastapi import FastAPI, Form, Request, Response, File, Depends, HTTPException, status\n'), ((5847, 5882), 'os.path.join', 'os.path.join', (['base_folder', 'filename'], {}), '(base_folder, filename)\n', (5859, 5882), False, 'import os\n'), ((6084, 6107), 'fastapi.Response', 'Response', (['response_data'], {}), '(response_data)\n', (6092, 6107), False, 'from fastapi import FastAPI, Form, Request, Response, File, Depends, HTTPException, status\n'), ((6205, 6214), 'fastapi.Form', 'Form', (['...'], {}), '(...)\n', (6209, 6214), False, 'from fastapi import FastAPI, Form, Request, Response, File, Depends, HTTPException, status\n'), ((6349, 6372), 'fastapi.Response', 'Response', (['response_data'], {}), '(response_data)\n', (6357, 6372), False, 'from fastapi import FastAPI, Form, Request, Response, File, Depends, HTTPException, status\n'), ((6424, 6486), 'uvicorn.run', 'uvicorn.run', (['"""app:app"""'], {'host': '"""0.0.0.0"""', 'port': '(8000)', 'reload': '(True)'}), "('app:app', host='0.0.0.0', port=8000, reload=True)\n", (6435, 6486), False, 'import uvicorn\n'), ((1754, 1778), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 't'}), '(page_content=t)\n', (1762, 1778), False, 'from langchain.docstore.document import Document\n'), ((4812, 4838), 'os.path.isdir', 'os.path.isdir', (['base_folder'], {}), '(base_folder)\n', (4825, 4838), False, 'import os\n'), ((4849, 4870), 'os.mkdir', 'os.mkdir', (['base_folder'], {}), '(base_folder)\n', (4857, 4870), False, 'import os\n'), ((5008, 5027), 'csv.writer', 'csv.writer', (['csvfile'], {}), '(csvfile)\n', (5018, 5027), False, 'import csv\n'), ((5768, 5794), 'os.path.isdir', 'os.path.isdir', (['base_folder'], {}), '(base_folder)\n', (5781, 5794), False, 'import os\n'), ((5805, 5826), 'os.mkdir', 'os.mkdir', (['base_folder'], {}), '(base_folder)\n', (5813, 5826), False, 'import os\n'), ((5901, 5934), 'aiofiles.open', 'aiofiles.open', (['pdf_filename', '"""wb"""'], {}), "(pdf_filename, 'wb')\n", (5914, 5934), False, 'import aiofiles\n'), ((6012, 6072), 'json.dumps', 'json.dumps', (["{'msg': 'success', 'pdf_filename': pdf_filename}"], {}), "({'msg': 'success', 'pdf_filename': pdf_filename})\n", (6022, 6072), False, 'import json\n'), ((6296, 6336), 'json.dumps', 'json.dumps', (["{'output_file': output_file}"], {}), "({'output_file': output_file})\n", (6306, 6336), False, 'import json\n')] |
#!/usr/bin/env python
"""Example LangChain server exposes a retriever."""
from fastapi import FastAPI
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langserve import add_routes
vectorstore = FAISS.from_texts(
["cats like fish", "dogs like sticks"], embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()
app = FastAPI(
title="LangChain Server",
version="1.0",
description="Spin up a simple api server using Langchain's Runnable interfaces",
)
# Adds routes to the app for using the retriever under:
# /invoke
# /batch
# /stream
add_routes(app, retriever)
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="localhost", port=8000)
| [
"langchain.embeddings.OpenAIEmbeddings"
] | [((381, 515), 'fastapi.FastAPI', 'FastAPI', ([], {'title': '"""LangChain Server"""', 'version': '"""1.0"""', 'description': '"""Spin up a simple api server using Langchain\'s Runnable interfaces"""'}), '(title=\'LangChain Server\', version=\'1.0\', description=\n "Spin up a simple api server using Langchain\'s Runnable interfaces")\n', (388, 515), False, 'from fastapi import FastAPI\n'), ((611, 637), 'langserve.add_routes', 'add_routes', (['app', 'retriever'], {}), '(app, retriever)\n', (621, 637), False, 'from langserve import add_routes\n'), ((690, 735), 'uvicorn.run', 'uvicorn.run', (['app'], {'host': '"""localhost"""', 'port': '(8000)'}), "(app, host='localhost', port=8000)\n", (701, 735), False, 'import uvicorn\n'), ((314, 332), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (330, 332), False, 'from langchain.embeddings import OpenAIEmbeddings\n')] |
"""
Chatbot for talking to Podcast using Langchain, Ollama and LanceDB
"""
from langchain.document_loaders import WikipediaLoader
import pandas as pd
from langchain.memory import ConversationSummaryMemory
import lancedb
from langchain.vectorstores import LanceDB
from langchain.embeddings import OpenAIEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chat_models import ChatOllama
from langchain.chains import ConversationalRetrievalChain
def lanceDBConnection(embed):
db = lancedb.connect("/tmp/lancedb")
table = db.create_table(
"pdf_search",
data=[{"vector": embed.embed_query("Hello World"), "text": "Hello World"}],
mode="overwrite",
)
return table
def vectorStoreSetup(query, OPENAI_KEY):
docs = WikipediaLoader(query=query, load_max_docs=2).load()
# chunking
text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=0)
all_splits = text_splitter.split_documents(docs)
# OpenAI embeddings
embed = OpenAIEmbeddings(openai_api_key=OPENAI_KEY)
# LanceDB as vector store
table = lanceDBConnection(embed)
vectorstore = LanceDB.from_documents(
documents=all_splits,
embedding=OpenAIEmbeddings(openai_api_key=OPENAI_KEY),
connection=table,
)
return vectorstore
def retrieverSetup(text, OPENAI_KEY):
vectorstore = vectorStoreSetup(text, OPENAI_KEY)
# define ChatOllama: by default takes llama2-4bit quantized model
llm = ChatOllama()
memory = ConversationSummaryMemory(
llm=llm, memory_key="chat_history", return_messages=True
)
retriever = vectorstore.as_retriever()
# define Retrieval Chain for retriver
qa = ConversationalRetrievalChain.from_llm(llm, retriever=retriever, memory=memory)
return qa
def chat(qa, question):
# chat query
r = qa.run({"question": question})
return r
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.memory.ConversationSummaryMemory",
"langchain.chains.ConversationalRetrievalChain.from_llm",
"langchain.document_loaders.WikipediaLoader",
"langchain.chat_models.ChatOllama",
"langchain.embeddings.OpenAIEmbeddings"
] | [((525, 556), 'lancedb.connect', 'lancedb.connect', (['"""/tmp/lancedb"""'], {}), "('/tmp/lancedb')\n", (540, 556), False, 'import lancedb\n'), ((883, 946), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(500)', 'chunk_overlap': '(0)'}), '(chunk_size=500, chunk_overlap=0)\n', (913, 946), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1036, 1079), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'OPENAI_KEY'}), '(openai_api_key=OPENAI_KEY)\n', (1052, 1079), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((1510, 1522), 'langchain.chat_models.ChatOllama', 'ChatOllama', ([], {}), '()\n', (1520, 1522), False, 'from langchain.chat_models import ChatOllama\n'), ((1536, 1623), 'langchain.memory.ConversationSummaryMemory', 'ConversationSummaryMemory', ([], {'llm': 'llm', 'memory_key': '"""chat_history"""', 'return_messages': '(True)'}), "(llm=llm, memory_key='chat_history',\n return_messages=True)\n", (1561, 1623), False, 'from langchain.memory import ConversationSummaryMemory\n'), ((1728, 1806), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', (['llm'], {'retriever': 'retriever', 'memory': 'memory'}), '(llm, retriever=retriever, memory=memory)\n', (1765, 1806), False, 'from langchain.chains import ConversationalRetrievalChain\n'), ((795, 840), 'langchain.document_loaders.WikipediaLoader', 'WikipediaLoader', ([], {'query': 'query', 'load_max_docs': '(2)'}), '(query=query, load_max_docs=2)\n', (810, 840), False, 'from langchain.document_loaders import WikipediaLoader\n'), ((1237, 1280), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'OPENAI_KEY'}), '(openai_api_key=OPENAI_KEY)\n', (1253, 1280), False, 'from langchain.embeddings import OpenAIEmbeddings\n')] |
## Conversational Q&A Chatbot
import streamlit as st
from langchain.schema import HumanMessage,SystemMessage,AIMessage
from langchain.chat_models import ChatOpenAI
## Streamlit UI
st.set_page_config(page_title="Conversational Q&A Chatbot")
st.header("Hey, Let's Chat")
from dotenv import load_dotenv
load_dotenv()
import os
chat=ChatOpenAI(temperature=0.5)
if 'flowmessages' not in st.session_state:
st.session_state['flowmessages']=[
SystemMessage(content="Yor are a comedian AI assitant")
]
## Function to load OpenAI model and get respones
def get_chatmodel_response(question):
st.session_state['flowmessages'].append(HumanMessage(content=question))
answer=chat(st.session_state['flowmessages'])
st.session_state['flowmessages'].append(AIMessage(content=answer.content))
return answer.content
input=st.text_input("Input: ",key="input")
response=get_chatmodel_response(input)
submit=st.button("Ask the question")
## If ask button is clicked
if submit:
st.subheader("The Response is")
st.write(response) | [
"langchain.schema.AIMessage",
"langchain.schema.SystemMessage",
"langchain.schema.HumanMessage",
"langchain.chat_models.ChatOpenAI"
] | [((189, 248), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""Conversational Q&A Chatbot"""'}), "(page_title='Conversational Q&A Chatbot')\n", (207, 248), True, 'import streamlit as st\n'), ((250, 278), 'streamlit.header', 'st.header', (['"""Hey, Let\'s Chat"""'], {}), '("Hey, Let\'s Chat")\n', (259, 278), True, 'import streamlit as st\n'), ((314, 327), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (325, 327), False, 'from dotenv import load_dotenv\n'), ((347, 374), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0.5)'}), '(temperature=0.5)\n', (357, 374), False, 'from langchain.chat_models import ChatOpenAI\n'), ((873, 910), 'streamlit.text_input', 'st.text_input', (['"""Input: """'], {'key': '"""input"""'}), "('Input: ', key='input')\n", (886, 910), True, 'import streamlit as st\n'), ((960, 989), 'streamlit.button', 'st.button', (['"""Ask the question"""'], {}), "('Ask the question')\n", (969, 989), True, 'import streamlit as st\n'), ((1040, 1071), 'streamlit.subheader', 'st.subheader', (['"""The Response is"""'], {}), "('The Response is')\n", (1052, 1071), True, 'import streamlit as st\n'), ((1077, 1095), 'streamlit.write', 'st.write', (['response'], {}), '(response)\n', (1085, 1095), True, 'import streamlit as st\n'), ((470, 525), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': '"""Yor are a comedian AI assitant"""'}), "(content='Yor are a comedian AI assitant')\n", (483, 525), False, 'from langchain.schema import HumanMessage, SystemMessage, AIMessage\n'), ((674, 704), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'question'}), '(content=question)\n', (686, 704), False, 'from langchain.schema import HumanMessage, SystemMessage, AIMessage\n'), ((802, 835), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'answer.content'}), '(content=answer.content)\n', (811, 835), False, 'from langchain.schema import HumanMessage, SystemMessage, AIMessage\n')] |
# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import ray
from ray import serve
import logging
import os
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.llms import OpenAI, HuggingFacePipeline
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoConfig, pipeline
# Logging configuration
logging.basicConfig(level=logging.INFO)
# Configurations (consider using environment variables or a dedicated config module)
MODEL_ID = os.environ.get('MODEL_ID', 'google/flan-t5-small')
RAY_ADDRESS = os.environ.get('RAY_ADDRESS', 'ray://example-cluster-kuberay-head-svc:10001')
def create_chains(llm):
template1 = "Give me a fact about {topic}."
template2 = "Translate to french: {fact}"
# Create the prompts
prompt = PromptTemplate(input_variables=["topic"], template=template1)
second_prompt = PromptTemplate(input_variables=["fact"], template=template2)
# Create and combine chains
fact_chain = LLMChain(llm=llm, prompt=prompt)
translate_chain = LLMChain(llm=llm, prompt=second_prompt)
return fact_chain, translate_chain
def init_model():
logging.info("Initializing the model...")
config = AutoConfig.from_pretrained(MODEL_ID)
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_ID, config=config)
_pipeline = pipeline('text2text-generation', model=model, tokenizer=tokenizer, max_length=512)
llm = HuggingFacePipeline(pipeline=_pipeline)
return create_chains(llm)
fact_chain, translate_chain = init_model()
@serve.deployment
class DeployLLM:
def __init__(self):
self.fact_chain = fact_chain
self.translate_chain = translate_chain
def _run_chain(self, text: str):
fact = self.fact_chain.run(text)
translation = self.translate_chain.run(fact)
return fact, translation
async def __call__(self, request):
# 1. Parse the request
text = request.query_params["text"]
# 2. Run the chain
fact, translation = self._run_chain(text)
# 3. Return the response
return [fact, translation]
def init_ray_and_deploy():
logging.info("Initializing Ray and deploying the model...")
ray.init(
address=RAY_ADDRESS,
runtime_env={
"pip": [
"transformers>=4.26.0",
"langchain",
"requests",
"torch"
]
}
)
deployment = DeployLLM.bind()
serve.run(deployment, host="0.0.0.0")
| [
"langchain.chains.LLMChain",
"langchain.prompts.PromptTemplate",
"langchain.llms.HuggingFacePipeline"
] | [((882, 921), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (901, 921), False, 'import logging\n'), ((1019, 1069), 'os.environ.get', 'os.environ.get', (['"""MODEL_ID"""', '"""google/flan-t5-small"""'], {}), "('MODEL_ID', 'google/flan-t5-small')\n", (1033, 1069), False, 'import os\n'), ((1084, 1161), 'os.environ.get', 'os.environ.get', (['"""RAY_ADDRESS"""', '"""ray://example-cluster-kuberay-head-svc:10001"""'], {}), "('RAY_ADDRESS', 'ray://example-cluster-kuberay-head-svc:10001')\n", (1098, 1161), False, 'import os\n'), ((1320, 1381), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['topic']", 'template': 'template1'}), "(input_variables=['topic'], template=template1)\n", (1334, 1381), False, 'from langchain.prompts import PromptTemplate\n'), ((1402, 1462), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['fact']", 'template': 'template2'}), "(input_variables=['fact'], template=template2)\n", (1416, 1462), False, 'from langchain.prompts import PromptTemplate\n'), ((1517, 1549), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (1525, 1549), False, 'from langchain.chains import LLMChain\n'), ((1572, 1611), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'second_prompt'}), '(llm=llm, prompt=second_prompt)\n', (1580, 1611), False, 'from langchain.chains import LLMChain\n'), ((1674, 1715), 'logging.info', 'logging.info', (['"""Initializing the model..."""'], {}), "('Initializing the model...')\n", (1686, 1715), False, 'import logging\n'), ((1729, 1765), 'transformers.AutoConfig.from_pretrained', 'AutoConfig.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (1755, 1765), False, 'from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoConfig, pipeline\n'), ((1782, 1821), 'transformers.AutoTokenizer.from_pretrained', 'AutoTokenizer.from_pretrained', (['MODEL_ID'], {}), '(MODEL_ID)\n', (1811, 1821), False, 'from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoConfig, pipeline\n'), ((1834, 1896), 'transformers.AutoModelForSeq2SeqLM.from_pretrained', 'AutoModelForSeq2SeqLM.from_pretrained', (['MODEL_ID'], {'config': 'config'}), '(MODEL_ID, config=config)\n', (1871, 1896), False, 'from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoConfig, pipeline\n'), ((1913, 1999), 'transformers.pipeline', 'pipeline', (['"""text2text-generation"""'], {'model': 'model', 'tokenizer': 'tokenizer', 'max_length': '(512)'}), "('text2text-generation', model=model, tokenizer=tokenizer,\n max_length=512)\n", (1921, 1999), False, 'from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoConfig, pipeline\n'), ((2006, 2045), 'langchain.llms.HuggingFacePipeline', 'HuggingFacePipeline', ([], {'pipeline': '_pipeline'}), '(pipeline=_pipeline)\n', (2025, 2045), False, 'from langchain.llms import OpenAI, HuggingFacePipeline\n'), ((2721, 2780), 'logging.info', 'logging.info', (['"""Initializing Ray and deploying the model..."""'], {}), "('Initializing Ray and deploying the model...')\n", (2733, 2780), False, 'import logging\n'), ((2785, 2899), 'ray.init', 'ray.init', ([], {'address': 'RAY_ADDRESS', 'runtime_env': "{'pip': ['transformers>=4.26.0', 'langchain', 'requests', 'torch']}"}), "(address=RAY_ADDRESS, runtime_env={'pip': ['transformers>=4.26.0',\n 'langchain', 'requests', 'torch']})\n", (2793, 2899), False, 'import ray\n'), ((3060, 3097), 'ray.serve.run', 'serve.run', (['deployment'], {'host': '"""0.0.0.0"""'}), "(deployment, host='0.0.0.0')\n", (3069, 3097), False, 'from ray import serve\n')] |
"""Prompt schema definition."""
from __future__ import annotations
from string import Formatter
from typing import Any, Dict, List
from pydantic import BaseModel, Extra, root_validator
from langchain.prompts.base import (
DEFAULT_FORMATTER_MAPPING,
BasePromptTemplate,
check_valid_template,
)
class PromptTemplate(BasePromptTemplate, BaseModel):
"""Schema to represent a prompt for an LLM.
Example:
.. code-block:: python
from langchain import PromptTemplate
prompt = PromptTemplate(input_variables=["foo"], template="Say {foo}")
"""
input_variables: List[str]
"""A list of the names of the variables the prompt template expects."""
template: str
"""The prompt template."""
template_format: str = "f-string"
"""The format of the prompt template. Options are: 'f-string', 'jinja2'."""
validate_template: bool = True
"""Whether or not to try validating the template."""
@property
def _prompt_type(self) -> str:
"""Return the prompt type key."""
return "prompt"
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
def format(self, **kwargs: Any) -> str:
"""Format the prompt with the inputs.
Args:
kwargs: Any arguments to be passed to the prompt template.
Returns:
A formatted string.
Example:
.. code-block:: python
prompt.format(variable1="foo")
"""
return DEFAULT_FORMATTER_MAPPING[self.template_format](self.template, **kwargs)
@root_validator()
def template_is_valid(cls, values: Dict) -> Dict:
"""Check that template and input variables are consistent."""
if values["validate_template"]:
check_valid_template(
values["template"], values["template_format"], values["input_variables"]
)
return values
@classmethod
def from_examples(
cls,
examples: List[str],
suffix: str,
input_variables: List[str],
example_separator: str = "\n\n",
prefix: str = "",
) -> PromptTemplate:
"""Take examples in list format with prefix and suffix to create a prompt.
Intended be used as a way to dynamically create a prompt from examples.
Args:
examples: List of examples to use in the prompt.
suffix: String to go after the list of examples. Should generally
set up the user's input.
input_variables: A list of variable names the final prompt template
will expect.
example_separator: The separator to use in between examples. Defaults
to two new line characters.
prefix: String that should go before any examples. Generally includes
examples. Default to an empty string.
Returns:
The final prompt generated.
"""
template = example_separator.join([prefix, *examples, suffix])
return cls(input_variables=input_variables, template=template)
@classmethod
def from_file(
cls, template_file: str, input_variables: List[str]
) -> PromptTemplate:
"""Load a prompt from a file.
Args:
template_file: The path to the file containing the prompt template.
input_variables: A list of variable names the final prompt template
will expect.
Returns:
The prompt loaded from the file.
"""
with open(template_file, "r") as f:
template = f.read()
return cls(input_variables=input_variables, template=template)
@classmethod
def from_template(cls, template: str) -> PromptTemplate:
"""Load a prompt template from a template."""
input_variables = {
v for _, v, _, _ in Formatter().parse(template) if v is not None
}
return cls(input_variables=list(sorted(input_variables)), template=template)
# For backwards compatibility.
Prompt = PromptTemplate
| [
"langchain.prompts.base.check_valid_template"
] | [((1613, 1629), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (1627, 1629), False, 'from pydantic import BaseModel, Extra, root_validator\n'), ((1806, 1905), 'langchain.prompts.base.check_valid_template', 'check_valid_template', (["values['template']", "values['template_format']", "values['input_variables']"], {}), "(values['template'], values['template_format'], values[\n 'input_variables'])\n", (1826, 1905), False, 'from langchain.prompts.base import DEFAULT_FORMATTER_MAPPING, BasePromptTemplate, check_valid_template\n'), ((3905, 3916), 'string.Formatter', 'Formatter', ([], {}), '()\n', (3914, 3916), False, 'from string import Formatter\n')] |
from langchain.chat_models import ChatOpenAI
from langchain.chains.summarize import load_summarize_chain
from langchain.text_splitter import TokenTextSplitter
from langchain.docstore.document import Document
# Function to initialize the large language model.
def initialize_llm(openai_api_key, model_name, temperature):
llm = ChatOpenAI(openai_api_key=openai_api_key, model_name=model_name, temperature=temperature)
return llm
# Function to initialize the summarize chain.
def initialize_summarize_chain(llm, chain_type, question_prompt, refine_prompt):
strategy_chain = load_summarize_chain(llm=llm, chain_type=chain_type, verbose=True, question_prompt=question_prompt, refine_prompt=refine_prompt)
return strategy_chain
# Function to split the transcript into chunks.
def split_text(data, chunk_size, chunk_overlap):
text_splitter = TokenTextSplitter(chunk_size = chunk_size, chunk_overlap = chunk_overlap)
texts = text_splitter.split_text(data)
# Create documents for further processing
docs = [Document(page_content=t) for t in texts]
return docs
| [
"langchain.chains.summarize.load_summarize_chain",
"langchain.docstore.document.Document",
"langchain.text_splitter.TokenTextSplitter",
"langchain.chat_models.ChatOpenAI"
] | [((331, 424), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': 'openai_api_key', 'model_name': 'model_name', 'temperature': 'temperature'}), '(openai_api_key=openai_api_key, model_name=model_name,\n temperature=temperature)\n', (341, 424), False, 'from langchain.chat_models import ChatOpenAI\n'), ((585, 717), 'langchain.chains.summarize.load_summarize_chain', 'load_summarize_chain', ([], {'llm': 'llm', 'chain_type': 'chain_type', 'verbose': '(True)', 'question_prompt': 'question_prompt', 'refine_prompt': 'refine_prompt'}), '(llm=llm, chain_type=chain_type, verbose=True,\n question_prompt=question_prompt, refine_prompt=refine_prompt)\n', (605, 717), False, 'from langchain.chains.summarize import load_summarize_chain\n'), ((858, 927), 'langchain.text_splitter.TokenTextSplitter', 'TokenTextSplitter', ([], {'chunk_size': 'chunk_size', 'chunk_overlap': 'chunk_overlap'}), '(chunk_size=chunk_size, chunk_overlap=chunk_overlap)\n', (875, 927), False, 'from langchain.text_splitter import TokenTextSplitter\n'), ((1034, 1058), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 't'}), '(page_content=t)\n', (1042, 1058), False, 'from langchain.docstore.document import Document\n')] |
"""Wrapper around Google's PaLM Chat API."""
from __future__ import annotations
import logging
from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional
from pydantic import BaseModel, root_validator
from tenacity import (
before_sleep_log,
retry,
retry_if_exception_type,
stop_after_attempt,
wait_exponential,
)
from langchain.callbacks.manager import (
AsyncCallbackManagerForLLMRun,
CallbackManagerForLLMRun,
)
from langchain.chat_models.base import BaseChatModel
from langchain.schema import (
AIMessage,
BaseMessage,
ChatGeneration,
ChatMessage,
ChatResult,
HumanMessage,
SystemMessage,
)
from langchain.utils import get_from_dict_or_env
if TYPE_CHECKING:
import google.generativeai as genai
logger = logging.getLogger(__name__)
class ChatGooglePalmError(Exception):
pass
def _truncate_at_stop_tokens(
text: str,
stop: Optional[List[str]],
) -> str:
"""Truncates text at the earliest stop token found."""
if stop is None:
return text
for stop_token in stop:
stop_token_idx = text.find(stop_token)
if stop_token_idx != -1:
text = text[:stop_token_idx]
return text
def _response_to_result(
response: genai.types.ChatResponse,
stop: Optional[List[str]],
) -> ChatResult:
"""Converts a PaLM API response into a LangChain ChatResult."""
if not response.candidates:
raise ChatGooglePalmError("ChatResponse must have at least one candidate.")
generations: List[ChatGeneration] = []
for candidate in response.candidates:
author = candidate.get("author")
if author is None:
raise ChatGooglePalmError(f"ChatResponse must have an author: {candidate}")
content = _truncate_at_stop_tokens(candidate.get("content", ""), stop)
if content is None:
raise ChatGooglePalmError(f"ChatResponse must have a content: {candidate}")
if author == "ai":
generations.append(
ChatGeneration(text=content, message=AIMessage(content=content))
)
elif author == "human":
generations.append(
ChatGeneration(
text=content,
message=HumanMessage(content=content),
)
)
else:
generations.append(
ChatGeneration(
text=content,
message=ChatMessage(role=author, content=content),
)
)
return ChatResult(generations=generations)
def _messages_to_prompt_dict(
input_messages: List[BaseMessage],
) -> genai.types.MessagePromptDict:
"""Converts a list of LangChain messages into a PaLM API MessagePrompt structure."""
import google.generativeai as genai
context: str = ""
examples: List[genai.types.MessageDict] = []
messages: List[genai.types.MessageDict] = []
remaining = list(enumerate(input_messages))
while remaining:
index, input_message = remaining.pop(0)
if isinstance(input_message, SystemMessage):
if index != 0:
raise ChatGooglePalmError("System message must be first input message.")
context = input_message.content
elif isinstance(input_message, HumanMessage) and input_message.example:
if messages:
raise ChatGooglePalmError(
"Message examples must come before other messages."
)
_, next_input_message = remaining.pop(0)
if isinstance(next_input_message, AIMessage) and next_input_message.example:
examples.extend(
[
genai.types.MessageDict(
author="human", content=input_message.content
),
genai.types.MessageDict(
author="ai", content=next_input_message.content
),
]
)
else:
raise ChatGooglePalmError(
"Human example message must be immediately followed by an "
" AI example response."
)
elif isinstance(input_message, AIMessage) and input_message.example:
raise ChatGooglePalmError(
"AI example message must be immediately preceded by a Human "
"example message."
)
elif isinstance(input_message, AIMessage):
messages.append(
genai.types.MessageDict(author="ai", content=input_message.content)
)
elif isinstance(input_message, HumanMessage):
messages.append(
genai.types.MessageDict(author="human", content=input_message.content)
)
elif isinstance(input_message, ChatMessage):
messages.append(
genai.types.MessageDict(
author=input_message.role, content=input_message.content
)
)
else:
raise ChatGooglePalmError(
"Messages without an explicit role not supported by PaLM API."
)
return genai.types.MessagePromptDict(
context=context,
examples=examples,
messages=messages,
)
def _create_retry_decorator() -> Callable[[Any], Any]:
"""Returns a tenacity retry decorator, preconfigured to handle PaLM exceptions"""
import google.api_core.exceptions
multiplier = 2
min_seconds = 1
max_seconds = 60
max_retries = 10
return retry(
reraise=True,
stop=stop_after_attempt(max_retries),
wait=wait_exponential(multiplier=multiplier, min=min_seconds, max=max_seconds),
retry=(
retry_if_exception_type(google.api_core.exceptions.ResourceExhausted)
| retry_if_exception_type(google.api_core.exceptions.ServiceUnavailable)
| retry_if_exception_type(google.api_core.exceptions.GoogleAPIError)
),
before_sleep=before_sleep_log(logger, logging.WARNING),
)
def chat_with_retry(llm: ChatGooglePalm, **kwargs: Any) -> Any:
"""Use tenacity to retry the completion call."""
retry_decorator = _create_retry_decorator()
@retry_decorator
def _chat_with_retry(**kwargs: Any) -> Any:
return llm.client.chat(**kwargs)
return _chat_with_retry(**kwargs)
async def achat_with_retry(llm: ChatGooglePalm, **kwargs: Any) -> Any:
"""Use tenacity to retry the async completion call."""
retry_decorator = _create_retry_decorator()
@retry_decorator
async def _achat_with_retry(**kwargs: Any) -> Any:
# Use OpenAI's async api https://github.com/openai/openai-python#async-api
return await llm.client.chat_async(**kwargs)
return await _achat_with_retry(**kwargs)
class ChatGooglePalm(BaseChatModel, BaseModel):
"""Wrapper around Google's PaLM Chat API.
To use you must have the google.generativeai Python package installed and
either:
1. The ``GOOGLE_API_KEY``` environment varaible set with your API key, or
2. Pass your API key using the google_api_key kwarg to the ChatGoogle
constructor.
Example:
.. code-block:: python
from langchain.chat_models import ChatGooglePalm
chat = ChatGooglePalm()
"""
client: Any #: :meta private:
model_name: str = "models/chat-bison-001"
"""Model name to use."""
google_api_key: Optional[str] = None
temperature: Optional[float] = None
"""Run inference with this temperature. Must by in the closed
interval [0.0, 1.0]."""
top_p: Optional[float] = None
"""Decode using nucleus sampling: consider the smallest set of tokens whose
probability sum is at least top_p. Must be in the closed interval [0.0, 1.0]."""
top_k: Optional[int] = None
"""Decode using top-k sampling: consider the set of top_k most probable tokens.
Must be positive."""
n: int = 1
"""Number of chat completions to generate for each prompt. Note that the API may
not return the full n completions if duplicates are generated."""
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate api key, python package exists, temperature, top_p, and top_k."""
google_api_key = get_from_dict_or_env(
values, "google_api_key", "GOOGLE_API_KEY"
)
try:
import google.generativeai as genai
genai.configure(api_key=google_api_key)
except ImportError:
raise ChatGooglePalmError(
"Could not import google.generativeai python package. "
"Please install it with `pip install google-generativeai`"
)
values["client"] = genai
if values["temperature"] is not None and not 0 <= values["temperature"] <= 1:
raise ValueError("temperature must be in the range [0.0, 1.0]")
if values["top_p"] is not None and not 0 <= values["top_p"] <= 1:
raise ValueError("top_p must be in the range [0.0, 1.0]")
if values["top_k"] is not None and values["top_k"] <= 0:
raise ValueError("top_k must be positive")
return values
def _generate(
self,
messages: List[BaseMessage],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
) -> ChatResult:
prompt = _messages_to_prompt_dict(messages)
response: genai.types.ChatResponse = chat_with_retry(
self,
model=self.model_name,
prompt=prompt,
temperature=self.temperature,
top_p=self.top_p,
top_k=self.top_k,
candidate_count=self.n,
)
return _response_to_result(response, stop)
async def _agenerate(
self,
messages: List[BaseMessage],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
) -> ChatResult:
prompt = _messages_to_prompt_dict(messages)
response: genai.types.ChatResponse = await achat_with_retry(
self,
model=self.model_name,
prompt=prompt,
temperature=self.temperature,
top_p=self.top_p,
top_k=self.top_k,
candidate_count=self.n,
)
return _response_to_result(response, stop)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {
"model_name": self.model_name,
"temperature": self.temperature,
"top_p": self.top_p,
"top_k": self.top_k,
"n": self.n,
}
@property
def _llm_type(self) -> str:
return "google-palm-chat"
| [
"langchain.schema.ChatMessage",
"langchain.utils.get_from_dict_or_env",
"langchain.schema.ChatResult",
"langchain.schema.HumanMessage",
"langchain.schema.AIMessage"
] | [((792, 819), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (809, 819), False, 'import logging\n'), ((2563, 2598), 'langchain.schema.ChatResult', 'ChatResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (2573, 2598), False, 'from langchain.schema import AIMessage, BaseMessage, ChatGeneration, ChatMessage, ChatResult, HumanMessage, SystemMessage\n'), ((5264, 5353), 'google.generativeai.types.MessagePromptDict', 'genai.types.MessagePromptDict', ([], {'context': 'context', 'examples': 'examples', 'messages': 'messages'}), '(context=context, examples=examples, messages=\n messages)\n', (5293, 5353), True, 'import google.generativeai as genai\n'), ((8257, 8273), 'pydantic.root_validator', 'root_validator', ([], {}), '()\n', (8271, 8273), False, 'from pydantic import BaseModel, root_validator\n'), ((8442, 8506), 'langchain.utils.get_from_dict_or_env', 'get_from_dict_or_env', (['values', '"""google_api_key"""', '"""GOOGLE_API_KEY"""'], {}), "(values, 'google_api_key', 'GOOGLE_API_KEY')\n", (8462, 8506), False, 'from langchain.utils import get_from_dict_or_env\n'), ((5697, 5728), 'tenacity.stop_after_attempt', 'stop_after_attempt', (['max_retries'], {}), '(max_retries)\n', (5715, 5728), False, 'from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_exponential\n'), ((5743, 5816), 'tenacity.wait_exponential', 'wait_exponential', ([], {'multiplier': 'multiplier', 'min': 'min_seconds', 'max': 'max_seconds'}), '(multiplier=multiplier, min=min_seconds, max=max_seconds)\n', (5759, 5816), False, 'from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_exponential\n'), ((6114, 6155), 'tenacity.before_sleep_log', 'before_sleep_log', (['logger', 'logging.WARNING'], {}), '(logger, logging.WARNING)\n', (6130, 6155), False, 'from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_exponential\n'), ((8603, 8642), 'google.generativeai.configure', 'genai.configure', ([], {'api_key': 'google_api_key'}), '(api_key=google_api_key)\n', (8618, 8642), True, 'import google.generativeai as genai\n'), ((6015, 6081), 'tenacity.retry_if_exception_type', 'retry_if_exception_type', (['google.api_core.exceptions.GoogleAPIError'], {}), '(google.api_core.exceptions.GoogleAPIError)\n', (6038, 6081), False, 'from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_exponential\n'), ((5846, 5915), 'tenacity.retry_if_exception_type', 'retry_if_exception_type', (['google.api_core.exceptions.ResourceExhausted'], {}), '(google.api_core.exceptions.ResourceExhausted)\n', (5869, 5915), False, 'from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_exponential\n'), ((5930, 6000), 'tenacity.retry_if_exception_type', 'retry_if_exception_type', (['google.api_core.exceptions.ServiceUnavailable'], {}), '(google.api_core.exceptions.ServiceUnavailable)\n', (5953, 6000), False, 'from tenacity import before_sleep_log, retry, retry_if_exception_type, stop_after_attempt, wait_exponential\n'), ((2073, 2099), 'langchain.schema.AIMessage', 'AIMessage', ([], {'content': 'content'}), '(content=content)\n', (2082, 2099), False, 'from langchain.schema import AIMessage, BaseMessage, ChatGeneration, ChatMessage, ChatResult, HumanMessage, SystemMessage\n'), ((2273, 2302), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'content'}), '(content=content)\n', (2285, 2302), False, 'from langchain.schema import AIMessage, BaseMessage, ChatGeneration, ChatMessage, ChatResult, HumanMessage, SystemMessage\n'), ((2476, 2517), 'langchain.schema.ChatMessage', 'ChatMessage', ([], {'role': 'author', 'content': 'content'}), '(role=author, content=content)\n', (2487, 2517), False, 'from langchain.schema import AIMessage, BaseMessage, ChatGeneration, ChatMessage, ChatResult, HumanMessage, SystemMessage\n'), ((3748, 3818), 'google.generativeai.types.MessageDict', 'genai.types.MessageDict', ([], {'author': '"""human"""', 'content': 'input_message.content'}), "(author='human', content=input_message.content)\n", (3771, 3818), True, 'import google.generativeai as genai\n'), ((3898, 3970), 'google.generativeai.types.MessageDict', 'genai.types.MessageDict', ([], {'author': '"""ai"""', 'content': 'next_input_message.content'}), "(author='ai', content=next_input_message.content)\n", (3921, 3970), True, 'import google.generativeai as genai\n'), ((4608, 4675), 'google.generativeai.types.MessageDict', 'genai.types.MessageDict', ([], {'author': '"""ai"""', 'content': 'input_message.content'}), "(author='ai', content=input_message.content)\n", (4631, 4675), True, 'import google.generativeai as genai\n'), ((4789, 4859), 'google.generativeai.types.MessageDict', 'genai.types.MessageDict', ([], {'author': '"""human"""', 'content': 'input_message.content'}), "(author='human', content=input_message.content)\n", (4812, 4859), True, 'import google.generativeai as genai\n'), ((4972, 5058), 'google.generativeai.types.MessageDict', 'genai.types.MessageDict', ([], {'author': 'input_message.role', 'content': 'input_message.content'}), '(author=input_message.role, content=input_message.\n content)\n', (4995, 5058), True, 'import google.generativeai as genai\n')] |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File : create_db.py
@Time : 2023/12/14 10:56:31
@Author : Logan Zou
@Version : 1.0
@Contact : [email protected]
@License : (C)Copyright 2017-2018, Liugroup-NLPR-CASIA
@Desc : 知识库搭建
'''
# 首先导入所需第三方库
from langchain.document_loaders import UnstructuredFileLoader
from langchain.document_loaders import UnstructuredMarkdownLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
from tqdm import tqdm
import os
# 获取文件路径函数
def get_files(dir_path):
# args：dir_path，目标文件夹路径
file_list = []
for filepath, dirnames, filenames in os.walk(dir_path):
# os.walk 函数将递归遍历指定文件夹
for filename in filenames:
# 通过后缀名判断文件类型是否满足要求
if filename.endswith(".md"):
# 如果满足要求，将其绝对路径加入到结果列表
file_list.append(os.path.join(filepath, filename))
elif filename.endswith(".txt"):
file_list.append(os.path.join(filepath, filename))
return file_list
# 加载文件函数
def get_text(dir_path):
# args：dir_path，目标文件夹路径
# 首先调用上文定义的函数得到目标文件路径列表
file_lst = get_files(dir_path)
# docs 存放加载之后的纯文本对象
docs = []
# 遍历所有目标文件
for one_file in tqdm(file_lst):
file_type = one_file.split('.')[-1]
if file_type == 'md':
loader = UnstructuredMarkdownLoader(one_file)
elif file_type == 'txt':
loader = UnstructuredFileLoader(one_file)
else:
# 如果是不符合条件的文件，直接跳过
continue
docs.extend(loader.load())
return docs
# 目标文件夹
tar_dir = [
"/root/autodl-tmp/self-llm",
"/root/autodl-tmp/llm-universe",
"/root/autodl-tmp/prompt-engineering-for-developers",
"/root/autodl-tmp/so-large-lm",
"/root/autodl-tmp/hugging-llm",
]
# 加载目标文件
docs = []
for dir_path in tar_dir:
docs.extend(get_text(dir_path))
# 对文本进行分块
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500, chunk_overlap=150)
split_docs = text_splitter.split_documents(docs)
# 加载开源词向量模型
embeddings = HuggingFaceEmbeddings(model_name="/root/autodl-tmp/sentence-transformer")
# 构建向量数据库
# 定义持久化路径
persist_directory = 'data_base/vector_db/chroma'
# 加载数据库
vectordb = Chroma.from_documents(
documents=split_docs,
embedding=embeddings,
persist_directory=persist_directory # 允许我们将persist_directory目录保存到磁盘上
)
# 将加载的向量数据库持久化到磁盘上
vectordb.persist() | [
"langchain.document_loaders.UnstructuredFileLoader",
"langchain.embeddings.huggingface.HuggingFaceEmbeddings",
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.vectorstores.Chroma.from_documents",
"langchain.document_loaders.UnstructuredMarkdownLoader"
] | [((2018, 2083), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(500)', 'chunk_overlap': '(150)'}), '(chunk_size=500, chunk_overlap=150)\n', (2048, 2083), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((2164, 2237), 'langchain.embeddings.huggingface.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""/root/autodl-tmp/sentence-transformer"""'}), "(model_name='/root/autodl-tmp/sentence-transformer')\n", (2185, 2237), False, 'from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n'), ((2327, 2433), 'langchain.vectorstores.Chroma.from_documents', 'Chroma.from_documents', ([], {'documents': 'split_docs', 'embedding': 'embeddings', 'persist_directory': 'persist_directory'}), '(documents=split_docs, embedding=embeddings,\n persist_directory=persist_directory)\n', (2348, 2433), False, 'from langchain.vectorstores import Chroma\n'), ((741, 758), 'os.walk', 'os.walk', (['dir_path'], {}), '(dir_path)\n', (748, 758), False, 'import os\n'), ((1335, 1349), 'tqdm.tqdm', 'tqdm', (['file_lst'], {}), '(file_lst)\n', (1339, 1349), False, 'from tqdm import tqdm\n'), ((1446, 1482), 'langchain.document_loaders.UnstructuredMarkdownLoader', 'UnstructuredMarkdownLoader', (['one_file'], {}), '(one_file)\n', (1472, 1482), False, 'from langchain.document_loaders import UnstructuredMarkdownLoader\n'), ((1537, 1569), 'langchain.document_loaders.UnstructuredFileLoader', 'UnstructuredFileLoader', (['one_file'], {}), '(one_file)\n', (1559, 1569), False, 'from langchain.document_loaders import UnstructuredFileLoader\n'), ((971, 1003), 'os.path.join', 'os.path.join', (['filepath', 'filename'], {}), '(filepath, filename)\n', (983, 1003), False, 'import os\n'), ((1082, 1114), 'os.path.join', 'os.path.join', (['filepath', 'filename'], {}), '(filepath, filename)\n', (1094, 1114), False, 'import os\n')] |
from flask import Flask, request
from flask_restful import Resource, Api, reqparse, abort
from werkzeug.utils import secure_filename
########################################################################
import tempfile
import os
from langchain.document_loaders import DirectoryLoader, PyMuPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.chains import ConversationalRetrievalChain
from langchain.chat_models import ChatOpenAI
from langchain.vectorstores import Pinecone
import pinecone
from templates.qa_prompt import QA_PROMPT
from templates.condense_prompt import CONDENSE_PROMPT
from dotenv import load_dotenv
load_dotenv()
openai_api_key_env = os.environ.get('OPENAI_API_KEY')
pinecone_api_key_env = os.environ.get('PINECONE_API_KEY')
pinecone_environment_env = os.environ.get('PINECONE_ENVIRONMENT')
pinecone_index_env = os.environ.get('PINECONE_INDEX')
pinecone_namespace = 'testing-pdf-2389203901'
app = Flask("L-ChatBot")
UPLOAD_FOLDER = 'documents'
ALLOWED_EXTENSIONS = {'pdf'}
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
api = Api(app)
parser = reqparse.RequestParser()
def get_answer(message, temperature=0.7, source_amount=4):
chat_history = []
embeddings = OpenAIEmbeddings(
model='text-embedding-ada-002', openai_api_key=openai_api_key_env)
pinecone.init(api_key=pinecone_api_key_env,
environment=pinecone_environment_env)
vectorstore = Pinecone.from_existing_index(
index_name=pinecone_index_env, embedding=embeddings, text_key='text', namespace=pinecone_namespace)
model = ChatOpenAI(model_name='gpt-3.5-turbo', temperature=temperature,
openai_api_key=openai_api_key_env, streaming=False) # max temperature is 2 least is 0
retriever = vectorstore.as_retriever(search_kwargs={
"k": source_amount}, qa_template=QA_PROMPT, question_generator_template=CONDENSE_PROMPT) # 9 is the max sources
qa = ConversationalRetrievalChain.from_llm(
llm=model, retriever=retriever, return_source_documents=True)
result = qa({"question": message, "chat_history": chat_history})
print("Cevap Geldi")
answer = result["answer"]
source_documents = result['source_documents']
parsed_documents = []
for doc in source_documents:
parsed_doc = {
"page_content": doc.page_content,
"metadata": {
"author": doc.metadata.get("author", ""),
"creationDate": doc.metadata.get("creationDate", ""),
"creator": doc.metadata.get("creator", ""),
"file_path": doc.metadata.get("file_path", ""),
"format": doc.metadata.get("format", ""),
"keywords": doc.metadata.get("keywords", ""),
"modDate": doc.metadata.get("modDate", ""),
"page_number": doc.metadata.get("page_number", 0),
"producer": doc.metadata.get("producer", ""),
"source": doc.metadata.get("source", ""),
"subject": doc.metadata.get("subject", ""),
"title": doc.metadata.get("title", ""),
"total_pages": doc.metadata.get("total_pages", 0),
"trapped": doc.metadata.get("trapped", "")
}
}
parsed_documents.append(parsed_doc)
# Display the response in the Streamlit app
return {
"answer": answer,
"meta": parsed_documents
}
########################################################################
class Ask(Resource):
def get(self):
question = request.args.get("question")
temp = request.args.get("temp", default=0.7)
sources = request.args.get("sources", default=4)
return get_answer(question, float(temp), int(sources))
class Ingest(Resource):
def allowed_file(self, filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
def post(self):
# Get Text type fields
if 'file' not in request.files:
return 'No file part'
file = request.files.get("file")
if file and self.allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
loader = DirectoryLoader(
app.config['UPLOAD_FOLDER'], glob="**/*.pdf", loader_cls=PyMuPDFLoader)
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=1000, chunk_overlap=100)
documents = text_splitter.split_documents(documents)
pinecone.init(
api_key=pinecone_api_key_env, # find at app.pinecone.io
environment=pinecone_environment_env # next to api key in console
)
embeddings = OpenAIEmbeddings(
model='text-embedding-ada-002', openai_api_key=openai_api_key_env)
Pinecone.from_documents(
documents, embeddings, index_name=pinecone_index_env, namespace=pinecone_namespace)
return 'File uploaded and ingested successfully'
api.add_resource(Ask, "/ask")
api.add_resource(Ingest, "/ingest")
if __name__ == "__main__":
app.run()
| [
"langchain.document_loaders.DirectoryLoader",
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.chains.ConversationalRetrievalChain.from_llm",
"langchain.vectorstores.Pinecone.from_documents",
"langchain.chat_models.ChatOpenAI",
"langchain.vectorstores.Pinecone.from_existing_index",
"langchain.embeddings.openai.OpenAIEmbeddings"
] | [((718, 731), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (729, 731), False, 'from dotenv import load_dotenv\n'), ((753, 785), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (767, 785), False, 'import os\n'), ((809, 843), 'os.environ.get', 'os.environ.get', (['"""PINECONE_API_KEY"""'], {}), "('PINECONE_API_KEY')\n", (823, 843), False, 'import os\n'), ((871, 909), 'os.environ.get', 'os.environ.get', (['"""PINECONE_ENVIRONMENT"""'], {}), "('PINECONE_ENVIRONMENT')\n", (885, 909), False, 'import os\n'), ((931, 963), 'os.environ.get', 'os.environ.get', (['"""PINECONE_INDEX"""'], {}), "('PINECONE_INDEX')\n", (945, 963), False, 'import os\n'), ((1018, 1036), 'flask.Flask', 'Flask', (['"""L-ChatBot"""'], {}), "('L-ChatBot')\n", (1023, 1036), False, 'from flask import Flask, request\n'), ((1146, 1154), 'flask_restful.Api', 'Api', (['app'], {}), '(app)\n', (1149, 1154), False, 'from flask_restful import Resource, Api, reqparse, abort\n'), ((1165, 1189), 'flask_restful.reqparse.RequestParser', 'reqparse.RequestParser', ([], {}), '()\n', (1187, 1189), False, 'from flask_restful import Resource, Api, reqparse, abort\n'), ((1290, 1378), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'model': '"""text-embedding-ada-002"""', 'openai_api_key': 'openai_api_key_env'}), "(model='text-embedding-ada-002', openai_api_key=\n openai_api_key_env)\n", (1306, 1378), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((1388, 1474), 'pinecone.init', 'pinecone.init', ([], {'api_key': 'pinecone_api_key_env', 'environment': 'pinecone_environment_env'}), '(api_key=pinecone_api_key_env, environment=\n pinecone_environment_env)\n', (1401, 1474), False, 'import pinecone\n'), ((1506, 1639), 'langchain.vectorstores.Pinecone.from_existing_index', 'Pinecone.from_existing_index', ([], {'index_name': 'pinecone_index_env', 'embedding': 'embeddings', 'text_key': '"""text"""', 'namespace': 'pinecone_namespace'}), "(index_name=pinecone_index_env, embedding=\n embeddings, text_key='text', namespace=pinecone_namespace)\n", (1534, 1639), False, 'from langchain.vectorstores import Pinecone\n'), ((1656, 1775), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""', 'temperature': 'temperature', 'openai_api_key': 'openai_api_key_env', 'streaming': '(False)'}), "(model_name='gpt-3.5-turbo', temperature=temperature,\n openai_api_key=openai_api_key_env, streaming=False)\n", (1666, 1775), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2018, 2121), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', ([], {'llm': 'model', 'retriever': 'retriever', 'return_source_documents': '(True)'}), '(llm=model, retriever=retriever,\n return_source_documents=True)\n', (2055, 2121), False, 'from langchain.chains import ConversationalRetrievalChain\n'), ((3647, 3675), 'flask.request.args.get', 'request.args.get', (['"""question"""'], {}), "('question')\n", (3663, 3675), False, 'from flask import Flask, request\n'), ((3691, 3728), 'flask.request.args.get', 'request.args.get', (['"""temp"""'], {'default': '(0.7)'}), "('temp', default=0.7)\n", (3707, 3728), False, 'from flask import Flask, request\n'), ((3747, 3785), 'flask.request.args.get', 'request.args.get', (['"""sources"""'], {'default': '(4)'}), "('sources', default=4)\n", (3763, 3785), False, 'from flask import Flask, request\n'), ((4162, 4187), 'flask.request.files.get', 'request.files.get', (['"""file"""'], {}), "('file')\n", (4179, 4187), False, 'from flask import Flask, request\n'), ((4265, 4295), 'werkzeug.utils.secure_filename', 'secure_filename', (['file.filename'], {}), '(file.filename)\n', (4280, 4295), False, 'from werkzeug.utils import secure_filename\n'), ((4392, 4484), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (["app.config['UPLOAD_FOLDER']"], {'glob': '"""**/*.pdf"""', 'loader_cls': 'PyMuPDFLoader'}), "(app.config['UPLOAD_FOLDER'], glob='**/*.pdf', loader_cls=\n PyMuPDFLoader)\n", (4407, 4484), False, 'from langchain.document_loaders import DirectoryLoader, PyMuPDFLoader\n'), ((4563, 4629), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(100)'}), '(chunk_size=1000, chunk_overlap=100)\n', (4593, 4629), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((4725, 4811), 'pinecone.init', 'pinecone.init', ([], {'api_key': 'pinecone_api_key_env', 'environment': 'pinecone_environment_env'}), '(api_key=pinecone_api_key_env, environment=\n pinecone_environment_env)\n', (4738, 4811), False, 'import pinecone\n'), ((4935, 5023), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'model': '"""text-embedding-ada-002"""', 'openai_api_key': 'openai_api_key_env'}), "(model='text-embedding-ada-002', openai_api_key=\n openai_api_key_env)\n", (4951, 5023), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((5048, 5160), 'langchain.vectorstores.Pinecone.from_documents', 'Pinecone.from_documents', (['documents', 'embeddings'], {'index_name': 'pinecone_index_env', 'namespace': 'pinecone_namespace'}), '(documents, embeddings, index_name=\n pinecone_index_env, namespace=pinecone_namespace)\n', (5071, 5160), False, 'from langchain.vectorstores import Pinecone\n'), ((4318, 4369), 'os.path.join', 'os.path.join', (["app.config['UPLOAD_FOLDER']", 'filename'], {}), "(app.config['UPLOAD_FOLDER'], filename)\n", (4330, 4369), False, 'import os\n')] |
from rich import print
from typing import Any, List
from langchain import LLMChain
from langchain.agents import Tool
from langchain.chat_models import AzureChatOpenAI
from LLMAgent.callbackHandler import CustomHandler
from langchain.callbacks import get_openai_callback
from langchain.memory import ConversationBufferMemory
from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
temp = """
You need to recall the original 'Question' before comming up with a 'Thought'.
2. You need to determine whether the human message is a traffic simulation control command or a question before making any move. If it is a traffic simulation control command, just execute the command and don't do any further information analysis. If it's neither, try to respond to it using your own ability and knowledge as a chat AI
5. Stop calling other tools if you have enough information to answer the questions or already fulfilled the commands explicitly mentioned in the human message.
"""
# prefix = """
# 1. You are a AI to assist human with traffic simulation control or making traffic and transportation decisions.
# 2. You need to determine whether the human message is a traffic simulation control command or a question before making any move. If it is a traffic simulation control command, just execute the command and don't do any further information analysis. If
# 3. You need to remeber the human message exactly. Your only purpose is to complete the task that is explicitly expressed in the human message.
# 4. Whenever you are about to come up with a thought, recall the human message to check if you already have enough information for the final answer. If so, you shouldn't infer or fabricate any more needs or questions based on your own ideas.
# 5. You are forbidden to fabricate any tool names. If you can not find any appropriate tool for your task, try to do it using your own ability and knowledge as a chat AI.
# 6. Remember what tools you have used, DONOT use the same tool repeatedly. Try to use the least amount of tools.
# 7. DONOT fabricate any input parameters when calling tools!
# 8. When you encounter tabular content in Observation, make sure you output the tabular content in markdown format into your final answer.
# 9. When you realize that existing tools are not solving the problem at hand, you need to end your actions and ask the human for more information as your final answer.
# """
# simbot+report
# prefix = """
# [WHO ARE YOU]
# You are a AI to assist human with traffic simulation control, making traffic and transportation decisions, or providing traffic analysis reports. Although you have access to a set of tools, your abilities are not limited to the tools at your disposal
# [YOUR ACTION GUIDLINES]
# 1. You need to determine whether the human message is a traffic simulation control command or a question before making any move. If it is a traffic simulation control command, just execute the command and don't do any further information analysis. If
# 2. You need to remeber the human message exactly. Your only purpose is to complete the task that is explicitly expressed in the human message.
# 3. Whenever you are about to come up with a thought, recall the human message to check if you already have enough information for the final answer. If so, you shouldn't infer or fabricate any more needs or questions based on your own ideas.
# 4. Remember what tools you have used, DONOT use the same tool repeatedly. Try to use the least amount of tools.
# 5. If you can not find any appropriate tool for your task, try to do it using your own ability and knowledge as a chat AI.
# 6. When you encounter tabular content in Observation, make sure you output the tabular content in markdown format into your final answer.
# 7. When you realize that existing tools are not solving the problem at hand, you need to end your actions and ask the human for more information as your final answer.
# [THINGS YOU CANNOT DO]
# You are forbidden to fabricate any tool names.
# You are forbidden to fabricate any input parameters when calling tools!
# [HOW TO GENERATE TRAFFIC REPORTS]
# Act as a human. And provide as much information as possible, including file path and tabular datasets.
# When human need to provede a report of the traffic situation of a road network, they usually start by observing the operation of the network,
# find a few intersections in the network that are in a poor operating condition, as well as their locations, try to optimize them,
# and evaluate which parameters have become better and which ones are worse after the optimization. And form a report of the complete thought process in markdown format.
# For example:
# Macroscopic traffic operations on the entire road network can be viewed on the basis of road network heatmaps: 'replace the correct filepath here'.
# To be more specific, these 5 intersections are in the worst operation status.
# | | Juction_id | speed_avg | volume_avg | timeLoss_avg |
# |---:|-------------:|------------:|-------------:|---------------:|
# | 0 | 4605 | 8.02561 | 734.58 | 8155.83 |
# | 1 | 4471 | 8.11299 | 797.92 | 16500.6 |
# | 2 | 4493 | 8.36199 | 532.26 | 8801.71 |
# | 3 | 4616 | 8.62853 | 898.08 | 5897.33 |
# | 4 | 4645 | 9.38659 | 360.03 | 11689 |
# the locations of these intersections are shown in the map: 'replace the correct filepath here'.
# I tried to optimize the traffic signal shceme of them and run the simulation again.
# The new traffic stauts of these 5 intersections are as follows:
# | | Juction_id | speed_avg | volume_avg | timeLoss_avg |
# |---:|-------------:|------------:|-------------:|---------------:|
# | 0 | 4605 | 5.02561 | 1734.58 | 9155.83 |
# | 1 | 4471 | 5.11299 | 1797.92 | 17500.6 |
# | 2 | 4493 | 5.36199 | 1532.26 | 9901.71 |
# | 3 | 4616 | 5.62853 | 1898.08 | 6897.33 |
# | 4 | 4645 | 5.38659 | 1360.03 | 13689 |
# According to the data above, after optimization, Traffic volume has increased at these intersections, but average speeds have slowed and time loss have become greater.
# """
suffix = """Begin!"
{chat_history}
Question: {input}
{agent_scratchpad}"""
class ConversationBot:
def __init__(
self, llm: AzureChatOpenAI, toolModels: List,
customedPrefix: str, verbose: bool = False
) -> Any:
self.ch = CustomHandler()
tools = []
for ins in toolModels:
func = getattr(ins, 'inference')
tools.append(
Tool(
name=func.name,
description=func.description,
func=func
)
)
prompt = ZeroShotAgent.create_prompt(
tools,
prefix=customedPrefix,
suffix=suffix,
input_variables=["input", "chat_history", "agent_scratchpad"],
)
self.agent_memory = ConversationBufferMemory(memory_key="chat_history")
llm_chain = LLMChain(llm=llm, prompt=prompt)
agent = ZeroShotAgent(
llm_chain=llm_chain,
tools=tools, verbose=verbose
)
self.agent_chain = AgentExecutor.from_agent_and_tools(
agent=agent, tools=tools,
verbose=verbose, memory=self.agent_memory,
handle_parsing_errors="Use the LLM output directly as your final answer!"
)
def dialogue(self, input: str):
print('TransGPT is running, Please wait for a moment...')
with get_openai_callback() as cb:
res = self.agent_chain.run(input=input, callbacks=[self.ch])
# print('History: ', self.agent_memory.buffer)
return res, cb
| [
"langchain.agents.AgentExecutor.from_agent_and_tools",
"langchain.LLMChain",
"langchain.agents.ZeroShotAgent.create_prompt",
"langchain.agents.ZeroShotAgent",
"langchain.memory.ConversationBufferMemory",
"langchain.callbacks.get_openai_callback",
"langchain.agents.Tool"
] | [((6579, 6594), 'LLMAgent.callbackHandler.CustomHandler', 'CustomHandler', ([], {}), '()\n', (6592, 6594), False, 'from LLMAgent.callbackHandler import CustomHandler\n'), ((6905, 7044), 'langchain.agents.ZeroShotAgent.create_prompt', 'ZeroShotAgent.create_prompt', (['tools'], {'prefix': 'customedPrefix', 'suffix': 'suffix', 'input_variables': "['input', 'chat_history', 'agent_scratchpad']"}), "(tools, prefix=customedPrefix, suffix=suffix,\n input_variables=['input', 'chat_history', 'agent_scratchpad'])\n", (6932, 7044), False, 'from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n'), ((7128, 7179), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""'}), "(memory_key='chat_history')\n", (7152, 7179), False, 'from langchain.memory import ConversationBufferMemory\n'), ((7201, 7233), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (7209, 7233), False, 'from langchain import LLMChain\n'), ((7250, 7314), 'langchain.agents.ZeroShotAgent', 'ZeroShotAgent', ([], {'llm_chain': 'llm_chain', 'tools': 'tools', 'verbose': 'verbose'}), '(llm_chain=llm_chain, tools=tools, verbose=verbose)\n', (7263, 7314), False, 'from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n'), ((7376, 7564), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'agent', 'tools': 'tools', 'verbose': 'verbose', 'memory': 'self.agent_memory', 'handle_parsing_errors': '"""Use the LLM output directly as your final answer!"""'}), "(agent=agent, tools=tools, verbose=\n verbose, memory=self.agent_memory, handle_parsing_errors=\n 'Use the LLM output directly as your final answer!')\n", (7410, 7564), False, 'from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n'), ((7646, 7703), 'rich.print', 'print', (['"""TransGPT is running, Please wait for a moment..."""'], {}), "('TransGPT is running, Please wait for a moment...')\n", (7651, 7703), False, 'from rich import print\n'), ((7717, 7738), 'langchain.callbacks.get_openai_callback', 'get_openai_callback', ([], {}), '()\n', (7736, 7738), False, 'from langchain.callbacks import get_openai_callback\n'), ((6733, 6794), 'langchain.agents.Tool', 'Tool', ([], {'name': 'func.name', 'description': 'func.description', 'func': 'func'}), '(name=func.name, description=func.description, func=func)\n', (6737, 6794), False, 'from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n')] |
from langchain_app.models.http_llm import HTTPBaseLLM
def default_parameters():
return {"temperature": 0, "max_new_tokens": 256, "stop": ["Observation:"]}
def build_llama_base_llm(prompt_url="http://127.0.0.1:8000/prompt", parameters=None):
if parameters is None:
parameters = default_parameters()
return HTTPBaseLLM(prompt_url=prompt_url, parameters=parameters)
| [
"langchain_app.models.http_llm.HTTPBaseLLM"
] | [((330, 387), 'langchain_app.models.http_llm.HTTPBaseLLM', 'HTTPBaseLLM', ([], {'prompt_url': 'prompt_url', 'parameters': 'parameters'}), '(prompt_url=prompt_url, parameters=parameters)\n', (341, 387), False, 'from langchain_app.models.http_llm import HTTPBaseLLM\n')] |
from langchain.llms import LlamaCpp
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
def hf_embeddings():
return HuggingFaceEmbeddings(
model_name = "sentence-transformers/all-mpnet-base-v2",
)
def code_llama():
callbackmanager = CallbackManager([StreamingStdOutCallbackHandler()])
llm = LlamaCpp(
model_path="./models/codellama-7b.Q4_K_M.gguf",
n_ctx=2048,
max_tokens=200,
n_gpu_layers=1,
f16_kv=True,
callback_manager=callbackmanager,
verbose=True,
use_mlock=True
)
return llm | [
"langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler",
"langchain.llms.LlamaCpp",
"langchain.embeddings.HuggingFaceEmbeddings"
] | [((260, 335), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""sentence-transformers/all-mpnet-base-v2"""'}), "(model_name='sentence-transformers/all-mpnet-base-v2')\n", (281, 335), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((456, 642), 'langchain.llms.LlamaCpp', 'LlamaCpp', ([], {'model_path': '"""./models/codellama-7b.Q4_K_M.gguf"""', 'n_ctx': '(2048)', 'max_tokens': '(200)', 'n_gpu_layers': '(1)', 'f16_kv': '(True)', 'callback_manager': 'callbackmanager', 'verbose': '(True)', 'use_mlock': '(True)'}), "(model_path='./models/codellama-7b.Q4_K_M.gguf', n_ctx=2048,\n max_tokens=200, n_gpu_layers=1, f16_kv=True, callback_manager=\n callbackmanager, verbose=True, use_mlock=True)\n", (464, 642), False, 'from langchain.llms import LlamaCpp\n'), ((411, 443), 'langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler', 'StreamingStdOutCallbackHandler', ([], {}), '()\n', (441, 443), False, 'from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n')] |
import os
import yaml
from types import SimpleNamespace
import openai
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from langchain.vectorstores import FAISS
from langchain.embeddings import HuggingFaceEmbeddings
with open("config.yml") as f:
config = yaml.safe_load(f)
config = SimpleNamespace(**config)
os.environ["TOKENIZERS_PARALLELISM"] = "false"
def semantic_search(query_embedding, embeddings):
"""Manual similarity search (deprecated in favor of langchain)."""
similarities = cosine_similarity([query_embedding], embeddings)[0]
ranked_indices = np.argsort(-similarities)
return ranked_indices
def answer_question(context, query, model="gpt-3.5-turbo", max_tokens=None, temperature=config.temperature):
system_prompt = """
You are a truthful and accurate scientific research assistant.
You can write equations in LaTeX.
You can fix any unknown LaTeX syntax elements. Do not use the \enumerate. \itemize, \cite, \ref LaTex environments.
You are an expert and helpful programmer and write correct code.
If parts of the context are not relevant to the question, ignore them.
Only answer if you are absolutely confident in the answer. Do not make up any facts. Do not make up what acronyms stand for.
"""
if context is not None and len(context) > 0:
prompt = f"Use the following context to answer the question at the end. If parts of the context are not relevant to the question, ignore them. Context: {context}. Question: {query}"
else:
prompt = f"Question: {query}"
try:
response = openai.ChatCompletion.create(
model=model,
messages=[{"role": "system", "content": system_prompt}, {"role": "user", "content": prompt}],
max_tokens=max_tokens,
n=1,
temperature=temperature,
)
return response["choices"][0]["message"]["content"]
except (openai.error.AuthenticationError, openai.error.APIError) as e:
return "Authentication error."
except (openai.error.APIError, openai.error.Timeout, openai.error.ServiceUnavailableError) as e:
return "There was an error with the OpenAI API, or the request timed out."
except openai.error.APIConnectionError as e:
return "Issue connecting to the OpenAI API."
except Exception as e:
return "An error occurred: {}".format(e)
def run(query, model="gpt-3.5-turbo", api_key=None, query_papers=True, k=config.top_k, max_len_query=300):
if api_key is None:
openai.api_key = os.getenv("OPENAI_API_KEY")
else:
openai.api_key = api_key
db_path = "./data/db/faiss_index"
embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/multi-qa-mpnet-base-dot-v1")
files = [db_path]
is_missing = False
for file in files:
if not os.path.exists(file):
print(f"{file} does not exist")
is_missing = True
else:
# Load FAISS index
db = FAISS.load_local(db_path, embeddings)
# If set, don't query papers; pretend they don't exist
if not query_papers:
is_missing = True
if not query:
return "Please enter your question above, and I'll do my best to help you."
if len(query) > max_len_query:
return "Please ask a shorter question!"
else:
# Do a similarity query, combine the most relevant chunks, and answer the question
if not is_missing:
similarity_results = db.similarity_search(query, k=k)
most_relevant_chunk = ". ".join([results.page_content for results in similarity_results])
answer = answer_question(context=most_relevant_chunk, query=query, model=model)
answer.strip("\n")
return answer
else:
answer = answer_question(context=None, query=query, model=model)
answer.strip("\n")
return answer
| [
"langchain.embeddings.HuggingFaceEmbeddings",
"langchain.vectorstores.FAISS.load_local"
] | [((313, 338), 'types.SimpleNamespace', 'SimpleNamespace', ([], {}), '(**config)\n', (328, 338), False, 'from types import SimpleNamespace\n'), ((286, 303), 'yaml.safe_load', 'yaml.safe_load', (['f'], {}), '(f)\n', (300, 303), False, 'import yaml\n'), ((602, 627), 'numpy.argsort', 'np.argsort', (['(-similarities)'], {}), '(-similarities)\n', (612, 627), True, 'import numpy as np\n'), ((2699, 2788), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""sentence-transformers/multi-qa-mpnet-base-dot-v1"""'}), "(model_name=\n 'sentence-transformers/multi-qa-mpnet-base-dot-v1')\n", (2720, 2788), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((529, 577), 'sklearn.metrics.pairwise.cosine_similarity', 'cosine_similarity', (['[query_embedding]', 'embeddings'], {}), '([query_embedding], embeddings)\n', (546, 577), False, 'from sklearn.metrics.pairwise import cosine_similarity\n'), ((1617, 1813), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'model', 'messages': "[{'role': 'system', 'content': system_prompt}, {'role': 'user', 'content':\n prompt}]", 'max_tokens': 'max_tokens', 'n': '(1)', 'temperature': 'temperature'}), "(model=model, messages=[{'role': 'system',\n 'content': system_prompt}, {'role': 'user', 'content': prompt}],\n max_tokens=max_tokens, n=1, temperature=temperature)\n", (1645, 1813), False, 'import openai\n'), ((2571, 2598), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (2580, 2598), False, 'import os\n'), ((2869, 2889), 'os.path.exists', 'os.path.exists', (['file'], {}), '(file)\n', (2883, 2889), False, 'import os\n'), ((3027, 3064), 'langchain.vectorstores.FAISS.load_local', 'FAISS.load_local', (['db_path', 'embeddings'], {}), '(db_path, embeddings)\n', (3043, 3064), False, 'from langchain.vectorstores import FAISS\n')] |
from langchain.agents import load_tools
from langchain.agents import initialize_agent
from langchain.agents import AgentType
from langchain_app.models.vicuna_request_llm import VicunaLLM
# First, let's load the language model we're going to use to control the agent.
llm = VicunaLLM()
# Next, let's load some tools to use. Note that the `llm-math` tool uses an LLM, so we need to pass that in.
tools = load_tools(["python_repl"], llm=llm)
# Finally, let's initialize an agent with the tools, the language model, and the type of agent we want to use.
agent = initialize_agent(
tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
# Now let's test it out!
agent.run("""Write a Python script that prints 'Hello, world!""")
| [
"langchain_app.models.vicuna_request_llm.VicunaLLM",
"langchain.agents.initialize_agent",
"langchain.agents.load_tools"
] | [((275, 286), 'langchain_app.models.vicuna_request_llm.VicunaLLM', 'VicunaLLM', ([], {}), '()\n', (284, 286), False, 'from langchain_app.models.vicuna_request_llm import VicunaLLM\n'), ((405, 441), 'langchain.agents.load_tools', 'load_tools', (["['python_repl']"], {'llm': 'llm'}), "(['python_repl'], llm=llm)\n", (415, 441), False, 'from langchain.agents import load_tools\n'), ((562, 653), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': 'AgentType.ZERO_SHOT_REACT_DESCRIPTION', 'verbose': '(True)'}), '(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,\n verbose=True)\n', (578, 653), False, 'from langchain.agents import initialize_agent\n')] |
import logging
import sys
from typing import Callable
from langchain.prompts import MessagesPlaceholder
from langchain.agents import AgentType, AgentExecutor
from langchain.agents import initialize_agent as initialize_agent_base
from langchain.agents.agent_toolkits.base import BaseToolkit
from langchain.chains.base import Chain
logger = logging.getLogger(__name__)
def initialize_agent(agent: AgentType, **kwargs) -> Chain:
"""
Extended version of the initialize_agent function from ix.chains.agents.
Modifications:
- unpacks agent_kwargs: allows agent_kwargs to be flattened into the ChainNode config
A flattened config simplifies the UX integration such that it works with TypeAutoFields
"""
# Inject placeholders into prompt for memory if provided
placeholders = []
if memories := kwargs.get("memory", None):
if not isinstance(memories, list):
memories = [memories]
placeholders = []
for component in memories:
if not getattr(component, "return_messages", False):
raise ValueError(
f"Memory component {component} has return_messages=False. Agents require "
f"return_messages=True."
)
for memory_key in component.memory_variables:
placeholders.append(MessagesPlaceholder(variable_name=memory_key))
# Re-pack agent_kwargs__* arguments into agent_kwargs
agent_kwargs = {
"extra_prompt_messages": placeholders,
}
for key, value in kwargs.items():
if key.startswith("agent_kwargs__"):
agent_kwargs[key[15:]] = value
del kwargs[key]
kwargs["agent_kwargs"] = agent_kwargs
# unpack Toolkits into Tools
if "tools" in kwargs:
tools = kwargs["tools"]
unpacked_tools = []
for i, value in enumerate(tools):
if isinstance(value, BaseToolkit):
unpacked_tools.extend(value.get_tools())
else:
unpacked_tools.append(value)
kwargs["tools"] = unpacked_tools
return initialize_agent_base(agent=agent, **kwargs)
def create_init_func(agent_type: AgentType) -> Callable:
"""
This function creates a new initialization function for a given agent type. The initialization
function is a proxy to the initialize_agent function, but it has a distinct name and can be
imported directly from this module.
Agent initialization functions are used so there is a distinct class_path for each agent type.
This allows class_path to be used as an identifier for the agent type.
Args:
agent_type (str): The type of the agent to create an initialization function for.
Returns:
function: The newly created initialization function.
"""
def init_func(**kwargs) -> AgentExecutor:
return initialize_agent(agent=agent_type, **kwargs)
return init_func
# list of function names that are created, used for debugging
FUNCTION_NAMES = []
def create_functions() -> None:
"""
Generate initialization functions for each agent type and add them to this module.
This will automatically create a new function for each agent type as LangChain
creates them.
"""
for agent_type in AgentType:
# create an initialization function for this agent type
init_func = create_init_func(agent_type)
func_name = "initialize_" + agent_type.value.replace("-", "_")
FUNCTION_NAMES.append(func_name)
# add the function to the current module
setattr(sys.modules[__name__], func_name, init_func)
# auto-run the function that creates the initialization functions
create_functions()
| [
"langchain.agents.initialize_agent",
"langchain.prompts.MessagesPlaceholder"
] | [((343, 370), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (360, 370), False, 'import logging\n'), ((2107, 2151), 'langchain.agents.initialize_agent', 'initialize_agent_base', ([], {'agent': 'agent'}), '(agent=agent, **kwargs)\n', (2128, 2151), True, 'from langchain.agents import initialize_agent as initialize_agent_base\n'), ((1348, 1393), 'langchain.prompts.MessagesPlaceholder', 'MessagesPlaceholder', ([], {'variable_name': 'memory_key'}), '(variable_name=memory_key)\n', (1367, 1393), False, 'from langchain.prompts import MessagesPlaceholder\n')] |
import os
os.environ["LANGCHAIN_TRACING"] = "true"
from langchain import OpenAI
from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
def multiplier(a, b):
return a / b
def parsing_multiplier(string):
a, b = string.split(",")
return multiplier(int(a), int(b))
llm = OpenAI(temperature=0)
tools = [
Tool(
name="Multiplier",
func=parsing_multiplier,
description="useful for when you need to multiply two numbers together. The input to this tool should be a comma separated list of numbers of length two, representing the two numbers you want to multiply together. For example, `1,2` would be the input if you wanted to multiply 1 by 2.",
)
]
agent = initialize_agent(
tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
agent.run("3 times four?")
| [
"langchain.agents.initialize_agent",
"langchain.llms.OpenAI",
"langchain.agents.Tool"
] | [((412, 433), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (418, 433), False, 'from langchain.llms import OpenAI\n'), ((826, 917), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': 'AgentType.ZERO_SHOT_REACT_DESCRIPTION', 'verbose': '(True)'}), '(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,\n verbose=True)\n', (842, 917), False, 'from langchain.agents import initialize_agent, Tool\n'), ((448, 794), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""Multiplier"""', 'func': 'parsing_multiplier', 'description': '"""useful for when you need to multiply two numbers together. The input to this tool should be a comma separated list of numbers of length two, representing the two numbers you want to multiply together. For example, `1,2` would be the input if you wanted to multiply 1 by 2."""'}), "(name='Multiplier', func=parsing_multiplier, description=\n 'useful for when you need to multiply two numbers together. The input to this tool should be a comma separated list of numbers of length two, representing the two numbers you want to multiply together. For example, `1,2` would be the input if you wanted to multiply 1 by 2.'\n )\n", (452, 794), False, 'from langchain.agents import initialize_agent, Tool\n')] |
# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
from typing import List
from langchain.chains import RetrievalQA
from langchain.chains.conversational_retrieval.base import (
BaseConversationalRetrievalChain,
)
from langchain.llms.vertexai import VertexAI
from langchain.memory import ConversationBufferMemory
from langchain.tools import BaseTool
current_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.append(current_dir)
from MyVertexAIEmbedding import MyVertexAIEmbedding # noqa: E402
from VertexMatchingEngine import MatchingEngine, MatchingEngineUtils # noqa: E402
# https://cdn.cloudflare.steamstatic.com/steam/apps/597180/manuals/Old_World-Official_User_Manual.pdf?t=1653279974
"""
Matching Engine As Retriever
"""
ME_REGION = os.getenv("GOOGLE_CLOUD_REGIN")
PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
ME_INDEX_NAME = f"{PROJECT_ID}-chatbot-vme"
ME_DIMENSIONS = 768
ME_EMBEDDING_DIR = f"gs://{PROJECT_ID}-chatbot-embeddings"
REQUESTS_PER_MINUTE = 15
mengine = MatchingEngineUtils(
project_id=PROJECT_ID, region=ME_REGION, index_name=ME_INDEX_NAME
)
embedding = MyVertexAIEmbedding()
llm = VertexAI()
memory = ConversationBufferMemory()
def create_PDFQA_chain_me_RetrievalQA() -> BaseConversationalRetrievalChain:
mengine = MatchingEngineUtils(
project_id=PROJECT_ID, region=ME_REGION, index_name=ME_INDEX_NAME
)
ME_INDEX_ID, ME_INDEX_ENDPOINT_ID = mengine.get_index_and_endpoint()
me = MatchingEngine.from_components(
project_id=PROJECT_ID,
region=ME_REGION,
gcs_bucket_name=f'gs://{ME_EMBEDDING_DIR.split("/")[2]}',
embedding=embedding,
index_id=ME_INDEX_ID,
endpoint_id=ME_INDEX_ENDPOINT_ID,
)
retriever = me.as_retriever()
doc_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff",
retriever=retriever,
return_source_documents=False,
verbose=True,
)
return doc_chain
class VIAI_INFO_ME(BaseTool):
name = "VIAI_INFO_ME"
description = """
Use this tool to get information regarding the solution "Visual Inspection AI Edge", or "VIAI Edge".
The Tool Input is the user's question, the user may reference to previous convsation,
add context to the question when needed.
The Output is the result
"""
def _run(self, query: str) -> str:
if query == "":
query = "summarize"
chat_history: List[str] = []
print("Running tool:{}".format(query))
qa = create_PDFQA_chain_me_RetrievalQA()
result = qa(
{"query": query, "chat_history": chat_history}, return_only_outputs=False
)
return result
async def _arun(self, query: str) -> str:
"""Use the tool asynchronously."""
print(f"*** Invoking MockTool with query '{query}'")
return f"Answer of '{query}' is 'Michael Chi'"
| [
"langchain.llms.vertexai.VertexAI",
"langchain.memory.ConversationBufferMemory",
"langchain.chains.RetrievalQA.from_chain_type"
] | [((957, 985), 'sys.path.append', 'sys.path.append', (['current_dir'], {}), '(current_dir)\n', (972, 985), False, 'import sys\n'), ((1302, 1333), 'os.getenv', 'os.getenv', (['"""GOOGLE_CLOUD_REGIN"""'], {}), "('GOOGLE_CLOUD_REGIN')\n", (1311, 1333), False, 'import os\n'), ((1347, 1380), 'os.getenv', 'os.getenv', (['"""GOOGLE_CLOUD_PROJECT"""'], {}), "('GOOGLE_CLOUD_PROJECT')\n", (1356, 1380), False, 'import os\n'), ((1540, 1631), 'VertexMatchingEngine.MatchingEngineUtils', 'MatchingEngineUtils', ([], {'project_id': 'PROJECT_ID', 'region': 'ME_REGION', 'index_name': 'ME_INDEX_NAME'}), '(project_id=PROJECT_ID, region=ME_REGION, index_name=\n ME_INDEX_NAME)\n', (1559, 1631), False, 'from VertexMatchingEngine import MatchingEngine, MatchingEngineUtils\n'), ((1645, 1666), 'MyVertexAIEmbedding.MyVertexAIEmbedding', 'MyVertexAIEmbedding', ([], {}), '()\n', (1664, 1666), False, 'from MyVertexAIEmbedding import MyVertexAIEmbedding\n'), ((1674, 1684), 'langchain.llms.vertexai.VertexAI', 'VertexAI', ([], {}), '()\n', (1682, 1684), False, 'from langchain.llms.vertexai import VertexAI\n'), ((1694, 1720), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {}), '()\n', (1718, 1720), False, 'from langchain.memory import ConversationBufferMemory\n'), ((930, 955), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (945, 955), False, 'import os\n'), ((1814, 1905), 'VertexMatchingEngine.MatchingEngineUtils', 'MatchingEngineUtils', ([], {'project_id': 'PROJECT_ID', 'region': 'ME_REGION', 'index_name': 'ME_INDEX_NAME'}), '(project_id=PROJECT_ID, region=ME_REGION, index_name=\n ME_INDEX_NAME)\n', (1833, 1905), False, 'from VertexMatchingEngine import MatchingEngine, MatchingEngineUtils\n'), ((2311, 2438), 'langchain.chains.RetrievalQA.from_chain_type', 'RetrievalQA.from_chain_type', ([], {'llm': 'llm', 'chain_type': '"""stuff"""', 'retriever': 'retriever', 'return_source_documents': '(False)', 'verbose': '(True)'}), "(llm=llm, chain_type='stuff', retriever=\n retriever, return_source_documents=False, verbose=True)\n", (2338, 2438), False, 'from langchain.chains import RetrievalQA\n')] |
import boto3
from botocore.exceptions import ClientError
import json
import langchain
from importlib import reload
from langchain.agents.structured_chat import output_parser
from typing import List
import logging
import os
import sqlalchemy
from sqlalchemy import create_engine
from langchain.docstore.document import Document
from langchain import PromptTemplate,SQLDatabase, LLMChain
from langchain_experimental.sql.base import SQLDatabaseChain
from langchain.prompts.prompt import PromptTemplate
import streamlit as st
import pandas as pd
import datetime
from langchain.tools import tool
from typing import List, Optional
import json
from langchain.prompts import (
ChatPromptTemplate,
PromptTemplate,
SystemMessagePromptTemplate,
AIMessagePromptTemplate,
HumanMessagePromptTemplate,
)
from langchain.llms.bedrock import Bedrock
from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner
from langchain.agents.tools import Tool
import time
import uuid
from utility import get_cfn_details,custom_logga, upload_amz_file
from langchain.tools.python.tool import PythonREPLTool
from langchain.memory import ConversationBufferMemory
from langchain.memory.chat_message_histories import DynamoDBChatMessageHistory
from streamlit.web.server.websocket_headers import _get_websocket_headers
import sys
st.set_page_config(layout="wide")
# logger = logging.getLogger('sagemaker')
# logger.setLevel(logging.DEBUG)
# logger.addHandler(logging.StreamHandler())
sys.stdout = custom_logga.Logger()
#Session states to hold sateful variables
if 'generated' not in st.session_state:
st.session_state['generated'] = []
if 'past' not in st.session_state:
st.session_state['past'] = []
if 'messages' not in st.session_state:
st.session_state['messages'] = []
if 'ant_key' not in st.session_state:
st.session_state['ant_key'] = ''
if 'chat_id' not in st.session_state:
st.session_state['chat_id'] = 1
if 'client_id' not in st.session_state:
st.session_state['client_id'] = ''
if 'prompt' not in st.session_state:
st.session_state['prompt'] = ''
if 'memory' not in st.session_state:
st.session_state['memory'] = ""
# Global Variables
STACK_NAME="mmfsi" #change to the name of the cloudformation stack
REGION='us-east-1' #change to the name of the region you are working in
if len(st.session_state['messages'])<1:
## browser client info
headers = _get_websocket_headers()
st.session_state['client_id'] = str(headers.get("Sec-Websocket-Key"))
#print(f"Client KEY {st.session_state['client_id']}")
#st.session_state['ant_key']= get_secret()(REGION, "Secrete Name") ## PASS the AWS SECRETES secrete name
st.session_state['chat_id']= st.session_state['chat_id']+1
#print(f"Session Chat ID {st.session_state['chat_id']}")
# get cfn parameters
glue_db_name,kendra_index_id,audio_transcripts_source_bucket,textract_source_bucket,query_staging_bucket,multimodal_output_bucket=get_cfn_details.stack_info(STACK_NAME,REGION)
param={}
param['db']=glue_db_name
param['query_bucket']=query_staging_bucket
param['region']=REGION
param['kendra_id']=kendra_index_id#'45739a4f-c80f-4201-b183-20389d0febc7'
#Store parameters in json file
with open('param.json', 'w', encoding='utf-8') as f:
json.dump(param, f, ensure_ascii=False, indent=4)
# upload files to s3
#from utility.upload_amz_file import upload_file_amz
upload_amz_file.upload_file_amz('files/Amazon-10K-2022-EarningsReport.pdf', textract_source_bucket)
upload_amz_file.upload_file_amz('files/Amazon-10Q-Q1-2023-QuaterlyEarningsReport.pdf', textract_source_bucket)
upload_amz_file.upload_file_amz('files/Amazon-Quarterly-Earnings-Report-Q1-2023-Full-Call-v1.mp3', audio_transcripts_source_bucket)
#Athena connection config
connathena=f"athena.{REGION}.amazonaws.com"
portathena='443' #Update, if port is different
schemaathena=glue_db_name #from user defined params
s3stagingathena=f's3://{query_staging_bucket}/athenaresults/'#from cfn params
wkgrpathena='primary'#Update, if workgroup is different
## Create the athena connection string
connection_string = f"awsathena+rest://@{connathena}:{portathena}/{schemaathena}?s3_staging_dir={s3stagingathena}&work_group={wkgrpathena}"
## Create the athena SQLAlchemy engine
engine_athena = create_engine(connection_string, echo=False)
dbathena = SQLDatabase(engine_athena)
from botocore.config import Config
config = Config(
retries = dict(
max_attempts = 10
)
)
from utility import stock_query_mm, kendra_tool_mm, aws_tools, portfolio_tool
inference_modifier = {
'max_tokens_to_sample':512,
"temperature":0.01,
"stop_sequences":["\n\nQuestion:","\n\nHuman:","\nHuman:"]#"\n\nAssistant:","\nAssistant:"]#,"\nHuman:"]#,"\n\nAssistant:","\nAssistant:"],
# "top_k": 50,
# "top_p": 1,
}
llm = llm = Bedrock(model_id='anthropic.claude-v2',model_kwargs =inference_modifier )
table = 'stock_prices'
session_id=st.session_state['client_id']
chat_id= st.session_state['chat_id']
#persist dynamodb table id for chat history for each session and browser client
@st.cache_data
def db_table_id(session_id, chat_id):
chat_sess_id=str(uuid.uuid4())
return chat_sess_id
chat_session_id=db_table_id(session_id, chat_id)
#print(f"Chat SESSION ID {chat_session_id}")
def run_query(query):
PROMPT_sql = PromptTemplate(
input_variables=["input", "table_info", "dialect"], template=_DEFAULT_TEMPLATE
)
db_chain = SQLDatabaseChain.from_llm(llm, dbathena, prompt=PROMPT_sql, verbose=True, return_intermediate_steps=False)
response=db_chain.run(query)
return response
def SentimentAnalysis(inputString):
print(inputString)
lambda_client = boto3.client('lambda', region_name=REGION)
lambda_payload = {"inputString:"+inputString}
response=lambda_client.invoke(FunctionName='FSI-SentimentDetecttion',
InvocationType='RequestResponse',
Payload=json.dumps(inputString))
#print(response['Payload'].read())
output=json.loads(response['Payload'].read().decode())
return output['body']
def DetectKeyPhrases(inputString):
#print(inputString)
lambda_client = boto3.client('lambda', region_name=REGION)
lambda_payload = {"inputString:"+inputString}
response=lambda_client.invoke(FunctionName='FSI-KeyPhrasesDetection',
InvocationType='RequestResponse',
Payload=json.dumps(inputString))
#print(response['Payload'].read())
output=json.loads(response['Payload'].read().decode())
return output['body']
tools = [
Tool(
name="Stock Querying Tool",
func=stock_query_mm.run_query,
description="""
Useful for when you need to answer questions about stocks. It only has information about stocks.
"""
),
portfolio_tool.OptimizePortfolio(),
Tool(
name="Financial Information Lookup Tool",
func=kendra_tool_mm.run_chain,
description="""
Useful for when you need to look up financial information like revenues, sales, loss, risks etc.
"""
),
PythonREPLTool(),
Tool(
name="Sentiment Analysis Tool",
func=SentimentAnalysis,
description="""
Useful for when you need to analyze the sentiment of an excerpt from a financial report.
"""
),
Tool(
name="Detect Phrases Tool",
func=DetectKeyPhrases,
description="""
Useful for when you need to detect key phrases in financial reports.
"""
),
Tool(
name="Text Extraction Tool",
func=aws_tools.IntiateTextExtractProcessing,
description="""
Useful for when you need to trigger conversion of pdf version of quaterly reports to text files using amazon textextract
"""
),
Tool(
name="Transcribe Audio Tool",
func=aws_tools.TranscribeAudio,
description="""
Useful for when you need to convert audio recordings of earnings calls from audio to text format using Amazon Transcribe
"""
)
]
combo_template = """\n\nHuman:
You are a Minimization Solutionist with a set of tools at your disposal.
You would be presented with a problem. First understand the problem and devise a plan to solve the problem.
Please output the plan starting with the header 'Plan:' and then followed by a numbered list of steps.
Ensure the plan has the minimum amount of steps needed to solve the problem. Do not include unnecessary steps.
<instructions>
These are guidance on when to use a tool to solve a task, follow them strictly:
1. For the tool that specifically focuses on stock price data, use "Stock Query Tool".
2. For financial information lookup that covers various financial data like company's finance, performance or any other information pertaining a company beyond stocks, use the "Financial Data Explorer Tool". Ask specific questions using this tool as it is your knowledge database. Refrain from asking question like "look up 10K filings" instead a more specific question like "what is the revenue for this company".
3. When you need to find key phrases in a report, use the "Detect Phrases Tool" to get the information about all key phrases and respond with key phrases relavent to the question.
4. When you need to provide an optimized stock portfolio based on stock names, use Portfolio Optimization Tool. The output is the percent of fund you should spend on each stock. This tool only takes stock ticker as input and not stock prices, for example ["EWR","JHT"].
5. Please use the PythonREPLTool exclusively for calculations, refrain from utilizing 'print' statements for output. Use this too only when needed, most times its unnecessary.
6. When you need to analyze sentiment of a topic, use "Sentiment Analysis Tool".
</instructions>\n\nAssistant:"""
combo_template=combo_template if st.session_state['prompt']=="" else st.session_state['prompt']
chat_history_table = 'DYNAMODB table name' ### SPECIFY THE DYNAMODB TABLE
chat_history_memory = DynamoDBChatMessageHistory(table_name=chat_history_table, session_id=chat_session_id)
model = llm
planner = load_chat_planner(model)
system_message_prompt = SystemMessagePromptTemplate.from_template(combo_template)
human_message_prompt = planner.llm_chain.prompt.messages[1]
planner.llm_chain.prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
executor = load_agent_executor(model, tools, verbose=True)
if st.session_state['memory']:
memory = ConversationBufferMemory(memory_key="chat_history", chat_memory=chat_history_memory, return_messages=True)
agent = PlanAndExecute(planner=planner, executor=executor, verbose=True, max_iterations=2, memory=memory)
else:
agent = PlanAndExecute(planner=planner, executor=executor, verbose=True, max_iterations=2)#, memory=memory)
def query(request, agent, chat_history_memory):
output=agent(request)
chat_history_memory.add_ai_message(str(output))
try:
return output['output']
except:
return output
def action_doc(agent, chat_history_memory):
st.title('Multi-Modal Agent to assist Financial Analyst')
# Display chat messages from history on app rerun
for message in st.session_state.messages:
if "role" in message.keys():
with st.chat_message(message["role"]):
st.markdown(message['content'].replace("$","USD ").replace("%", " percent"))
else:
with st.expander(label="**Intermediate Steps**"):
st.write(message["steps"])
if prompt := st.chat_input("Hello?"):
st.session_state.messages.append({"role": "user", "content": prompt})
with st.chat_message("user"):
st.markdown(prompt)
with st.chat_message("assistant"):
message_placeholder = st.empty()
output_answer=query(prompt, agent, chat_history_memory)
message_placeholder.markdown(output_answer.replace("$","USD ").replace("%", " percent"))
st.session_state.messages.append({"role": "assistant", "content": output_answer})
# Saving the intermediate steps in a logf file to be shown in the UI. This is a hack due to the inability to capture these steps with the agent planner and executor library being used
with st.expander(label="**Intermediate Steps**"):
with open('logfile.txt','r')as f:
steps=f.readlines()
st.write(steps)
os.remove('logfile.txt')
st.session_state.messages.append({"steps": steps})
def app_sidebar():
with st.sidebar:
st.write('## How to use:')
description = """This app lets you query multi-modal documents and get relevant answers.
Documents inculde DB Tables, audio files and pdf files.
Type your query in the chat box to get appropiate answers.
If you need to refresh session, click on the `Clear Session` button.
Happy QnA :)
"""
st.markdown(description)
st.write('---')
st.write('## Sample Questions')
st.markdown("""
- What are the closing prices of stocks AAAA, WWW, DDD in year 2018? Can you build an optimized portfolio using these three stocks? Please provide answers to both questions.
- What is the net sales for Amazon in 2021 and 2022? What is the percent difference?
- What are the biggest risks facing Amazon Inc?
""")
st.markdown("""
**Datasets**
- [Quterly Earnings recordings](https://github.com/revdotcom/speech-datasets)
- [Annual Reports (FinTabNet)](https://developer.ibm.com/exchanges/data/all/fintabnet/)
- [S&P 500 stock data](https://www.kaggle.com/camnugent/sandp500)
""")
st.write('---')
#st.write('Pass your custom prompt')
user_input = st.text_area("Custom prompt goes here", "")
if user_input:
st.session_state['prompt']=user_input
print(user_input)
use_memory=''
mem = st.checkbox('Conversation Memory')
if mem:
use_memory='yes'
st.session_state['memory']=use_memory
if st.button('Clear Session'):
'''
The Clear context helps to refresh the UI and also create a new session for the chat. This creates a new Dynamo DB table to hold the chat history.
'''
# Delete all the items in Session state
for key in st.session_state.keys():
del st.session_state[key]
# create new session state items
if 'generated' not in st.session_state:
st.session_state['generated'] = []
if 'past' not in st.session_state:
st.session_state['past'] = []
if 'messages' not in st.session_state:
st.session_state['messages'] = []
if 'ant_key' not in st.session_state:
st.session_state['ant_key'] = ''
if 'chat_id' not in st.session_state:
st.session_state['chat_id'] = 1
if 'client_id' not in st.session_state:
st.session_state['client_id'] = ''
if 'prompt' not in st.session_state:
st.session_state['prompt'] = ""
if 'memory' not in st.session_state:
st.session_state['memory'] = ""
def main(agent,chat_history_memory):
params=app_sidebar()
action_doc(agent, chat_history_memory)
if __name__ == '__main__':
main(agent, chat_history_memory)
| [
"langchain.memory.ConversationBufferMemory",
"langchain.prompts.ChatPromptTemplate.from_messages",
"langchain.tools.python.tool.PythonREPLTool",
"langchain.llms.bedrock.Bedrock",
"langchain.prompts.PromptTemplate",
"langchain_experimental.plan_and_execute.load_chat_planner",
"langchain_experimental.plan_and_execute.PlanAndExecute",
"langchain.memory.chat_message_histories.DynamoDBChatMessageHistory",
"langchain.SQLDatabase",
"langchain.agents.tools.Tool",
"langchain.prompts.SystemMessagePromptTemplate.from_template",
"langchain_experimental.plan_and_execute.load_agent_executor",
"langchain_experimental.sql.base.SQLDatabaseChain.from_llm"
] | [((1364, 1397), 'streamlit.set_page_config', 'st.set_page_config', ([], {'layout': '"""wide"""'}), "(layout='wide')\n", (1382, 1397), True, 'import streamlit as st\n'), ((1532, 1553), 'utility.custom_logga.Logger', 'custom_logga.Logger', ([], {}), '()\n', (1551, 1553), False, 'from utility import get_cfn_details, custom_logga, upload_amz_file\n'), ((5121, 5193), 'langchain.llms.bedrock.Bedrock', 'Bedrock', ([], {'model_id': '"""anthropic.claude-v2"""', 'model_kwargs': 'inference_modifier'}), "(model_id='anthropic.claude-v2', model_kwargs=inference_modifier)\n", (5128, 5193), False, 'from langchain.llms.bedrock import Bedrock\n'), ((10370, 10460), 'langchain.memory.chat_message_histories.DynamoDBChatMessageHistory', 'DynamoDBChatMessageHistory', ([], {'table_name': 'chat_history_table', 'session_id': 'chat_session_id'}), '(table_name=chat_history_table, session_id=\n chat_session_id)\n', (10396, 10460), False, 'from langchain.memory.chat_message_histories import DynamoDBChatMessageHistory\n'), ((10478, 10502), 'langchain_experimental.plan_and_execute.load_chat_planner', 'load_chat_planner', (['model'], {}), '(model)\n', (10495, 10502), False, 'from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner\n'), ((10528, 10585), 'langchain.prompts.SystemMessagePromptTemplate.from_template', 'SystemMessagePromptTemplate.from_template', (['combo_template'], {}), '(combo_template)\n', (10569, 10585), False, 'from langchain.prompts import ChatPromptTemplate, PromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((10673, 10752), 'langchain.prompts.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (['[system_message_prompt, human_message_prompt]'], {}), '([system_message_prompt, human_message_prompt])\n', (10705, 10752), False, 'from langchain.prompts import ChatPromptTemplate, PromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((10765, 10812), 'langchain_experimental.plan_and_execute.load_agent_executor', 'load_agent_executor', (['model', 'tools'], {'verbose': '(True)'}), '(model, tools, verbose=True)\n', (10784, 10812), False, 'from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner\n'), ((2449, 2473), 'streamlit.web.server.websocket_headers._get_websocket_headers', '_get_websocket_headers', ([], {}), '()\n', (2471, 2473), False, 'from streamlit.web.server.websocket_headers import _get_websocket_headers\n'), ((3016, 3062), 'utility.get_cfn_details.stack_info', 'get_cfn_details.stack_info', (['STACK_NAME', 'REGION'], {}), '(STACK_NAME, REGION)\n', (3042, 3062), False, 'from utility import get_cfn_details, custom_logga, upload_amz_file\n'), ((3511, 3614), 'utility.upload_amz_file.upload_file_amz', 'upload_amz_file.upload_file_amz', (['"""files/Amazon-10K-2022-EarningsReport.pdf"""', 'textract_source_bucket'], {}), "('files/Amazon-10K-2022-EarningsReport.pdf',\n textract_source_bucket)\n", (3542, 3614), False, 'from utility import get_cfn_details, custom_logga, upload_amz_file\n'), ((3615, 3734), 'utility.upload_amz_file.upload_file_amz', 'upload_amz_file.upload_file_amz', (['"""files/Amazon-10Q-Q1-2023-QuaterlyEarningsReport.pdf"""', 'textract_source_bucket'], {}), "(\n 'files/Amazon-10Q-Q1-2023-QuaterlyEarningsReport.pdf',\n textract_source_bucket)\n", (3646, 3734), False, 'from utility import get_cfn_details, custom_logga, upload_amz_file\n'), ((3730, 3870), 'utility.upload_amz_file.upload_file_amz', 'upload_amz_file.upload_file_amz', (['"""files/Amazon-Quarterly-Earnings-Report-Q1-2023-Full-Call-v1.mp3"""', 'audio_transcripts_source_bucket'], {}), "(\n 'files/Amazon-Quarterly-Earnings-Report-Q1-2023-Full-Call-v1.mp3',\n audio_transcripts_source_bucket)\n", (3761, 3870), False, 'from utility import get_cfn_details, custom_logga, upload_amz_file\n'), ((4454, 4498), 'sqlalchemy.create_engine', 'create_engine', (['connection_string'], {'echo': '(False)'}), '(connection_string, echo=False)\n', (4467, 4498), False, 'from sqlalchemy import create_engine\n'), ((4514, 4540), 'langchain.SQLDatabase', 'SQLDatabase', (['engine_athena'], {}), '(engine_athena)\n', (4525, 4540), False, 'from langchain import PromptTemplate, SQLDatabase, LLMChain\n'), ((5625, 5724), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['input', 'table_info', 'dialect']", 'template': '_DEFAULT_TEMPLATE'}), "(input_variables=['input', 'table_info', 'dialect'], template\n =_DEFAULT_TEMPLATE)\n", (5639, 5724), False, 'from langchain.prompts import ChatPromptTemplate, PromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((5754, 5864), 'langchain_experimental.sql.base.SQLDatabaseChain.from_llm', 'SQLDatabaseChain.from_llm', (['llm', 'dbathena'], {'prompt': 'PROMPT_sql', 'verbose': '(True)', 'return_intermediate_steps': '(False)'}), '(llm, dbathena, prompt=PROMPT_sql, verbose=True,\n return_intermediate_steps=False)\n', (5779, 5864), False, 'from langchain_experimental.sql.base import SQLDatabaseChain\n'), ((5999, 6041), 'boto3.client', 'boto3.client', (['"""lambda"""'], {'region_name': 'REGION'}), "('lambda', region_name=REGION)\n", (6011, 6041), False, 'import boto3\n'), ((6482, 6524), 'boto3.client', 'boto3.client', (['"""lambda"""'], {'region_name': 'REGION'}), "('lambda', region_name=REGION)\n", (6494, 6524), False, 'import boto3\n'), ((6901, 7113), 'langchain.agents.tools.Tool', 'Tool', ([], {'name': '"""Stock Querying Tool"""', 'func': 'stock_query_mm.run_query', 'description': '"""\n Useful for when you need to answer questions about stocks. It only has information about stocks.\n """'}), '(name=\'Stock Querying Tool\', func=stock_query_mm.run_query, description\n =\n """\n Useful for when you need to answer questions about stocks. It only has information about stocks.\n """\n )\n', (6905, 7113), False, 'from langchain.agents.tools import Tool\n'), ((7134, 7168), 'utility.portfolio_tool.OptimizePortfolio', 'portfolio_tool.OptimizePortfolio', ([], {}), '()\n', (7166, 7168), False, 'from utility import stock_query_mm, kendra_tool_mm, aws_tools, portfolio_tool\n'), ((7174, 7401), 'langchain.agents.tools.Tool', 'Tool', ([], {'name': '"""Financial Information Lookup Tool"""', 'func': 'kendra_tool_mm.run_chain', 'description': '"""\n Useful for when you need to look up financial information like revenues, sales, loss, risks etc. \n """'}), '(name=\'Financial Information Lookup Tool\', func=kendra_tool_mm.\n run_chain, description=\n """\n Useful for when you need to look up financial information like revenues, sales, loss, risks etc. \n """\n )\n', (7178, 7401), False, 'from langchain.agents.tools import Tool\n'), ((7422, 7438), 'langchain.tools.python.tool.PythonREPLTool', 'PythonREPLTool', ([], {}), '()\n', (7436, 7438), False, 'from langchain.tools.python.tool import PythonREPLTool\n'), ((7444, 7640), 'langchain.agents.tools.Tool', 'Tool', ([], {'name': '"""Sentiment Analysis Tool"""', 'func': 'SentimentAnalysis', 'description': '"""\n Useful for when you need to analyze the sentiment of an excerpt from a financial report.\n """'}), '(name=\'Sentiment Analysis Tool\', func=SentimentAnalysis, description=\n """\n Useful for when you need to analyze the sentiment of an excerpt from a financial report.\n """\n )\n', (7448, 7640), False, 'from langchain.agents.tools import Tool\n'), ((7667, 7838), 'langchain.agents.tools.Tool', 'Tool', ([], {'name': '"""Detect Phrases Tool"""', 'func': 'DetectKeyPhrases', 'description': '"""\n Useful for when you need to detect key phrases in financial reports.\n """'}), '(name=\'Detect Phrases Tool\', func=DetectKeyPhrases, description=\n """\n Useful for when you need to detect key phrases in financial reports.\n """\n )\n', (7671, 7838), False, 'from langchain.agents.tools import Tool\n'), ((7865, 8117), 'langchain.agents.tools.Tool', 'Tool', ([], {'name': '"""Text Extraction Tool"""', 'func': 'aws_tools.IntiateTextExtractProcessing', 'description': '"""\n Useful for when you need to trigger conversion of pdf version of quaterly reports to text files using amazon textextract\n """'}), '(name=\'Text Extraction Tool\', func=aws_tools.\n IntiateTextExtractProcessing, description=\n """\n Useful for when you need to trigger conversion of pdf version of quaterly reports to text files using amazon textextract\n """\n )\n', (7869, 8117), False, 'from langchain.agents.tools import Tool\n'), ((8139, 8377), 'langchain.agents.tools.Tool', 'Tool', ([], {'name': '"""Transcribe Audio Tool"""', 'func': 'aws_tools.TranscribeAudio', 'description': '"""\n Useful for when you need to convert audio recordings of earnings calls from audio to text format using Amazon Transcribe\n """'}), '(name=\'Transcribe Audio Tool\', func=aws_tools.TranscribeAudio,\n description=\n """\n Useful for when you need to convert audio recordings of earnings calls from audio to text format using Amazon Transcribe\n """\n )\n', (8143, 8377), False, 'from langchain.agents.tools import Tool\n'), ((10867, 10978), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'chat_memory': 'chat_history_memory', 'return_messages': '(True)'}), "(memory_key='chat_history', chat_memory=\n chat_history_memory, return_messages=True)\n", (10891, 10978), False, 'from langchain.memory import ConversationBufferMemory\n'), ((10986, 11087), 'langchain_experimental.plan_and_execute.PlanAndExecute', 'PlanAndExecute', ([], {'planner': 'planner', 'executor': 'executor', 'verbose': '(True)', 'max_iterations': '(2)', 'memory': 'memory'}), '(planner=planner, executor=executor, verbose=True,\n max_iterations=2, memory=memory)\n', (11000, 11087), False, 'from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner\n'), ((11102, 11188), 'langchain_experimental.plan_and_execute.PlanAndExecute', 'PlanAndExecute', ([], {'planner': 'planner', 'executor': 'executor', 'verbose': '(True)', 'max_iterations': '(2)'}), '(planner=planner, executor=executor, verbose=True,\n max_iterations=2)\n', (11116, 11188), False, 'from langchain_experimental.plan_and_execute import PlanAndExecute, load_agent_executor, load_chat_planner\n'), ((11461, 11518), 'streamlit.title', 'st.title', (['"""Multi-Modal Agent to assist Financial Analyst"""'], {}), "('Multi-Modal Agent to assist Financial Analyst')\n", (11469, 11518), True, 'import streamlit as st\n'), ((3361, 3410), 'json.dump', 'json.dump', (['param', 'f'], {'ensure_ascii': '(False)', 'indent': '(4)'}), '(param, f, ensure_ascii=False, indent=4)\n', (3370, 3410), False, 'import json\n'), ((5451, 5463), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (5461, 5463), False, 'import uuid\n'), ((11979, 12002), 'streamlit.chat_input', 'st.chat_input', (['"""Hello?"""'], {}), "('Hello?')\n", (11992, 12002), True, 'import streamlit as st\n'), ((12012, 12081), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (12044, 12081), True, 'import streamlit as st\n'), ((12444, 12529), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'assistant', 'content': output_answer}"], {}), "({'role': 'assistant', 'content':\n output_answer})\n", (12476, 12529), True, 'import streamlit as st\n'), ((12945, 12995), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'steps': steps}"], {}), "({'steps': steps})\n", (12977, 12995), True, 'import streamlit as st\n'), ((13107, 13133), 'streamlit.write', 'st.write', (['"""## How to use:"""'], {}), "('## How to use:')\n", (13115, 13133), True, 'import streamlit as st\n'), ((13561, 13585), 'streamlit.markdown', 'st.markdown', (['description'], {}), '(description)\n', (13572, 13585), True, 'import streamlit as st\n'), ((13594, 13609), 'streamlit.write', 'st.write', (['"""---"""'], {}), "('---')\n", (13602, 13609), True, 'import streamlit as st\n'), ((13618, 13649), 'streamlit.write', 'st.write', (['"""## Sample Questions"""'], {}), "('## Sample Questions')\n", (13626, 13649), True, 'import streamlit as st\n'), ((13658, 14109), 'streamlit.markdown', 'st.markdown', (['"""\n - What are the closing prices of stocks AAAA, WWW, DDD in year 2018? Can you build an optimized portfolio using these three stocks? Please provide answers to both questions.\n - What is the net sales for Amazon in 2021 and 2022? What is the percent difference?\n - What are the biggest risks facing Amazon Inc? \n """'], {}), '(\n """\n - What are the closing prices of stocks AAAA, WWW, DDD in year 2018? Can you build an optimized portfolio using these three stocks? Please provide answers to both questions.\n - What is the net sales for Amazon in 2021 and 2022? What is the percent difference?\n - What are the biggest risks facing Amazon Inc? \n """\n )\n', (13669, 14109), True, 'import streamlit as st\n'), ((14108, 14504), 'streamlit.markdown', 'st.markdown', (['"""\n **Datasets**\n \n - [Quterly Earnings recordings](https://github.com/revdotcom/speech-datasets)\n - [Annual Reports (FinTabNet)](https://developer.ibm.com/exchanges/data/all/fintabnet/)\n - [S&P 500 stock data](https://www.kaggle.com/camnugent/sandp500)\n """'], {}), '(\n """\n **Datasets**\n \n - [Quterly Earnings recordings](https://github.com/revdotcom/speech-datasets)\n - [Annual Reports (FinTabNet)](https://developer.ibm.com/exchanges/data/all/fintabnet/)\n - [S&P 500 stock data](https://www.kaggle.com/camnugent/sandp500)\n """\n )\n', (14119, 14504), True, 'import streamlit as st\n'), ((14503, 14518), 'streamlit.write', 'st.write', (['"""---"""'], {}), "('---')\n", (14511, 14518), True, 'import streamlit as st\n'), ((14585, 14628), 'streamlit.text_area', 'st.text_area', (['"""Custom prompt goes here"""', '""""""'], {}), "('Custom prompt goes here', '')\n", (14597, 14628), True, 'import streamlit as st\n'), ((14773, 14807), 'streamlit.checkbox', 'st.checkbox', (['"""Conversation Memory"""'], {}), "('Conversation Memory')\n", (14784, 14807), True, 'import streamlit as st\n'), ((14924, 14950), 'streamlit.button', 'st.button', (['"""Clear Session"""'], {}), "('Clear Session')\n", (14933, 14950), True, 'import streamlit as st\n'), ((6253, 6276), 'json.dumps', 'json.dumps', (['inputString'], {}), '(inputString)\n', (6263, 6276), False, 'import json\n'), ((6736, 6759), 'json.dumps', 'json.dumps', (['inputString'], {}), '(inputString)\n', (6746, 6759), False, 'import json\n'), ((12095, 12118), 'streamlit.chat_message', 'st.chat_message', (['"""user"""'], {}), "('user')\n", (12110, 12118), True, 'import streamlit as st\n'), ((12132, 12151), 'streamlit.markdown', 'st.markdown', (['prompt'], {}), '(prompt)\n', (12143, 12151), True, 'import streamlit as st\n'), ((12191, 12219), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (12206, 12219), True, 'import streamlit as st\n'), ((12255, 12265), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (12263, 12265), True, 'import streamlit as st\n'), ((12740, 12783), 'streamlit.expander', 'st.expander', ([], {'label': '"""**Intermediate Steps**"""'}), "(label='**Intermediate Steps**')\n", (12751, 12783), True, 'import streamlit as st\n'), ((12912, 12936), 'os.remove', 'os.remove', (['"""logfile.txt"""'], {}), "('logfile.txt')\n", (12921, 12936), False, 'import os\n'), ((15241, 15264), 'streamlit.session_state.keys', 'st.session_state.keys', ([], {}), '()\n', (15262, 15264), True, 'import streamlit as st\n'), ((11674, 11706), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (11689, 11706), True, 'import streamlit as st\n'), ((11861, 11904), 'streamlit.expander', 'st.expander', ([], {'label': '"""**Intermediate Steps**"""'}), "(label='**Intermediate Steps**')\n", (11872, 11904), True, 'import streamlit as st\n'), ((11922, 11948), 'streamlit.write', 'st.write', (["message['steps']"], {}), "(message['steps'])\n", (11930, 11948), True, 'import streamlit as st\n'), ((12884, 12899), 'streamlit.write', 'st.write', (['steps'], {}), '(steps)\n', (12892, 12899), True, 'import streamlit as st\n')] |
from langchain.agents.agent_toolkits import create_python_agent
from langchain.tools.python.tool import PythonREPLTool
from langchain.python import PythonREPL
from langchain.llms.openai import OpenAI
from langchain.agents.agent_types import AgentType
from langchain.chat_models import ChatOpenAI
import os
agent_executor = create_python_agent(
llm=OpenAI(temperature=0.5, max_tokens=2000),
tool=PythonREPLTool(),
verbose=True,
agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
)
agent_executor.run("What is the 10th fibonacci number?")
| [
"langchain.llms.openai.OpenAI",
"langchain.tools.python.tool.PythonREPLTool"
] | [((354, 394), 'langchain.llms.openai.OpenAI', 'OpenAI', ([], {'temperature': '(0.5)', 'max_tokens': '(2000)'}), '(temperature=0.5, max_tokens=2000)\n', (360, 394), False, 'from langchain.llms.openai import OpenAI\n'), ((405, 421), 'langchain.tools.python.tool.PythonREPLTool', 'PythonREPLTool', ([], {}), '()\n', (419, 421), False, 'from langchain.tools.python.tool import PythonREPLTool\n')] |
# docsGpt.py - Contains the docsGpt functions and classes for document parsing
# Author: Armin Norouzi, Farhad Davaripour
# Contact: https://github.com/Farhad-Davaripour/DocsGPT
# Date created: April 14, 2023
# Last modified: May 3, 2023
# License: MIT License
# Import required modules
import sys
import subprocess
from google.colab import files
import os
import shutil
import time
import tempfile
# List of library names to import
library_names = ['langchain', 'openai', 'PyPDF2', 'tiktoken', 'faiss-cpu', 'textwrap', 'python-docx', 'python-pptx']
# Dynamically import libraries from list
for name in library_names:
try:
__import__(name)
except ImportError:
print(f"{name} not found. Installing {name}...")
subprocess.check_call([sys.executable, '-m', 'pip', 'install', name])
# Import required modules
from PyPDF2 import PdfReader
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import ElasticVectorSearch, Pinecone, Weaviate, FAISS
from langchain.chains.question_answering import load_qa_chain
from langchain.llms import OpenAI
from getpass import getpass
import textwrap
import os
import docx
import pptx
# adding token
# print("You need OpenAI token: Here is the link to get
# the keys: https://platform.openai.com/account/billing/overview")
token = getpass("Enter your OpenAI token: ()")
os.environ["OPENAI_API_KEY"] = str(token)
# Download embeddings from OpenAI
embeddings = OpenAIEmbeddings()
chain = load_qa_chain(OpenAI(), chain_type="stuff")
def extract_texts(root_files):
"""
Extracts text from uploaded file and puts it in a list.
Supported file types: .pdf, .docx, .pptx
If multiple files are provided, their contents are concatenated.
Args:
- root_files: A list of file paths to be processed.
Returns:
- A FAISS index object containing the embeddings of the
text chunks.
"""
raw_text = ''
for root_file in root_files:
_, ext = os.path.splitext(root_file)
if ext == '.pdf':
with open(root_file, 'rb') as f:
reader = PdfReader(f)
for i in range(len(reader.pages)):
page = reader.pages[i]
raw_text += page.extract_text()
elif ext == '.docx':
doc = docx.Document(root_file)
for paragraph in doc.paragraphs:
raw_text += paragraph.text
elif ext == '.pptx':
ppt = pptx.Presentation(root_file)
for slide in ppt.slides:
for shape in slide.shapes:
if hasattr(shape, 'text'):
raw_text += shape.text
# retreival we don't hit the token size limits.
text_splitter = CharacterTextSplitter(
separator = "\n",
chunk_size = 1000,
chunk_overlap = 200,
length_function = len,
)
texts = text_splitter.split_text(raw_text)
docsearch = FAISS.from_texts(texts, embeddings)
return docsearch
def run_query(query, docsearch):
"""
Runs a query on a PDF file using the docsearch and chain
libraries.
Args:
- query: A string representing the query to be run.
- file: A PDFReader object containing the PDF file to be
searched.
Returns:
- A string containing the output of the chain library run
on the documents returned by the docsearch similarity search.
"""
docs = docsearch.similarity_search(query)
return chain.run(input_documents=docs, question=query)
def upload_file(folder_path):
"""
Uploads a file from the local file system and saves it to
a folder path.
Args:
- folder_path: A string representing the folder path where
the file will be saved.
Returns:
- A string representing the path of the uploaded file.
"""
uploaded = files.upload()
root_file = []
for filename, data in uploaded.items():
with open(filename, 'wb') as f:
f.write(data)
shutil.copy(filename, folder_path + "/")
root_file.append(folder_path + "/" + filename)
os.remove(filename)
return root_file
def run_conversation(folder_path):
"""
Initiates a conversation with the user by repeatedly asking for
input queries and running them on a PDF file.
Args:
- folder_path: A string representing the folder path where the
PDF file is located.
Returns:
- Run conversation based on PDF
"""
root_files = upload_file(folder_path)
# location of the pdf file/files.
docsearch = extract_texts(root_files)
count = 0
while True:
print("Question ", count + 1)
query = input(" Ask your question or if you have no further question type stop:\n ")
if query.lower() == "stop":
print("### Thanks for using the app! ###")
break
elif query == "":
print("### Your input is empty! Try again! ###")
continue
else:
wrapped_text = textwrap.wrap(run_query(query, docsearch), width=100)
print("Answer:")
for line in wrapped_text:
print(line)
count += 1 | [
"langchain.text_splitter.CharacterTextSplitter",
"langchain.vectorstores.FAISS.from_texts",
"langchain.llms.OpenAI",
"langchain.embeddings.openai.OpenAIEmbeddings"
] | [((1393, 1431), 'getpass.getpass', 'getpass', (['"""Enter your OpenAI token: ()"""'], {}), "('Enter your OpenAI token: ()')\n", (1400, 1431), False, 'from getpass import getpass\n'), ((1523, 1541), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1539, 1541), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((1564, 1572), 'langchain.llms.OpenAI', 'OpenAI', ([], {}), '()\n', (1570, 1572), False, 'from langchain.llms import OpenAI\n'), ((2810, 2908), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'separator': '"""\n"""', 'chunk_size': '(1000)', 'chunk_overlap': '(200)', 'length_function': 'len'}), "(separator='\\n', chunk_size=1000, chunk_overlap=200,\n length_function=len)\n", (2831, 2908), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((3206, 3241), 'langchain.vectorstores.FAISS.from_texts', 'FAISS.from_texts', (['texts', 'embeddings'], {}), '(texts, embeddings)\n', (3222, 3241), False, 'from langchain.vectorstores import ElasticVectorSearch, Pinecone, Weaviate, FAISS\n'), ((4111, 4125), 'google.colab.files.upload', 'files.upload', ([], {}), '()\n', (4123, 4125), False, 'from google.colab import files\n'), ((2043, 2070), 'os.path.splitext', 'os.path.splitext', (['root_file'], {}), '(root_file)\n', (2059, 2070), False, 'import os\n'), ((4264, 4304), 'shutil.copy', 'shutil.copy', (['filename', "(folder_path + '/')"], {}), "(filename, folder_path + '/')\n", (4275, 4304), False, 'import shutil\n'), ((4368, 4387), 'os.remove', 'os.remove', (['filename'], {}), '(filename)\n', (4377, 4387), False, 'import os\n'), ((745, 814), 'subprocess.check_call', 'subprocess.check_call', (["[sys.executable, '-m', 'pip', 'install', name]"], {}), "([sys.executable, '-m', 'pip', 'install', name])\n", (766, 814), False, 'import subprocess\n'), ((2167, 2179), 'PyPDF2.PdfReader', 'PdfReader', (['f'], {}), '(f)\n', (2176, 2179), False, 'from PyPDF2 import PdfReader\n'), ((2373, 2397), 'docx.Document', 'docx.Document', (['root_file'], {}), '(root_file)\n', (2386, 2397), False, 'import docx\n'), ((2533, 2561), 'pptx.Presentation', 'pptx.Presentation', (['root_file'], {}), '(root_file)\n', (2550, 2561), False, 'import pptx\n')] |
import httpx
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import (AsyncChromiumLoader,
AsyncHtmlLoader)
from langchain_community.document_transformers import BeautifulSoupTransformer
from modelscope_agent.tools import BaseTool, register_tool
@register_tool('web_browser')
class WebBrowser(BaseTool):
description = '网页浏览器，能根据网页url浏览网页并返回网页内容。'
name = 'web_browser'
parameters: list = [{
'name': 'urls',
'type': 'string',
'description': 'the urls that the user wants to browse',
'required': True
}]
def __init__(self, cfg={}):
super().__init__(cfg)
self.headers = {
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)'
}
self.client = httpx.Client(
headers=self.headers, verify=False, timeout=30.0)
def call(self, params: str, **kwargs) -> str:
params = self._verify_args(params)
if isinstance(params, str):
return 'Parameter Error'
urls = params['urls']
print(urls)
if urls is None:
return ''
# make sure parameters could be initialized in runtime
max_browser_length = kwargs.get('max_browser_length', 2000)
split_url_into_chunk = kwargs.get('split_url_into_chunk', False)
# # load html
loader = AsyncHtmlLoader(urls)
docs = loader.load()
# Transform
bs_transformer = BeautifulSoupTransformer()
docs_transformed = bs_transformer.transform_documents(
docs, tags_to_extract=['span'])
# split url content into chunk in order to get fine-grained results
if split_url_into_chunk:
# Grab the first 1000 tokens of the site
splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
chunk_size=1000, chunk_overlap=0)
splits = splitter.split_documents(docs_transformed)
else:
splits = docs_transformed
search_results = ''
for item in splits:
search_results += item.page_content + '\n'
return search_results[0:max_browser_length]
if __name__ == '__main__':
tool = WebBrowser()
result = tool.call('{"urls": "https://blog.sina.com.cn/zhangwuchang"}')
print(result)
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter.from_tiktoken_encoder",
"langchain_community.document_loaders.AsyncHtmlLoader",
"langchain_community.document_transformers.BeautifulSoupTransformer"
] | [((359, 387), 'modelscope_agent.tools.register_tool', 'register_tool', (['"""web_browser"""'], {}), "('web_browser')\n", (372, 387), False, 'from modelscope_agent.tools import BaseTool, register_tool\n'), ((857, 919), 'httpx.Client', 'httpx.Client', ([], {'headers': 'self.headers', 'verify': '(False)', 'timeout': '(30.0)'}), '(headers=self.headers, verify=False, timeout=30.0)\n', (869, 919), False, 'import httpx\n'), ((1443, 1464), 'langchain_community.document_loaders.AsyncHtmlLoader', 'AsyncHtmlLoader', (['urls'], {}), '(urls)\n', (1458, 1464), False, 'from langchain_community.document_loaders import AsyncChromiumLoader, AsyncHtmlLoader\n'), ((1539, 1565), 'langchain_community.document_transformers.BeautifulSoupTransformer', 'BeautifulSoupTransformer', ([], {}), '()\n', (1563, 1565), False, 'from langchain_community.document_transformers import BeautifulSoupTransformer\n'), ((1859, 1949), 'langchain.text_splitter.RecursiveCharacterTextSplitter.from_tiktoken_encoder', 'RecursiveCharacterTextSplitter.from_tiktoken_encoder', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(0)'}), '(chunk_size=1000,\n chunk_overlap=0)\n', (1911, 1949), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n')] |
from langchain.chains.base import Chain
from langchain.tools import Tool, BaseTool
def chain_as_tool(chain: Chain, name: str, description: str, **kwargs) -> BaseTool:
"""Converts a chain into a tool."""
return Tool(
name=name,
description=description,
func=chain.invoke,
coroutine=chain.ainvoke,
**kwargs
)
| [
"langchain.tools.Tool"
] | [((220, 319), 'langchain.tools.Tool', 'Tool', ([], {'name': 'name', 'description': 'description', 'func': 'chain.invoke', 'coroutine': 'chain.ainvoke'}), '(name=name, description=description, func=chain.invoke, coroutine=chain\n .ainvoke, **kwargs)\n', (224, 319), False, 'from langchain.tools import Tool, BaseTool\n')] |
"""Loaders for Prefect."""
import asyncio
import httpx
import os
import shutil
import tempfile
from pathlib import Path
from typing import List
from langchain.docstore.document import Document
from langchain.document_loaders.base import BaseLoader
from langchain_prefect.types import GitHubComment, GitHubIssue
from prefect.utilities.asyncutils import sync_compatible
class GithubIssueLoader(BaseLoader):
"""Loader for GitHub issues for a given repository."""
def __init__(self, repo: str, n_issues: int):
"""
Initialize the loader with the given repository.
Args:
repo: The name of the repository, in the format "<owner>/<repo>"
"""
self.repo = repo
self.n_issues = n_issues
self.request_headers = {
"Accept": "application/vnd.github.v3+json",
}
# If a GitHub token is available, use it to increase the rate limit
if token := os.environ.get("GITHUB_TOKEN"):
self.request_headers["Authorization"] = f"Bearer {token}"
def _get_issue_comments(
self, issue_number: int, per_page: int = 100
) -> List[GitHubComment]:
"""
Get a list of all comments for the given issue.
Returns:
A list of dictionaries, each representing a comment.
"""
url = f"https://api.github.com/repos/{self.repo}/issues/{issue_number}/comments"
comments = []
page = 1
while True:
response = httpx.get(
url=url,
headers=self.request_headers,
params={"per_page": per_page, "page": page},
)
response.raise_for_status()
if not (new_comments := response.json()):
break
comments.extend([GitHubComment(**comment) for comment in new_comments])
page += 1
return comments
def _get_issues(self, per_page: int = 100) -> List[GitHubIssue]:
"""
Get a list of all issues for the given repository.
Returns:
A list of `GitHubIssue` objects, each representing an issue.
"""
url = f"https://api.github.com/repos/{self.repo}/issues"
issues = []
page = 1
while True:
if len(issues) >= self.n_issues:
break
remaining = self.n_issues - len(issues)
response = httpx.get(
url=url,
headers=self.request_headers,
params={
"per_page": remaining if remaining < per_page else per_page,
"page": page,
"include": "comments",
},
)
response.raise_for_status()
if not (new_issues := response.json()):
break
issues.extend([GitHubIssue(**issue) for issue in new_issues])
page += 1
return issues
def load(self) -> List[Document]:
"""
Load all issues for the given repository.
Returns:
A list of `Document` objects, each representing an issue.
"""
issues = self._get_issues()
documents = []
for issue in issues:
text = f"{issue.title}\n{issue.body}"
if issue.comments:
for comment in self._get_issue_comments(issue.number):
text += f"\n\n{comment.user.login}: {comment.body}\n\n"
metadata = {
"source": issue.html_url,
"title": issue.title,
"labels": ",".join([label.name for label in issue.labels]),
}
documents.append(Document(page_content=text, metadata=metadata))
return documents
class GitHubRepoLoader(BaseLoader):
"""Loader for files on GitHub that match a glob pattern."""
def __init__(self, repo: str, glob: str):
"""Initialize with the GitHub repository and glob pattern.
Attrs:
repo: The organization and repository name, e.g. "prefecthq/prefect"
glob: The glob pattern to match files, e.g. "**/*.md"
"""
self.repo = f"https://github.com/{repo}.git"
self.glob = glob
@sync_compatible
async def load(self) -> List[Document]:
"""Load files from GitHub that match the glob pattern."""
tmp_dir = tempfile.mkdtemp()
try:
process = await asyncio.create_subprocess_exec(
*["git", "clone", "--depth", "1", self.repo, tmp_dir]
)
if (await process.wait()) != 0:
raise OSError(
f"Failed to clone repository:\n {process.stderr.decode()}"
)
# Read the contents of each file that matches the glob pattern
documents = []
for file in Path(tmp_dir).glob(self.glob):
with open(file, "r") as f:
text = f.read()
metadata = {
"source": os.path.join(self.repo, file.relative_to(tmp_dir))
}
documents.append(Document(page_content=text, metadata=metadata))
return documents
finally:
shutil.rmtree(tmp_dir)
| [
"langchain_prefect.types.GitHubIssue",
"langchain.docstore.document.Document",
"langchain_prefect.types.GitHubComment"
] | [((4368, 4386), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (4384, 4386), False, 'import tempfile\n'), ((944, 974), 'os.environ.get', 'os.environ.get', (['"""GITHUB_TOKEN"""'], {}), "('GITHUB_TOKEN')\n", (958, 974), False, 'import os\n'), ((1493, 1590), 'httpx.get', 'httpx.get', ([], {'url': 'url', 'headers': 'self.request_headers', 'params': "{'per_page': per_page, 'page': page}"}), "(url=url, headers=self.request_headers, params={'per_page':\n per_page, 'page': page})\n", (1502, 1590), False, 'import httpx\n'), ((2404, 2568), 'httpx.get', 'httpx.get', ([], {'url': 'url', 'headers': 'self.request_headers', 'params': "{'per_page': remaining if remaining < per_page else per_page, 'page': page,\n 'include': 'comments'}"}), "(url=url, headers=self.request_headers, params={'per_page': \n remaining if remaining < per_page else per_page, 'page': page,\n 'include': 'comments'})\n", (2413, 2568), False, 'import httpx\n'), ((5222, 5244), 'shutil.rmtree', 'shutil.rmtree', (['tmp_dir'], {}), '(tmp_dir)\n', (5235, 5244), False, 'import shutil\n'), ((3675, 3721), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'text', 'metadata': 'metadata'}), '(page_content=text, metadata=metadata)\n', (3683, 3721), False, 'from langchain.docstore.document import Document\n'), ((4428, 4517), 'asyncio.create_subprocess_exec', 'asyncio.create_subprocess_exec', (["*['git', 'clone', '--depth', '1', self.repo, tmp_dir]"], {}), "(*['git', 'clone', '--depth', '1', self.repo,\n tmp_dir])\n", (4458, 4517), False, 'import asyncio\n'), ((1795, 1819), 'langchain_prefect.types.GitHubComment', 'GitHubComment', ([], {}), '(**comment)\n', (1808, 1819), False, 'from langchain_prefect.types import GitHubComment, GitHubIssue\n'), ((2843, 2863), 'langchain_prefect.types.GitHubIssue', 'GitHubIssue', ([], {}), '(**issue)\n', (2854, 2863), False, 'from langchain_prefect.types import GitHubComment, GitHubIssue\n'), ((4843, 4856), 'pathlib.Path', 'Path', (['tmp_dir'], {}), '(tmp_dir)\n', (4847, 4856), False, 'from pathlib import Path\n'), ((5115, 5161), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'text', 'metadata': 'metadata'}), '(page_content=text, metadata=metadata)\n', (5123, 5161), False, 'from langchain.docstore.document import Document\n')] |
from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI
from benchllm import SemanticEvaluator, Test, Tester
tools = load_tools(["serpapi", "llm-math"], llm=OpenAI(temperature=0))
agent = initialize_agent(tools, OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
tests = [Test(input="How many people live in canada as of 2023?", expected=["approximately 38,625,801"])]
tester = Tester(lambda input: agent(input)["output"])
tester.add_tests(tests)
predictions = tester.run()
evaluator = SemanticEvaluator()
evaluator.load(predictions)
report = evaluator.run()
print(report)
| [
"langchain.llms.OpenAI"
] | [((569, 588), 'benchllm.SemanticEvaluator', 'SemanticEvaluator', ([], {}), '()\n', (586, 588), False, 'from benchllm import SemanticEvaluator, Test, Tester\n'), ((261, 282), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (267, 282), False, 'from langchain.llms import OpenAI\n'), ((353, 453), 'benchllm.Test', 'Test', ([], {'input': '"""How many people live in canada as of 2023?"""', 'expected': "['approximately 38,625,801']"}), "(input='How many people live in canada as of 2023?', expected=[\n 'approximately 38,625,801'])\n", (357, 453), False, 'from benchllm import SemanticEvaluator, Test, Tester\n'), ((206, 227), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (212, 227), False, 'from langchain.llms import OpenAI\n')] |
from dotenv import load_dotenv
from langchain.chains import RetrievalQA
from langchain.embeddings import HuggingFaceEmbeddings, HuggingFaceInstructEmbeddings
from langchain import HuggingFacePipeline
from colorama import Fore, Style
import re
from langchain.vectorstores import Chroma
from langchain.docstore.document import Document
from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter, RecursiveCharacterTextSplitter
import os
from langchain.llms import LlamaCpp
load_dotenv()
TEST_FILE = os.getenv("TEST_FILE")
EMBEDDINGS_MODEL = os.getenv("EMBEDDINGS_MODEL")
EMBEDDINGS_MAP = {
**{name: HuggingFaceInstructEmbeddings for name in ["hkunlp/instructor-xl", "hkunlp/instructor-large"]},
**{name: HuggingFaceEmbeddings for name in ["all-MiniLM-L6-v2", "sentence-t5-xxl"]}
}
model_type = os.environ.get('MODEL_TYPE')
model_path = os.environ.get('MODEL_PATH')
model_n_ctx =1000
target_source_chunks = os.environ.get('TARGET_SOURCE_CHUNKS')
n_gpu_layers = os.environ.get('N_GPU_LAYERS')
use_mlock = os.environ.get('USE_MLOCK')
n_batch = os.environ.get('N_BATCH') if os.environ.get('N_BATCH') != None else 512
callbacks = []
qa_prompt = ""
CHROMA_SETTINGS = {} # Set your Chroma settings here
def clean_text(text):
# Remove line breaksRetrievalQA
text = text.replace('\n', ' ')
# Remove special characters
text = re.sub(r'[^\w\s]', '', text)
return text
def load_unstructured_document(document: str) -> list[Document]:
with open(document, 'r') as file:
text = file.read()
title = os.path.basename(document)
return [Document(page_content=text, metadata={"title": title})]
def split_documents(documents: list[Document], chunk_size: int = 250, chunk_overlap: int = 20) -> list[Document]:
text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
return text_splitter.split_documents(documents)
def ingest_file(file_path):
# Load unstructured document
documents = load_unstructured_document(file_path)
# Split documents into chunks
documents = split_documents(documents, chunk_size=250, chunk_overlap=100)
# Determine the embedding model to use
EmbeddingsModel = EMBEDDINGS_MAP.get(EMBEDDINGS_MODEL)
if EmbeddingsModel is None:
raise ValueError(f"Invalid embeddings model: {EMBEDDINGS_MODEL}")
model_kwargs = {"device": "cuda:0"} if EmbeddingsModel == HuggingFaceInstructEmbeddings else {}
embedding = EmbeddingsModel(model_name=EMBEDDINGS_MODEL, model_kwargs=model_kwargs)
# Store embeddings from the chunked documents
vectordb = Chroma.from_documents(documents=documents, embedding=embedding)
retriever = vectordb.as_retriever(search_kwargs={"k":4})
print(file_path)
print(retriever)
return retriever
def load_tools():
#llm = LlamaCpp(model_path=model_path, n_ctx=model_n_ctx, callbacks=callbacks, verbose=False,n_gpu_layers=n_gpu_layers, use_mlock=use_mlock,top_p=0.9, n_batch=n_batch)
def ingest_file(file_path):
# Load unstructured document
documents = load_unstructured_document(file_path)
# Split documents into chunks
documents = split_documents(documents, chunk_size=120, chunk_overlap=20)
# Determine the embedding model to use
EmbeddingsModel = EMBEDDINGS_MAP.get(EMBEDDINGS_MODEL)
if EmbeddingsModel is None:
raise ValueError(f"Invalid embeddings model: {EMBEDDINGS_MODEL}")
model_kwargs = {"device": "cuda:0"} if EmbeddingsModel == HuggingFaceInstructEmbeddings else {}
embedding = EmbeddingsModel(model_name=EMBEDDINGS_MODEL, model_kwargs=model_kwargs)
# Store embeddings from the chunked documents
vectordb = Chroma.from_documents(documents=documents, embedding=embedding)
retriever = vectordb.as_retriever(search_kwargs={"k":4})
print(file_path)
print(retriever)
return retriever, file_path
file_path = TEST_FILE
retriever, title = ingest_file(file_path)
dict_tools = {
'File Ingestion': ingest_file,
}
return dict_tools
| [
"langchain.docstore.document.Document",
"langchain.vectorstores.Chroma.from_documents",
"langchain.text_splitter.RecursiveCharacterTextSplitter"
] | [((490, 503), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (501, 503), False, 'from dotenv import load_dotenv\n'), ((517, 539), 'os.getenv', 'os.getenv', (['"""TEST_FILE"""'], {}), "('TEST_FILE')\n", (526, 539), False, 'import os\n'), ((559, 588), 'os.getenv', 'os.getenv', (['"""EMBEDDINGS_MODEL"""'], {}), "('EMBEDDINGS_MODEL')\n", (568, 588), False, 'import os\n'), ((822, 850), 'os.environ.get', 'os.environ.get', (['"""MODEL_TYPE"""'], {}), "('MODEL_TYPE')\n", (836, 850), False, 'import os\n'), ((864, 892), 'os.environ.get', 'os.environ.get', (['"""MODEL_PATH"""'], {}), "('MODEL_PATH')\n", (878, 892), False, 'import os\n'), ((934, 972), 'os.environ.get', 'os.environ.get', (['"""TARGET_SOURCE_CHUNKS"""'], {}), "('TARGET_SOURCE_CHUNKS')\n", (948, 972), False, 'import os\n'), ((988, 1018), 'os.environ.get', 'os.environ.get', (['"""N_GPU_LAYERS"""'], {}), "('N_GPU_LAYERS')\n", (1002, 1018), False, 'import os\n'), ((1031, 1058), 'os.environ.get', 'os.environ.get', (['"""USE_MLOCK"""'], {}), "('USE_MLOCK')\n", (1045, 1058), False, 'import os\n'), ((1069, 1094), 'os.environ.get', 'os.environ.get', (['"""N_BATCH"""'], {}), "('N_BATCH')\n", (1083, 1094), False, 'import os\n'), ((1364, 1393), 're.sub', 're.sub', (['"""[^\\\\w\\\\s]"""', '""""""', 'text'], {}), "('[^\\\\w\\\\s]', '', text)\n", (1370, 1393), False, 'import re\n'), ((1557, 1583), 'os.path.basename', 'os.path.basename', (['document'], {}), '(document)\n', (1573, 1583), False, 'import os\n'), ((1787, 1874), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': 'chunk_size', 'chunk_overlap': 'chunk_overlap'}), '(chunk_size=chunk_size, chunk_overlap=\n chunk_overlap)\n', (1817, 1874), False, 'from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter, RecursiveCharacterTextSplitter\n'), ((2666, 2729), 'langchain.vectorstores.Chroma.from_documents', 'Chroma.from_documents', ([], {'documents': 'documents', 'embedding': 'embedding'}), '(documents=documents, embedding=embedding)\n', (2687, 2729), False, 'from langchain.vectorstores import Chroma\n'), ((1098, 1123), 'os.environ.get', 'os.environ.get', (['"""N_BATCH"""'], {}), "('N_BATCH')\n", (1112, 1123), False, 'import os\n'), ((1596, 1650), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'text', 'metadata': "{'title': title}"}), "(page_content=text, metadata={'title': title})\n", (1604, 1650), False, 'from langchain.docstore.document import Document\n'), ((3812, 3875), 'langchain.vectorstores.Chroma.from_documents', 'Chroma.from_documents', ([], {'documents': 'documents', 'embedding': 'embedding'}), '(documents=documents, embedding=embedding)\n', (3833, 3875), False, 'from langchain.vectorstores import Chroma\n')] |
"""Wrapper around HuggingFace Pipeline APIs."""
import importlib.util
import logging
from typing import Any, List, Mapping, Optional
from pydantic import BaseModel, Extra
from langchain.llms.base import LLM
from langchain.llms.utils import enforce_stop_tokens
DEFAULT_MODEL_ID = "gpt2"
DEFAULT_TASK = "text-generation"
VALID_TASKS = ("text2text-generation", "text-generation")
logger = logging.getLogger()
class HuggingFacePipeline(LLM, BaseModel):
"""Wrapper around HuggingFace Pipeline API.
To use, you should have the ``transformers`` python package installed.
Only supports `text-generation` and `text2text-generation` for now.
Example using from_model_id:
.. code-block:: python
from langchain.llms import HuggingFacePipeline
hf = HuggingFacePipeline.from_model_id(
model_id="gpt2", task="text-generation"
)
Example passing pipeline in directly:
.. code-block:: python
from langchain.llms import HuggingFacePipeline
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
model_id = "gpt2"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
pipe = pipeline(
"text-generation", model=model, tokenizer=tokenizer, max_new_tokens=10
)
hf = HuggingFacePipeline(pipeline=pipe)
"""
pipeline: Any #: :meta private:
model_id: str = DEFAULT_MODEL_ID
"""Model name to use."""
model_kwargs: Optional[dict] = None
"""Key word arguments to pass to the model."""
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
@classmethod
def from_model_id(
cls,
model_id: str,
task: str,
device: int = -1,
model_kwargs: Optional[dict] = None,
**kwargs: Any,
) -> LLM:
"""Construct the pipeline object from model_id and task."""
try:
from transformers import (
AutoModelForCausalLM,
AutoModelForSeq2SeqLM,
AutoTokenizer,
)
from transformers import pipeline as hf_pipeline
except ImportError:
raise ValueError(
"Could not import transformers python package. "
"Please it install it with `pip install transformers`."
)
_model_kwargs = model_kwargs or {}
tokenizer = AutoTokenizer.from_pretrained(model_id, **_model_kwargs)
try:
if task == "text-generation":
model = AutoModelForCausalLM.from_pretrained(model_id, **_model_kwargs)
elif task == "text2text-generation":
model = AutoModelForSeq2SeqLM.from_pretrained(model_id, **_model_kwargs)
else:
raise ValueError(
f"Got invalid task {task}, "
f"currently only {VALID_TASKS} are supported"
)
except ImportError as e:
raise ValueError(
f"Could not load the {task} model due to missing dependencies."
) from e
if importlib.util.find_spec("torch") is not None:
import torch
cuda_device_count = torch.cuda.device_count()
if device < -1 or (device >= cuda_device_count):
raise ValueError(
f"Got device=={device}, "
f"device is required to be within [-1, {cuda_device_count})"
)
if device < 0 and cuda_device_count > 0:
logger.warning(
"Device has %d GPUs available. "
"Provide device={deviceId} to `from_model_id` to use available"
"GPUs for execution. deviceId is -1 (default) for CPU and "
"can be a positive integer associated with CUDA device id.",
cuda_device_count,
)
pipeline = hf_pipeline(
task=task,
model=model,
tokenizer=tokenizer,
device=device,
model_kwargs=_model_kwargs,
)
if pipeline.task not in VALID_TASKS:
raise ValueError(
f"Got invalid task {pipeline.task}, "
f"currently only {VALID_TASKS} are supported"
)
return cls(
pipeline=pipeline,
model_id=model_id,
model_kwargs=_model_kwargs,
**kwargs,
)
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {
**{"model_id": self.model_id},
**{"model_kwargs": self.model_kwargs},
}
@property
def _llm_type(self) -> str:
return "huggingface_pipeline"
def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
response = self.pipeline(prompt)
if self.pipeline.task == "text-generation":
# Text generation return includes the starter text.
text = response[0]["generated_text"][len(prompt) :]
elif self.pipeline.task == "text2text-generation":
text = response[0]["generated_text"]
else:
raise ValueError(
f"Got invalid task {self.pipeline.task}, "
f"currently only {VALID_TASKS} are supported"
)
if stop is not None:
# This is a bit hacky, but I can't figure out a better way to enforce
# stop tokens when making calls to huggingface_hub.
text = enforce_stop_tokens(text, stop)
return text
| [
"langchain.llms.utils.enforce_stop_tokens"
] | [((390, 409), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (407, 409), False, 'import logging\n'), ((2546, 2602), 'transformers.AutoTokenizer.from_pretrained', 'AutoTokenizer.from_pretrained', (['model_id'], {}), '(model_id, **_model_kwargs)\n', (2575, 2602), False, 'from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer\n'), ((4077, 4180), 'transformers.pipeline', 'hf_pipeline', ([], {'task': 'task', 'model': 'model', 'tokenizer': 'tokenizer', 'device': 'device', 'model_kwargs': '_model_kwargs'}), '(task=task, model=model, tokenizer=tokenizer, device=device,\n model_kwargs=_model_kwargs)\n', (4088, 4180), True, 'from transformers import pipeline as hf_pipeline\n'), ((3351, 3376), 'torch.cuda.device_count', 'torch.cuda.device_count', ([], {}), '()\n', (3374, 3376), False, 'import torch\n'), ((5708, 5739), 'langchain.llms.utils.enforce_stop_tokens', 'enforce_stop_tokens', (['text', 'stop'], {}), '(text, stop)\n', (5727, 5739), False, 'from langchain.llms.utils import enforce_stop_tokens\n'), ((2683, 2746), 'transformers.AutoModelForCausalLM.from_pretrained', 'AutoModelForCausalLM.from_pretrained', (['model_id'], {}), '(model_id, **_model_kwargs)\n', (2719, 2746), False, 'from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer\n'), ((2820, 2884), 'transformers.AutoModelForSeq2SeqLM.from_pretrained', 'AutoModelForSeq2SeqLM.from_pretrained', (['model_id'], {}), '(model_id, **_model_kwargs)\n', (2857, 2884), False, 'from transformers import AutoModelForCausalLM, AutoModelForSeq2SeqLM, AutoTokenizer\n')] |
from langchain.retrievers.self_query.base import SelfQueryRetriever
from langchain.chains.query_constructor.base import AttributeInfo
from datetime import datetime
current_time_iso = datetime.utcnow().isoformat() + "Z"
# example metadat
"""
{
"type": "file_load_gcs",
"attrs": "namespace:edmonbrain",
"source": "gs://devoteam-mark-langchain-loader/edmonbrain/MarkWork/Running LLMs on Google Cloud Platform via Cloud Run, VertexAI and PubSub - LLMOps on GCP.md",
"bucketId": "devoteam-mark-langchain-loader",
"category": "NarrativeText",
"filename": "Running LLMs on Google Cloud Platform via Cloud Run, VertexAI and PubSub - LLMOps on GCP.md",
"filetype": "text/markdown",
"objectId": "edmonbrain/MarkWork/Running LLMs on Google Cloud Platform via Cloud Run, VertexAI and PubSub - LLMOps on GCP.md",
"eventTime": "2023-07-12T19:36:07.325740Z",
"eventType": "OBJECT_FINALIZE",
"bucket_name": "devoteam-mark-langchain-loader",
"page_number": 1,
"payloadFormat": "JSON_API_V1",
"objectGeneration": "1689190567243818",
"notificationConfig": "projects/_/buckets/devoteam-mark-langchain-loader/notificationConfigs/1"
}
"""
metadata_field_info = [
AttributeInfo(
name="source",
description="The document source url or path to where the document is located",
type="string",
),
AttributeInfo(
name="eventTime",
description=f"When this content was put into the memory. The current datetime is {current_time_iso}",
type="ISO 8601 formatted date and time string",
),
AttributeInfo(
name="type",
description="How this content was added to the memory",
type="string",
),
]
document_content_description = "Documents stored in the bot long term memory"
def get_self_query_retriever(llm, vectorstore):
return SelfQueryRetriever.from_llm(
llm, vectorstore, document_content_description, metadata_field_info, verbose=True
)
| [
"langchain.retrievers.self_query.base.SelfQueryRetriever.from_llm",
"langchain.chains.query_constructor.base.AttributeInfo"
] | [((1179, 1311), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""source"""', 'description': '"""The document source url or path to where the document is located"""', 'type': '"""string"""'}), "(name='source', description=\n 'The document source url or path to where the document is located',\n type='string')\n", (1192, 1311), False, 'from langchain.chains.query_constructor.base import AttributeInfo\n'), ((1339, 1531), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""eventTime"""', 'description': 'f"""When this content was put into the memory. The current datetime is {current_time_iso}"""', 'type': '"""ISO 8601 formatted date and time string"""'}), "(name='eventTime', description=\n f'When this content was put into the memory. The current datetime is {current_time_iso}'\n , type='ISO 8601 formatted date and time string')\n", (1352, 1531), False, 'from langchain.chains.query_constructor.base import AttributeInfo\n'), ((1558, 1660), 'langchain.chains.query_constructor.base.AttributeInfo', 'AttributeInfo', ([], {'name': '"""type"""', 'description': '"""How this content was added to the memory"""', 'type': '"""string"""'}), "(name='type', description=\n 'How this content was added to the memory', type='string')\n", (1571, 1660), False, 'from langchain.chains.query_constructor.base import AttributeInfo\n'), ((1829, 1943), 'langchain.retrievers.self_query.base.SelfQueryRetriever.from_llm', 'SelfQueryRetriever.from_llm', (['llm', 'vectorstore', 'document_content_description', 'metadata_field_info'], {'verbose': '(True)'}), '(llm, vectorstore, document_content_description,\n metadata_field_info, verbose=True)\n', (1856, 1943), False, 'from langchain.retrievers.self_query.base import SelfQueryRetriever\n'), ((184, 201), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (199, 201), False, 'from datetime import datetime\n')] |
import sys
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain.document_loaders import PyPDFLoader, DirectoryLoader, UnstructuredExcelLoader, TextLoader, UnstructuredPowerPointLoader, UnstructuredMarkdownLoader, Docx2txtLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
import os
#import faiss
def embeddings(chosen_directory):
current_directory = os.path.dirname(os.path.realpath(__file__))
model_directory = os.path.join(current_directory, '..', 'mpnet')
print("Model Directory:", os.path.abspath(model_directory))
### LOAD EMBEDDING SETTINGS
embeddings=HuggingFaceEmbeddings(model_name=model_directory, model_kwargs={'device':'mps'}) # SET TO 'cpu' for PC
text_splitter=RecursiveCharacterTextSplitter(
chunk_size=8000,
chunk_overlap=4000)
victor = FAISS.from_texts(["foo"], embeddings)
###LOCATE DIRECTORY
# Specify the desktop path
desktop_path = os.path.join(os.path.expanduser("~"), "Documents")
# Specify the folder name
folder_name = "Dot-data"
# Combine the desktop path and folder name
folder_path = os.path.join(desktop_path, folder_name)
# Create the folder if it doesn't exist
if not os.path.exists(folder_path):
os.makedirs(folder_path)
directory = str(chosen_directory)
### PDF
try:
#**Step 1: Load the PDF File from Data Path****
loader1=DirectoryLoader(directory,
glob="*.pdf",
loader_cls=PyPDFLoader,
show_progress=True,
use_multithreading=True,
recursive=True)
documents_pdf = loader1.load()
text_chunks_pdf=text_splitter.split_documents(documents_pdf)
print(len(text_chunks_pdf))
#**Step 4: Convert the Text Chunks into Embeddings and Create a FAISS Vector Store***
vector_store_pdf=FAISS.from_documents(text_chunks_pdf, embeddings)
#vector_store_pdf.save_local(os.path.join(folder_path, "Dot-data-pdf"))
victor.merge_from(vector_store_pdf)
except Exception as error:
print("NO PDFs FOUND" + str(error))
### WORD
try:
loader2=DirectoryLoader(directory,
glob="*.docx",
loader_cls=Docx2txtLoader,
show_progress=True,
use_multithreading=True,
recursive=True)
documents_word = loader2.load()
text_chunks_word=text_splitter.split_documents(documents_word)
print(len(text_chunks_word))
#**Step 4: Convert the Text Chunks into Embeddings and Create a FAISS Vector Store***
vector_store_word=FAISS.from_documents(text_chunks_word, embeddings)
#vector_store_word.save_local(os.path.join(folder_path, "Dot-data-word"))
victor.merge_from(vector_store_word)
except Exception as error:
print("NO WORD DOCUMENTS FOUND" + str(error))
### POWER POINT
try:
loader3=DirectoryLoader(directory,
glob="*.pptx",
loader_cls=UnstructuredPowerPointLoader,
show_progress=True,
use_multithreading=True,
recursive=True)
documents_ppt = loader3.load()
text_chunks_ppt=text_splitter.split_documents(documents_ppt)
print(len(text_chunks_ppt))
#**Step 4: Convert the Text Chunks into Embeddings and Create a FAISS Vector Store***
vector_store_ppt=FAISS.from_documents(text_chunks_ppt, embeddings)
#vector_store_ppt.save_local(os.path.join(folder_path, "Dot-data-ppt"))
victor.merge_from(vector_store_ppt)
except Exception as error:
print("NO POWER POINTS FOUND" + str(error))
### EXCEL
try:
loader4=DirectoryLoader(directory,
glob="*.xlsx",
loader_cls=UnstructuredExcelLoader,
show_progress=True,
use_multithreading=True,
recursive=True)
documents_xlsx = loader4.load()
text_chunks_xlsx=text_splitter.split_documents(documents_xlsx)
print(len(text_chunks_ppt))
#**Step 4: Convert the Text Chunks into Embeddings and Create a FAISS Vector Store***
vector_store_xlsx=FAISS.from_documents(text_chunks_xlsx, embeddings)
#vector_store_ppt.save_local(os.path.join(folder_path, "Dot-data-ppt"))
victor.merge_from(vector_store_xlsx)
except Exception as error:
print("NO EXCEL FOUND" + str(error))
# MARKDOWN
try:
loader5=DirectoryLoader(directory,
glob="*.md",
loader_cls=UnstructuredMarkdownLoader,
show_progress=True,
use_multithreading=True,
recursive=True)
documents_md = loader5.load()
text_chunks_md=text_splitter.split_documents(documents_md)
print(len(text_chunks_md))
#**Step 4: Convert the Text Chunks into Embeddings and Create a FAISS Vector Store***
vector_store_md=FAISS.from_documents(text_chunks_md, embeddings)
#vector_store_ppt.save_local(os.path.join(folder_path, "Dot-data-ppt"))
victor.merge_from(vector_store_md)
except Exception as error:
print("NO MARKDOWN FOUND" + str(error))
victor.save_local(os.path.join(folder_path, "Dot-data"))
if __name__ == "__main__":
# Check if the correct number of command-line arguments is provided
print("Usage: python your_script.py <directory_path>")
# Get the directory path from the command-line argument
directory_path = sys.argv[1]
# Now, you can use the directory_path variable in your script
print(f"Processing directory: {directory_path}")
embeddings(directory_path)
print("LESGOOOOOO")
| [
"langchain.document_loaders.DirectoryLoader",
"langchain.embeddings.HuggingFaceEmbeddings",
"langchain.text_splitter.RecursiveCharacterTextSplitter",
"langchain.vectorstores.FAISS.from_documents",
"langchain.vectorstores.FAISS.from_texts"
] | [((506, 552), 'os.path.join', 'os.path.join', (['current_directory', '""".."""', '"""mpnet"""'], {}), "(current_directory, '..', 'mpnet')\n", (518, 552), False, 'import os\n'), ((666, 751), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': 'model_directory', 'model_kwargs': "{'device': 'mps'}"}), "(model_name=model_directory, model_kwargs={'device':\n 'mps'})\n", (687, 751), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((788, 855), 'langchain.text_splitter.RecursiveCharacterTextSplitter', 'RecursiveCharacterTextSplitter', ([], {'chunk_size': '(8000)', 'chunk_overlap': '(4000)'}), '(chunk_size=8000, chunk_overlap=4000)\n', (818, 855), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((972, 1009), 'langchain.vectorstores.FAISS.from_texts', 'FAISS.from_texts', (["['foo']", 'embeddings'], {}), "(['foo'], embeddings)\n", (988, 1009), False, 'from langchain.vectorstores import FAISS\n'), ((1262, 1301), 'os.path.join', 'os.path.join', (['desktop_path', 'folder_name'], {}), '(desktop_path, folder_name)\n', (1274, 1301), False, 'import os\n'), ((456, 482), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (472, 482), False, 'import os\n'), ((584, 616), 'os.path.abspath', 'os.path.abspath', (['model_directory'], {}), '(model_directory)\n', (599, 616), False, 'import os\n'), ((1098, 1121), 'os.path.expanduser', 'os.path.expanduser', (['"""~"""'], {}), "('~')\n", (1116, 1121), False, 'import os\n'), ((1358, 1385), 'os.path.exists', 'os.path.exists', (['folder_path'], {}), '(folder_path)\n', (1372, 1385), False, 'import os\n'), ((1395, 1419), 'os.makedirs', 'os.makedirs', (['folder_path'], {}), '(folder_path)\n', (1406, 1419), False, 'import os\n'), ((1554, 1683), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (['directory'], {'glob': '"""*.pdf"""', 'loader_cls': 'PyPDFLoader', 'show_progress': '(True)', 'use_multithreading': '(True)', 'recursive': '(True)'}), "(directory, glob='*.pdf', loader_cls=PyPDFLoader,\n show_progress=True, use_multithreading=True, recursive=True)\n", (1569, 1683), False, 'from langchain.document_loaders import PyPDFLoader, DirectoryLoader, UnstructuredExcelLoader, TextLoader, UnstructuredPowerPointLoader, UnstructuredMarkdownLoader, Docx2txtLoader\n'), ((2094, 2143), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['text_chunks_pdf', 'embeddings'], {}), '(text_chunks_pdf, embeddings)\n', (2114, 2143), False, 'from langchain.vectorstores import FAISS\n'), ((2389, 2522), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (['directory'], {'glob': '"""*.docx"""', 'loader_cls': 'Docx2txtLoader', 'show_progress': '(True)', 'use_multithreading': '(True)', 'recursive': '(True)'}), "(directory, glob='*.docx', loader_cls=Docx2txtLoader,\n show_progress=True, use_multithreading=True, recursive=True)\n", (2404, 2522), False, 'from langchain.document_loaders import PyPDFLoader, DirectoryLoader, UnstructuredExcelLoader, TextLoader, UnstructuredPowerPointLoader, UnstructuredMarkdownLoader, Docx2txtLoader\n'), ((2918, 2968), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['text_chunks_word', 'embeddings'], {}), '(text_chunks_word, embeddings)\n', (2938, 2968), False, 'from langchain.vectorstores import FAISS\n'), ((3230, 3383), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (['directory'], {'glob': '"""*.pptx"""', 'loader_cls': 'UnstructuredPowerPointLoader', 'show_progress': '(True)', 'use_multithreading': '(True)', 'recursive': '(True)'}), "(directory, glob='*.pptx', loader_cls=\n UnstructuredPowerPointLoader, show_progress=True, use_multithreading=\n True, recursive=True)\n", (3245, 3383), False, 'from langchain.document_loaders import PyPDFLoader, DirectoryLoader, UnstructuredExcelLoader, TextLoader, UnstructuredPowerPointLoader, UnstructuredMarkdownLoader, Docx2txtLoader\n'), ((3768, 3817), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['text_chunks_ppt', 'embeddings'], {}), '(text_chunks_ppt, embeddings)\n', (3788, 3817), False, 'from langchain.vectorstores import FAISS\n'), ((4066, 4213), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (['directory'], {'glob': '"""*.xlsx"""', 'loader_cls': 'UnstructuredExcelLoader', 'show_progress': '(True)', 'use_multithreading': '(True)', 'recursive': '(True)'}), "(directory, glob='*.xlsx', loader_cls=\n UnstructuredExcelLoader, show_progress=True, use_multithreading=True,\n recursive=True)\n", (4081, 4213), False, 'from langchain.document_loaders import PyPDFLoader, DirectoryLoader, UnstructuredExcelLoader, TextLoader, UnstructuredPowerPointLoader, UnstructuredMarkdownLoader, Docx2txtLoader\n'), ((4603, 4653), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['text_chunks_xlsx', 'embeddings'], {}), '(text_chunks_xlsx, embeddings)\n', (4623, 4653), False, 'from langchain.vectorstores import FAISS\n'), ((4897, 5045), 'langchain.document_loaders.DirectoryLoader', 'DirectoryLoader', (['directory'], {'glob': '"""*.md"""', 'loader_cls': 'UnstructuredMarkdownLoader', 'show_progress': '(True)', 'use_multithreading': '(True)', 'recursive': '(True)'}), "(directory, glob='*.md', loader_cls=\n UnstructuredMarkdownLoader, show_progress=True, use_multithreading=True,\n recursive=True)\n", (4912, 5045), False, 'from langchain.document_loaders import PyPDFLoader, DirectoryLoader, UnstructuredExcelLoader, TextLoader, UnstructuredPowerPointLoader, UnstructuredMarkdownLoader, Docx2txtLoader\n'), ((5426, 5474), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['text_chunks_md', 'embeddings'], {}), '(text_chunks_md, embeddings)\n', (5446, 5474), False, 'from langchain.vectorstores import FAISS\n'), ((5710, 5747), 'os.path.join', 'os.path.join', (['folder_path', '"""Dot-data"""'], {}), "(folder_path, 'Dot-data')\n", (5722, 5747), False, 'import os\n')] |
import os
import re
from typing import List, Optional, Any
from langchain.schema import Document
from langchain.text_splitter import RecursiveCharacterTextSplitter
from loguru import logger
from tqdm import tqdm
from src.config import local_embedding, retrieve_proxy, chunk_overlap, chunk_size, hf_emb_model_name
from src import shared
from src.utils import excel_to_string, get_files_hash, load_pkl, save_pkl
pwd_path = os.path.abspath(os.path.dirname(__file__))
class ChineseRecursiveTextSplitter(RecursiveCharacterTextSplitter):
"""Recursive text splitter for Chinese text.
copy from: https://github.com/chatchat-space/Langchain-Chatchat/tree/master
"""
def __init__(
self,
separators: Optional[List[str]] = None,
keep_separator: bool = True,
is_separator_regex: bool = True,
**kwargs: Any,
) -> None:
"""Create a new TextSplitter."""
super().__init__(keep_separator=keep_separator, **kwargs)
self._separators = separators or [
"\n\n",
"\n",
"。|！|？",
"\.\s|\!\s|\?\s",
"；|;\s",
"，|,\s"
]
self._is_separator_regex = is_separator_regex
@staticmethod
def _split_text_with_regex_from_end(
text: str, separator: str, keep_separator: bool
) -> List[str]:
# Now that we have the separator, split the text
if separator:
if keep_separator:
# The parentheses in the pattern keep the delimiters in the result.
_splits = re.split(f"({separator})", text)
splits = ["".join(i) for i in zip(_splits[0::2], _splits[1::2])]
if len(_splits) % 2 == 1:
splits += _splits[-1:]
else:
splits = re.split(separator, text)
else:
splits = list(text)
return [s for s in splits if s != ""]
def _split_text(self, text: str, separators: List[str]) -> List[str]:
"""Split incoming text and return chunks."""
final_chunks = []
# Get appropriate separator to use
separator = separators[-1]
new_separators = []
for i, _s in enumerate(separators):
_separator = _s if self._is_separator_regex else re.escape(_s)
if _s == "":
separator = _s
break
if re.search(_separator, text):
separator = _s
new_separators = separators[i + 1:]
break
_separator = separator if self._is_separator_regex else re.escape(separator)
splits = self._split_text_with_regex_from_end(text, _separator, self._keep_separator)
# Now go merging things, recursively splitting longer texts.
_good_splits = []
_separator = "" if self._keep_separator else separator
for s in splits:
if self._length_function(s) < self._chunk_size:
_good_splits.append(s)
else:
if _good_splits:
merged_text = self._merge_splits(_good_splits, _separator)
final_chunks.extend(merged_text)
_good_splits = []
if not new_separators:
final_chunks.append(s)
else:
other_info = self._split_text(s, new_separators)
final_chunks.extend(other_info)
if _good_splits:
merged_text = self._merge_splits(_good_splits, _separator)
final_chunks.extend(merged_text)
return [re.sub(r"\n{2,}", "\n", chunk.strip()) for chunk in final_chunks if chunk.strip() != ""]
def get_documents(file_paths):
text_splitter = ChineseRecursiveTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
documents = []
logger.debug("Loading documents...")
logger.debug(f"file_paths: {file_paths}")
for file in file_paths:
filepath = file.name
filename = os.path.basename(filepath)
file_type = os.path.splitext(filename)[1]
logger.info(f"loading file: {filename}")
texts = None
try:
if file_type == ".pdf":
import PyPDF2
logger.debug("Loading PDF...")
try:
from src.pdf_func import parse_pdf
from src.config import advance_docs
two_column = advance_docs["pdf"].get("two_column", False)
pdftext = parse_pdf(filepath, two_column).text
except:
pdftext = ""
with open(filepath, "rb") as pdfFileObj:
pdfReader = PyPDF2.PdfReader(pdfFileObj)
for page in tqdm(pdfReader.pages):
pdftext += page.extract_text()
texts = [Document(page_content=pdftext,
metadata={"source": filepath})]
elif file_type == ".docx":
logger.debug("Loading Word...")
from langchain.document_loaders import UnstructuredWordDocumentLoader
loader = UnstructuredWordDocumentLoader(filepath)
texts = loader.load()
elif file_type == ".pptx":
logger.debug("Loading PowerPoint...")
from langchain.document_loaders import UnstructuredPowerPointLoader
loader = UnstructuredPowerPointLoader(filepath)
texts = loader.load()
elif file_type == ".epub":
logger.debug("Loading EPUB...")
from langchain.document_loaders import UnstructuredEPubLoader
loader = UnstructuredEPubLoader(filepath)
texts = loader.load()
elif file_type == ".xlsx":
logger.debug("Loading Excel...")
text_list = excel_to_string(filepath)
texts = []
for elem in text_list:
texts.append(Document(page_content=elem,
metadata={"source": filepath}))
else:
logger.debug("Loading text file...")
from langchain_community.document_loaders import TextLoader
loader = TextLoader(filepath, "utf8")
texts = loader.load()
logger.debug(f"text size: {len(texts)}, text top3: {texts[:3]}")
except Exception as e:
logger.error(f"Error loading file: {filename}, {e}")
if texts is not None:
texts = text_splitter.split_documents(texts)
documents.extend(texts)
logger.debug(f"Documents loaded. documents size: {len(documents)}, top3: {documents[:3]}")
return documents
def construct_index(
api_key,
files,
load_from_cache_if_possible=True,
):
from langchain_community.vectorstores import FAISS
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
if api_key:
os.environ["OPENAI_API_KEY"] = api_key
else:
os.environ["OPENAI_API_KEY"] = "sk-xxxxxxx"
index_name = get_files_hash(files)
index_dir = os.path.join(pwd_path, '../index')
index_path = f"{index_dir}/{index_name}"
doc_file = f"{index_path}/docs.pkl"
if local_embedding:
embeddings = HuggingFaceEmbeddings(model_name=hf_emb_model_name)
else:
from langchain_community.embeddings import OpenAIEmbeddings
if os.environ.get("OPENAI_API_TYPE", "openai") == "openai":
embeddings = OpenAIEmbeddings(
openai_api_base=shared.state.openai_api_base,
openai_api_key=os.environ.get("OPENAI_EMBEDDING_API_KEY", api_key)
)
else:
embeddings = OpenAIEmbeddings(
deployment=os.environ["AZURE_EMBEDDING_DEPLOYMENT_NAME"],
openai_api_key=os.environ["AZURE_OPENAI_API_KEY"],
model=os.environ["AZURE_EMBEDDING_MODEL_NAME"],
openai_api_base=os.environ["AZURE_OPENAI_API_BASE_URL"],
openai_api_type="azure"
)
if os.path.exists(index_path) and load_from_cache_if_possible:
logger.info("找到了缓存的索引文件，加载中……")
index = FAISS.load_local(index_path, embeddings)
documents = load_pkl(doc_file)
return index, documents
else:
try:
documents = get_documents(files)
logger.info("构建索引中……")
with retrieve_proxy():
index = FAISS.from_documents(documents, embeddings)
logger.debug("索引构建完成！")
os.makedirs(index_dir, exist_ok=True)
index.save_local(index_path)
logger.debug("索引已保存至本地!")
save_pkl(documents, doc_file)
logger.debug("索引文档已保存至本地!")
return index, documents
except Exception as e:
logger.error(f"索引构建失败！error: {e}")
return None
| [
"langchain.document_loaders.UnstructuredWordDocumentLoader",
"langchain.embeddings.huggingface.HuggingFaceEmbeddings",
"langchain_community.vectorstores.FAISS.from_documents",
"langchain.document_loaders.UnstructuredPowerPointLoader",
"langchain.document_loaders.UnstructuredEPubLoader",
"langchain.schema.Document",
"langchain_community.vectorstores.FAISS.load_local",
"langchain_community.document_loaders.TextLoader",
"langchain_community.embeddings.OpenAIEmbeddings"
] | [((440, 465), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (455, 465), False, 'import os\n'), ((3874, 3910), 'loguru.logger.debug', 'logger.debug', (['"""Loading documents..."""'], {}), "('Loading documents...')\n", (3886, 3910), False, 'from loguru import logger\n'), ((3915, 3956), 'loguru.logger.debug', 'logger.debug', (['f"""file_paths: {file_paths}"""'], {}), "(f'file_paths: {file_paths}')\n", (3927, 3956), False, 'from loguru import logger\n'), ((7187, 7208), 'src.utils.get_files_hash', 'get_files_hash', (['files'], {}), '(files)\n', (7201, 7208), False, 'from src.utils import excel_to_string, get_files_hash, load_pkl, save_pkl\n'), ((7225, 7259), 'os.path.join', 'os.path.join', (['pwd_path', '"""../index"""'], {}), "(pwd_path, '../index')\n", (7237, 7259), False, 'import os\n'), ((4033, 4059), 'os.path.basename', 'os.path.basename', (['filepath'], {}), '(filepath)\n', (4049, 4059), False, 'import os\n'), ((4118, 4158), 'loguru.logger.info', 'logger.info', (['f"""loading file: {filename}"""'], {}), "(f'loading file: {filename}')\n", (4129, 4158), False, 'from loguru import logger\n'), ((7390, 7441), 'langchain.embeddings.huggingface.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': 'hf_emb_model_name'}), '(model_name=hf_emb_model_name)\n', (7411, 7441), False, 'from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n'), ((8186, 8212), 'os.path.exists', 'os.path.exists', (['index_path'], {}), '(index_path)\n', (8200, 8212), False, 'import os\n'), ((8254, 8285), 'loguru.logger.info', 'logger.info', (['"""找到了缓存的索引文件，加载中……"""'], {}), "('找到了缓存的索引文件，加载中……')\n", (8265, 8285), False, 'from loguru import logger\n'), ((8302, 8342), 'langchain_community.vectorstores.FAISS.load_local', 'FAISS.load_local', (['index_path', 'embeddings'], {}), '(index_path, embeddings)\n', (8318, 8342), False, 'from langchain_community.vectorstores import FAISS\n'), ((8363, 8381), 'src.utils.load_pkl', 'load_pkl', (['doc_file'], {}), '(doc_file)\n', (8371, 8381), False, 'from src.utils import excel_to_string, get_files_hash, load_pkl, save_pkl\n'), ((2427, 2454), 're.search', 're.search', (['_separator', 'text'], {}), '(_separator, text)\n', (2436, 2454), False, 'import re\n'), ((2626, 2646), 're.escape', 're.escape', (['separator'], {}), '(separator)\n', (2635, 2646), False, 'import re\n'), ((4080, 4106), 'os.path.splitext', 'os.path.splitext', (['filename'], {}), '(filename)\n', (4096, 4106), False, 'import os\n'), ((7531, 7574), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_TYPE"""', '"""openai"""'], {}), "('OPENAI_API_TYPE', 'openai')\n", (7545, 7574), False, 'import os\n'), ((7829, 8098), 'langchain_community.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'deployment': "os.environ['AZURE_EMBEDDING_DEPLOYMENT_NAME']", 'openai_api_key': "os.environ['AZURE_OPENAI_API_KEY']", 'model': "os.environ['AZURE_EMBEDDING_MODEL_NAME']", 'openai_api_base': "os.environ['AZURE_OPENAI_API_BASE_URL']", 'openai_api_type': '"""azure"""'}), "(deployment=os.environ['AZURE_EMBEDDING_DEPLOYMENT_NAME'],\n openai_api_key=os.environ['AZURE_OPENAI_API_KEY'], model=os.environ[\n 'AZURE_EMBEDDING_MODEL_NAME'], openai_api_base=os.environ[\n 'AZURE_OPENAI_API_BASE_URL'], openai_api_type='azure')\n", (7845, 8098), False, 'from langchain_community.embeddings import OpenAIEmbeddings\n'), ((8494, 8516), 'loguru.logger.info', 'logger.info', (['"""构建索引中……"""'], {}), "('构建索引中……')\n", (8505, 8516), False, 'from loguru import logger\n'), ((8632, 8655), 'loguru.logger.debug', 'logger.debug', (['"""索引构建完成！"""'], {}), "('索引构建完成！')\n", (8644, 8655), False, 'from loguru import logger\n'), ((8668, 8705), 'os.makedirs', 'os.makedirs', (['index_dir'], {'exist_ok': '(True)'}), '(index_dir, exist_ok=True)\n', (8679, 8705), False, 'import os\n'), ((8759, 8784), 'loguru.logger.debug', 'logger.debug', (['"""索引已保存至本地!"""'], {}), "('索引已保存至本地!')\n", (8771, 8784), False, 'from loguru import logger\n'), ((8797, 8826), 'src.utils.save_pkl', 'save_pkl', (['documents', 'doc_file'], {}), '(documents, doc_file)\n', (8805, 8826), False, 'from src.utils import excel_to_string, get_files_hash, load_pkl, save_pkl\n'), ((8839, 8866), 'loguru.logger.debug', 'logger.debug', (['"""索引文档已保存至本地!"""'], {}), "('索引文档已保存至本地!')\n", (8851, 8866), False, 'from loguru import logger\n'), ((1595, 1627), 're.split', 're.split', (['f"""({separator})"""', 'text'], {}), "(f'({separator})', text)\n", (1603, 1627), False, 'import re\n'), ((1837, 1862), 're.split', 're.split', (['separator', 'text'], {}), '(separator, text)\n', (1845, 1862), False, 'import re\n'), ((2320, 2333), 're.escape', 're.escape', (['_s'], {}), '(_s)\n', (2329, 2333), False, 'import re\n'), ((4275, 4305), 'loguru.logger.debug', 'logger.debug', (['"""Loading PDF..."""'], {}), "('Loading PDF...')\n", (4287, 4305), False, 'from loguru import logger\n'), ((6526, 6578), 'loguru.logger.error', 'logger.error', (['f"""Error loading file: {filename}, {e}"""'], {}), "(f'Error loading file: {filename}, {e}')\n", (6538, 6578), False, 'from loguru import logger\n'), ((8534, 8550), 'src.config.retrieve_proxy', 'retrieve_proxy', ([], {}), '()\n', (8548, 8550), False, 'from src.config import local_embedding, retrieve_proxy, chunk_overlap, chunk_size, hf_emb_model_name\n'), ((8576, 8619), 'langchain_community.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['documents', 'embeddings'], {}), '(documents, embeddings)\n', (8596, 8619), False, 'from langchain_community.vectorstores import FAISS\n'), ((8946, 8980), 'loguru.logger.error', 'logger.error', (['f"""索引构建失败！error: {e}"""'], {}), "(f'索引构建失败！error: {e}')\n", (8958, 8980), False, 'from loguru import logger\n'), ((4910, 4971), 'langchain.schema.Document', 'Document', ([], {'page_content': 'pdftext', 'metadata': "{'source': filepath}"}), "(page_content=pdftext, metadata={'source': filepath})\n", (4918, 4971), False, 'from langchain.schema import Document\n'), ((5062, 5093), 'loguru.logger.debug', 'logger.debug', (['"""Loading Word..."""'], {}), "('Loading Word...')\n", (5074, 5093), False, 'from loguru import logger\n'), ((5205, 5245), 'langchain.document_loaders.UnstructuredWordDocumentLoader', 'UnstructuredWordDocumentLoader', (['filepath'], {}), '(filepath)\n', (5235, 5245), False, 'from langchain.document_loaders import UnstructuredWordDocumentLoader\n'), ((7724, 7775), 'os.environ.get', 'os.environ.get', (['"""OPENAI_EMBEDDING_API_KEY"""', 'api_key'], {}), "('OPENAI_EMBEDDING_API_KEY', api_key)\n", (7738, 7775), False, 'import os\n'), ((4547, 4578), 'src.pdf_func.parse_pdf', 'parse_pdf', (['filepath', 'two_column'], {}), '(filepath, two_column)\n', (4556, 4578), False, 'from src.pdf_func import parse_pdf\n'), ((5339, 5376), 'loguru.logger.debug', 'logger.debug', (['"""Loading PowerPoint..."""'], {}), "('Loading PowerPoint...')\n", (5351, 5376), False, 'from loguru import logger\n'), ((5486, 5524), 'langchain.document_loaders.UnstructuredPowerPointLoader', 'UnstructuredPowerPointLoader', (['filepath'], {}), '(filepath)\n', (5514, 5524), False, 'from langchain.document_loaders import UnstructuredPowerPointLoader\n'), ((4738, 4766), 'PyPDF2.PdfReader', 'PyPDF2.PdfReader', (['pdfFileObj'], {}), '(pdfFileObj)\n', (4754, 4766), False, 'import PyPDF2\n'), ((4803, 4824), 'tqdm.tqdm', 'tqdm', (['pdfReader.pages'], {}), '(pdfReader.pages)\n', (4807, 4824), False, 'from tqdm import tqdm\n'), ((5618, 5649), 'loguru.logger.debug', 'logger.debug', (['"""Loading EPUB..."""'], {}), "('Loading EPUB...')\n", (5630, 5649), False, 'from loguru import logger\n'), ((5753, 5785), 'langchain.document_loaders.UnstructuredEPubLoader', 'UnstructuredEPubLoader', (['filepath'], {}), '(filepath)\n', (5775, 5785), False, 'from langchain.document_loaders import UnstructuredEPubLoader\n'), ((5879, 5911), 'loguru.logger.debug', 'logger.debug', (['"""Loading Excel..."""'], {}), "('Loading Excel...')\n", (5891, 5911), False, 'from loguru import logger\n'), ((5940, 5965), 'src.utils.excel_to_string', 'excel_to_string', (['filepath'], {}), '(filepath)\n', (5955, 5965), False, 'from src.utils import excel_to_string, get_files_hash, load_pkl, save_pkl\n'), ((6201, 6237), 'loguru.logger.debug', 'logger.debug', (['"""Loading text file..."""'], {}), "('Loading text file...')\n", (6213, 6237), False, 'from loguru import logger\n'), ((6339, 6367), 'langchain_community.document_loaders.TextLoader', 'TextLoader', (['filepath', '"""utf8"""'], {}), "(filepath, 'utf8')\n", (6349, 6367), False, 'from langchain_community.document_loaders import TextLoader\n'), ((6065, 6123), 'langchain.schema.Document', 'Document', ([], {'page_content': 'elem', 'metadata': "{'source': filepath}"}), "(page_content=elem, metadata={'source': filepath})\n", (6073, 6123), False, 'from langchain.schema import Document\n')] |
from fastapi import FastAPI
from langchain.chains import RetrievalQA
from langchain.chat_models import ChatOpenAI
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import ElasticVectorSearch
from config import openai_api_key
embedding = OpenAIEmbeddings(openai_api_key=openai_api_key)
db = ElasticVectorSearch(
elasticsearch_url="http://localhost:9200",
index_name="elastic-index",
embedding=embedding,
)
qa = RetrievalQA.from_chain_type(
llm=ChatOpenAI(temperature=0),
chain_type="stuff",
retriever=db.as_retriever(),
)
app = FastAPI()
@app.get("/")
def index():
return {
"message": "Make a post request to /ask to ask questions about Meditations by Marcus Aurelius"
}
@app.post("/ask")
def ask(query: str):
response = qa.run(query)
return {
"response": response,
}
| [
"langchain.vectorstores.ElasticVectorSearch",
"langchain.chat_models.ChatOpenAI",
"langchain.embeddings.openai.OpenAIEmbeddings"
] | [((274, 321), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'openai_api_key': 'openai_api_key'}), '(openai_api_key=openai_api_key)\n', (290, 321), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((328, 444), 'langchain.vectorstores.ElasticVectorSearch', 'ElasticVectorSearch', ([], {'elasticsearch_url': '"""http://localhost:9200"""', 'index_name': '"""elastic-index"""', 'embedding': 'embedding'}), "(elasticsearch_url='http://localhost:9200', index_name=\n 'elastic-index', embedding=embedding)\n", (347, 444), False, 'from langchain.vectorstores import ElasticVectorSearch\n'), ((590, 599), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (597, 599), False, 'from fastapi import FastAPI\n'), ((497, 522), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (507, 522), False, 'from langchain.chat_models import ChatOpenAI\n')] |
from abc import ABC, abstractmethod
from pathlib import Path
from typing import Dict, List
import pandas as pd
import streamlit as st
from langchain.chains import LLMChain
from langchain.prompts.few_shot import FewShotPromptTemplate
from doccano_mini.components import (
display_download_button,
openai_model_form,
task_instruction_editor,
usage,
)
from doccano_mini.utils import escape_markdown
class BasePage(ABC):
example_path: str = ""
def __init__(self, title: str) -> None:
self.title = title
@property
def columns(self) -> List[str]:
return []
def load_examples(self, filename: str) -> pd.DataFrame:
filepath = Path(__file__).parent.resolve().joinpath("examples", filename)
return pd.read_json(filepath)
def make_examples(self, columns: List[str]) -> List[Dict]:
df = self.load_examples(self.example_path)
edited_df = st.experimental_data_editor(df, num_rows="dynamic", width=1000)
examples = edited_df.to_dict(orient="records")
return examples
@abstractmethod
def make_prompt(self, examples: List[Dict]) -> FewShotPromptTemplate:
raise NotImplementedError()
@abstractmethod
def prepare_inputs(self, columns: List[str]) -> Dict:
raise NotImplementedError()
def annotate(self, examples: List[Dict]) -> List[Dict]:
return examples
def render(self) -> None:
st.title(self.title)
st.header("Annotate your data")
columns = self.columns
examples = self.make_examples(columns)
examples = self.annotate(examples)
prompt = self.make_prompt(examples)
prompt = task_instruction_editor(prompt)
st.header("Test")
col1, col2 = st.columns([3, 1])
with col1:
inputs = self.prepare_inputs(columns)
with col2:
llm = openai_model_form()
with st.expander("See your prompt"):
st.markdown(f"```\n{prompt.format(**inputs)}\n```")
if llm is None:
st.error("Enter your API key.")
if st.button("Predict", disabled=llm is None):
chain = LLMChain(llm=llm, prompt=prompt) # type:ignore
response = chain.run(**inputs)
st.markdown(escape_markdown(response).replace("\n", " \n"))
chain.save("config.yaml")
display_download_button()
usage()
| [
"langchain.chains.LLMChain"
] | [((763, 785), 'pandas.read_json', 'pd.read_json', (['filepath'], {}), '(filepath)\n', (775, 785), True, 'import pandas as pd\n'), ((921, 984), 'streamlit.experimental_data_editor', 'st.experimental_data_editor', (['df'], {'num_rows': '"""dynamic"""', 'width': '(1000)'}), "(df, num_rows='dynamic', width=1000)\n", (948, 984), True, 'import streamlit as st\n'), ((1434, 1454), 'streamlit.title', 'st.title', (['self.title'], {}), '(self.title)\n', (1442, 1454), True, 'import streamlit as st\n'), ((1463, 1494), 'streamlit.header', 'st.header', (['"""Annotate your data"""'], {}), "('Annotate your data')\n", (1472, 1494), True, 'import streamlit as st\n'), ((1678, 1709), 'doccano_mini.components.task_instruction_editor', 'task_instruction_editor', (['prompt'], {}), '(prompt)\n', (1701, 1709), False, 'from doccano_mini.components import display_download_button, openai_model_form, task_instruction_editor, usage\n'), ((1719, 1736), 'streamlit.header', 'st.header', (['"""Test"""'], {}), "('Test')\n", (1728, 1736), True, 'import streamlit as st\n'), ((1758, 1776), 'streamlit.columns', 'st.columns', (['[3, 1]'], {}), '([3, 1])\n', (1768, 1776), True, 'import streamlit as st\n'), ((2096, 2138), 'streamlit.button', 'st.button', (['"""Predict"""'], {'disabled': '(llm is None)'}), "('Predict', disabled=llm is None)\n", (2105, 2138), True, 'import streamlit as st\n'), ((2409, 2416), 'doccano_mini.components.usage', 'usage', ([], {}), '()\n', (2414, 2416), False, 'from doccano_mini.components import display_download_button, openai_model_form, task_instruction_editor, usage\n'), ((1885, 1904), 'doccano_mini.components.openai_model_form', 'openai_model_form', ([], {}), '()\n', (1902, 1904), False, 'from doccano_mini.components import display_download_button, openai_model_form, task_instruction_editor, usage\n'), ((1919, 1949), 'streamlit.expander', 'st.expander', (['"""See your prompt"""'], {}), "('See your prompt')\n", (1930, 1949), True, 'import streamlit as st\n'), ((2052, 2083), 'streamlit.error', 'st.error', (['"""Enter your API key."""'], {}), "('Enter your API key.')\n", (2060, 2083), True, 'import streamlit as st\n'), ((2160, 2192), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (2168, 2192), False, 'from langchain.chains import LLMChain\n'), ((2375, 2400), 'doccano_mini.components.display_download_button', 'display_download_button', ([], {}), '()\n', (2398, 2400), False, 'from doccano_mini.components import display_download_button, openai_model_form, task_instruction_editor, usage\n'), ((2275, 2300), 'doccano_mini.utils.escape_markdown', 'escape_markdown', (['response'], {}), '(response)\n', (2290, 2300), False, 'from doccano_mini.utils import escape_markdown\n'), ((685, 699), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (689, 699), False, 'from pathlib import Path\n')] |
"""This module contains functions for loading and managing vector stores in the Wandbot ingestion system.
The module includes the following functions:
- `load`: Loads the vector store from the specified source artifact path and returns the name of the resulting artifact.
Typical usage example:
project = "wandbot-dev"
entity = "wandbot"
source_artifact_path = "wandbot/wandbot-dev/raw_dataset:latest"
result_artifact_name = "wandbot_index"
load(project, entity, source_artifact_path, result_artifact_name)
"""
import json
import pathlib
from typing import Any, Dict, List
from langchain.schema import Document as LcDocument
from llama_index.callbacks import WandbCallbackHandler
import wandb
from wandbot.ingestion import preprocess_data
from wandbot.ingestion.config import VectorStoreConfig
from wandbot.utils import (
get_logger,
load_index,
load_service_context,
load_storage_context,
)
logger = get_logger(__name__)
def load(
project: str,
entity: str,
source_artifact_path: str,
result_artifact_name: str = "wandbot_index",
) -> str:
"""Load the vector store.
Loads the vector store from the specified source artifact path and returns the name of the resulting artifact.
Args:
project: The name of the project.
entity: The name of the entity.
source_artifact_path: The path to the source artifact.
result_artifact_name: The name of the resulting artifact. Defaults to "wandbot_index".
Returns:
The name of the resulting artifact.
Raises:
wandb.Error: An error occurred during the loading process.
"""
config: VectorStoreConfig = VectorStoreConfig()
run: wandb.Run = wandb.init(
project=project, entity=entity, job_type="create_vectorstore"
)
artifact: wandb.Artifact = run.use_artifact(
source_artifact_path, type="dataset"
)
artifact_dir: str = artifact.download()
storage_context = load_storage_context(config.embedding_dim)
service_context = load_service_context(
embeddings_cache=str(config.embeddings_cache),
llm="gpt-3.5-turbo-16k-0613",
temperature=config.temperature,
max_retries=config.max_retries,
)
document_files: List[pathlib.Path] = list(
pathlib.Path(artifact_dir).rglob("documents.jsonl")
)
transformed_documents: List[LcDocument] = []
for document_file in document_files:
documents: List[LcDocument] = []
with document_file.open() as f:
for line in f:
doc_dict: Dict[str, Any] = json.loads(line)
doc: LcDocument = LcDocument(**doc_dict)
documents.append(doc)
transformed_documents.extend(preprocess_data.load(documents))
unique_objects = {obj.hash: obj for obj in transformed_documents}
transformed_documents = list(unique_objects.values())
index = load_index(
transformed_documents,
service_context,
storage_context,
persist_dir=str(config.persist_dir),
)
wandb_callback: WandbCallbackHandler = WandbCallbackHandler()
wandb_callback.persist_index(index, index_name=result_artifact_name)
wandb_callback.finish()
run.finish()
return f"{entity}/{project}/{result_artifact_name}:latest"
| [
"langchain.schema.Document"
] | [((944, 964), 'wandbot.utils.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (954, 964), False, 'from wandbot.utils import get_logger, load_index, load_service_context, load_storage_context\n'), ((1677, 1696), 'wandbot.ingestion.config.VectorStoreConfig', 'VectorStoreConfig', ([], {}), '()\n', (1694, 1696), False, 'from wandbot.ingestion.config import VectorStoreConfig\n'), ((1718, 1791), 'wandb.init', 'wandb.init', ([], {'project': 'project', 'entity': 'entity', 'job_type': '"""create_vectorstore"""'}), "(project=project, entity=entity, job_type='create_vectorstore')\n", (1728, 1791), False, 'import wandb\n'), ((1972, 2014), 'wandbot.utils.load_storage_context', 'load_storage_context', (['config.embedding_dim'], {}), '(config.embedding_dim)\n', (1992, 2014), False, 'from wandbot.utils import get_logger, load_index, load_service_context, load_storage_context\n'), ((3103, 3125), 'llama_index.callbacks.WandbCallbackHandler', 'WandbCallbackHandler', ([], {}), '()\n', (3123, 3125), False, 'from llama_index.callbacks import WandbCallbackHandler\n'), ((2743, 2774), 'wandbot.ingestion.preprocess_data.load', 'preprocess_data.load', (['documents'], {}), '(documents)\n', (2763, 2774), False, 'from wandbot.ingestion import preprocess_data\n'), ((2294, 2320), 'pathlib.Path', 'pathlib.Path', (['artifact_dir'], {}), '(artifact_dir)\n', (2306, 2320), False, 'import pathlib\n'), ((2594, 2610), 'json.loads', 'json.loads', (['line'], {}), '(line)\n', (2604, 2610), False, 'import json\n'), ((2645, 2667), 'langchain.schema.Document', 'LcDocument', ([], {}), '(**doc_dict)\n', (2655, 2667), True, 'from langchain.schema import Document as LcDocument\n')] |
"""
This module contains the OpenAIImageToText class,
which is a subclass of ChatOpenAI that is specialized for converting images to text.
"""
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
class OpenAIImageToText(ChatOpenAI):
"""
A class that uses OpenAI's Chat API to convert an image to text.
Args:
llm_config (dict): The configuration for the language model.
Attributes:
max_tokens (int): The maximum number of tokens to generate in the response.
Methods:
run(image_url): Runs the image-to-text conversion using the provided image URL.
"""
def __init__(self, llm_config: dict):
"""
Initializes an instance of the OpenAIImageToText class.
Args:
llm_config (dict): The configuration for the language model.
"""
super().__init__(**llm_config, max_tokens=256)
def run(self, image_url: str):
"""
Runs the image-to-text conversion using the provided image URL.
Args:
image_url (str): The URL of the image to convert to text.
Returns:
str: The generated text description of the image.
"""
message = HumanMessage(
content=[
{"type": "text", "text": "What is this image showing"},
{
"type": "image_url",
"image_url": {
"url": image_url,
"detail": "auto",
},
},
]
)
# Use the invoke method from the superclass (ChatOpenAI)
result = self.invoke([message]).content
return result
| [
"langchain_core.messages.HumanMessage"
] | [((1233, 1394), 'langchain_core.messages.HumanMessage', 'HumanMessage', ([], {'content': "[{'type': 'text', 'text': 'What is this image showing'}, {'type':\n 'image_url', 'image_url': {'url': image_url, 'detail': 'auto'}}]"}), "(content=[{'type': 'text', 'text': 'What is this image showing'\n }, {'type': 'image_url', 'image_url': {'url': image_url, 'detail':\n 'auto'}}])\n", (1245, 1394), False, 'from langchain_core.messages import HumanMessage\n')] |
from langchain.tools import BaseTool
from langchain.tools.render import render_text_description
from langchain_core.language_models.base import LanguageModelLike
from langchain_core.messages import (
AIMessage,
FunctionMessage,
HumanMessage,
SystemMessage,
)
from langgraph.checkpoint import BaseCheckpointSaver
from langgraph.graph import END
from langgraph.graph.message import MessageGraph
from langgraph.prebuilt import ToolExecutor, ToolInvocation
from app.agent_types.prompts import xml_template
from app.message_types import LiberalFunctionMessage
def _collapse_messages(messages):
log = ""
if isinstance(messages[-1], AIMessage):
scratchpad = messages[:-1]
final = messages[-1]
else:
scratchpad = messages
final = None
if len(scratchpad) % 2 != 0:
raise ValueError("Unexpected")
for i in range(0, len(scratchpad), 2):
action = messages[i]
observation = messages[i + 1]
log += f"{action.content}<observation>{observation.content}</observation>"
if final is not None:
log += final.content
return AIMessage(content=log)
def construct_chat_history(messages):
collapsed_messages = []
temp_messages = []
for message in messages:
if isinstance(message, HumanMessage):
if temp_messages:
collapsed_messages.append(_collapse_messages(temp_messages))
temp_messages = []
collapsed_messages.append(message)
elif isinstance(message, LiberalFunctionMessage):
_dict = message.dict()
_dict["content"] = str(_dict["content"])
m_c = FunctionMessage(**_dict)
temp_messages.append(m_c)
else:
temp_messages.append(message)
# Don't forget to add the last non-human message if it exists
if temp_messages:
collapsed_messages.append(_collapse_messages(temp_messages))
return collapsed_messages
def get_xml_agent_executor(
tools: list[BaseTool],
llm: LanguageModelLike,
system_message: str,
interrupt_before_action: bool,
checkpoint: BaseCheckpointSaver,
):
formatted_system_message = xml_template.format(
system_message=system_message,
tools=render_text_description(tools),
tool_names=", ".join([t.name for t in tools]),
)
llm_with_stop = llm.bind(stop=["</tool_input>", "<observation>"])
def _get_messages(messages):
return [
SystemMessage(content=formatted_system_message)
] + construct_chat_history(messages)
agent = _get_messages | llm_with_stop
tool_executor = ToolExecutor(tools)
# Define the function that determines whether to continue or not
def should_continue(messages):
last_message = messages[-1]
if "</tool>" in last_message.content:
return "continue"
else:
return "end"
# Define the function to execute tools
async def call_tool(messages):
# Based on the continue condition
# we know the last message involves a function call
last_message = messages[-1]
# We construct an ToolInvocation from the function_call
tool, tool_input = last_message.content.split("</tool>")
_tool = tool.split("<tool>")[1]
if "<tool_input>" not in tool_input:
_tool_input = ""
else:
_tool_input = tool_input.split("<tool_input>")[1]
if "</tool_input>" in _tool_input:
_tool_input = _tool_input.split("</tool_input>")[0]
action = ToolInvocation(
tool=_tool,
tool_input=_tool_input,
)
# We call the tool_executor and get back a response
response = await tool_executor.ainvoke(action)
# We use the response to create a FunctionMessage
function_message = LiberalFunctionMessage(content=response, name=action.tool)
# We return a list, because this will get added to the existing list
return function_message
workflow = MessageGraph()
# Define the two nodes we will cycle between
workflow.add_node("agent", agent)
workflow.add_node("action", call_tool)
# Set the entrypoint as `agent`
# This means that this node is the first one called
workflow.set_entry_point("agent")
# We now add a conditional edge
workflow.add_conditional_edges(
# First, we define the start node. We use `agent`.
# This means these are the edges taken after the `agent` node is called.
"agent",
# Next, we pass in the function that will determine which node is called next.
should_continue,
# Finally we pass in a mapping.
# The keys are strings, and the values are other nodes.
# END is a special node marking that the graph should finish.
# What will happen is we will call `should_continue`, and then the output of that
# will be matched against the keys in this mapping.
# Based on which one it matches, that node will then be called.
{
# If `tools`, then we call the tool node.
"continue": "action",
# Otherwise we finish.
"end": END,
},
)
# We now add a normal edge from `tools` to `agent`.
# This means that after `tools` is called, `agent` node is called next.
workflow.add_edge("action", "agent")
# Finally, we compile it!
# This compiles it into a LangChain Runnable,
# meaning you can use it as you would any other runnable
app = workflow.compile(checkpointer=checkpoint)
if interrupt_before_action:
app.interrupt = ["action:inbox"]
return app
| [
"langchain_core.messages.AIMessage",
"langchain.tools.render.render_text_description",
"langchain_core.messages.SystemMessage",
"langchain_core.messages.FunctionMessage"
] | [((1121, 1143), 'langchain_core.messages.AIMessage', 'AIMessage', ([], {'content': 'log'}), '(content=log)\n', (1130, 1143), False, 'from langchain_core.messages import AIMessage, FunctionMessage, HumanMessage, SystemMessage\n'), ((2644, 2663), 'langgraph.prebuilt.ToolExecutor', 'ToolExecutor', (['tools'], {}), '(tools)\n', (2656, 2663), False, 'from langgraph.prebuilt import ToolExecutor, ToolInvocation\n'), ((4058, 4072), 'langgraph.graph.message.MessageGraph', 'MessageGraph', ([], {}), '()\n', (4070, 4072), False, 'from langgraph.graph.message import MessageGraph\n'), ((3588, 3638), 'langgraph.prebuilt.ToolInvocation', 'ToolInvocation', ([], {'tool': '_tool', 'tool_input': '_tool_input'}), '(tool=_tool, tool_input=_tool_input)\n', (3602, 3638), False, 'from langgraph.prebuilt import ToolExecutor, ToolInvocation\n'), ((3874, 3932), 'app.message_types.LiberalFunctionMessage', 'LiberalFunctionMessage', ([], {'content': 'response', 'name': 'action.tool'}), '(content=response, name=action.tool)\n', (3896, 3932), False, 'from app.message_types import LiberalFunctionMessage\n'), ((2261, 2291), 'langchain.tools.render.render_text_description', 'render_text_description', (['tools'], {}), '(tools)\n', (2284, 2291), False, 'from langchain.tools.render import render_text_description\n'), ((1663, 1687), 'langchain_core.messages.FunctionMessage', 'FunctionMessage', ([], {}), '(**_dict)\n', (1678, 1687), False, 'from langchain_core.messages import AIMessage, FunctionMessage, HumanMessage, SystemMessage\n'), ((2488, 2535), 'langchain_core.messages.SystemMessage', 'SystemMessage', ([], {'content': 'formatted_system_message'}), '(content=formatted_system_message)\n', (2501, 2535), False, 'from langchain_core.messages import AIMessage, FunctionMessage, HumanMessage, SystemMessage\n')] |
# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from langchain_core.messages.ai import AIMessage
from langchain_core.messages.human import HumanMessage
from langchain_google_el_carro import ElCarroEngine
from langchain_google_el_carro.chat_message_history import ElCarroChatMessageHistory
db_host = os.environ["DB_HOST"]
db_port = int(os.environ["DB_PORT"])
db_name = os.environ["DB_NAME"]
db_user = os.environ["DB_USER"]
db_password = os.environ["DB_PASSWORD"]
elcarro_engine = ElCarroEngine.from_instance(
db_host,
db_port,
db_name,
db_user,
db_password,
)
# Create a new table
elcarro_engine.init_chat_history_table("my_table")
# Create ElCarroChatMessageHistory
history = ElCarroChatMessageHistory(
elcarro_engine=elcarro_engine, session_id="test_session", table_name="my_table"
)
# Add a few messages
history.add_user_message("hi!")
history.add_ai_message("whats up?")
messages = history.messages
print(f"Messages = {messages}")
# verify messages are correct
assert messages[0].content == "hi!"
assert type(messages[0]) is HumanMessage
assert messages[1].content == "whats up?"
assert type(messages[1]) is AIMessage
history.clear()
assert len(history.messages) == 0
# Drop the table
elcarro_engine.drop_chat_history_table("my_table")
| [
"langchain_google_el_carro.ElCarroEngine.from_instance",
"langchain_google_el_carro.chat_message_history.ElCarroChatMessageHistory"
] | [((1019, 1095), 'langchain_google_el_carro.ElCarroEngine.from_instance', 'ElCarroEngine.from_instance', (['db_host', 'db_port', 'db_name', 'db_user', 'db_password'], {}), '(db_host, db_port, db_name, db_user, db_password)\n', (1046, 1095), False, 'from langchain_google_el_carro import ElCarroEngine\n'), ((1238, 1349), 'langchain_google_el_carro.chat_message_history.ElCarroChatMessageHistory', 'ElCarroChatMessageHistory', ([], {'elcarro_engine': 'elcarro_engine', 'session_id': '"""test_session"""', 'table_name': '"""my_table"""'}), "(elcarro_engine=elcarro_engine, session_id=\n 'test_session', table_name='my_table')\n", (1263, 1349), False, 'from langchain_google_el_carro.chat_message_history import ElCarroChatMessageHistory\n')] |
from typing import Optional, Type
from langchain.callbacks.manager import CallbackManagerForToolRun
from langchain_community.utilities import OpenWeatherMapAPIWrapper
from pydantic import BaseModel, Field
from exceptions import ToolEnvKeyException
from tools.base import BaseTool
class OpenWeatherMapSchema(BaseModel):
query: str = Field(
...,
description="The search query for OpenWeatherMap.",
)
class OpenWeatherMapTool(BaseTool):
"""Tool that queries the OpenWeatherMap API."""
name = "OpenWeatherMap Search"
slug = "openWeatherMapSearch"
description = (
"A wrapper around OpenWeatherMap API. "
"Useful for fetching current weather information for a specified location. "
"Input should be a location string (e.g. London,GB)."
)
args_schema: Type[OpenWeatherMapSchema] = OpenWeatherMapSchema
tool_id = "47a7e8c6-49f2-4b8d-8ba4-8879099e1be2"
def _run(
self, query: str, run_manager: Optional[CallbackManagerForToolRun] = None
) -> str:
"""Search OpenWeatherMap and return the results."""
openweathermap_api_key = self.get_env_key("OPENWEATHERMAP_API_KEY")
if not openweathermap_api_key:
raise ToolEnvKeyException(
f"Please fill OpenWeatherMap API Key in the [OpenWeatherMap Toolkit](/toolkits/{self.toolkit_slug})"
)
search = OpenWeatherMapAPIWrapper(openweathermap_api_key=openweathermap_api_key)
try:
return search.run(query)
except Exception as err:
if "Invalid API Key" in str(err):
raise ToolEnvKeyException(
f"OpenWeatherMap API Key is not valid. Please check in the [OpenWeatherMap Toolkit](/toolkits/{self.toolkit_slug})"
)
return "Could not retrieve weather information using OpenWeatherMap. Please try again later."
| [
"langchain_community.utilities.OpenWeatherMapAPIWrapper"
] | [((340, 402), 'pydantic.Field', 'Field', (['...'], {'description': '"""The search query for OpenWeatherMap."""'}), "(..., description='The search query for OpenWeatherMap.')\n", (345, 402), False, 'from pydantic import BaseModel, Field\n'), ((1406, 1477), 'langchain_community.utilities.OpenWeatherMapAPIWrapper', 'OpenWeatherMapAPIWrapper', ([], {'openweathermap_api_key': 'openweathermap_api_key'}), '(openweathermap_api_key=openweathermap_api_key)\n', (1430, 1477), False, 'from langchain_community.utilities import OpenWeatherMapAPIWrapper\n'), ((1236, 1367), 'exceptions.ToolEnvKeyException', 'ToolEnvKeyException', (['f"""Please fill OpenWeatherMap API Key in the [OpenWeatherMap Toolkit](/toolkits/{self.toolkit_slug})"""'], {}), "(\n f'Please fill OpenWeatherMap API Key in the [OpenWeatherMap Toolkit](/toolkits/{self.toolkit_slug})'\n )\n", (1255, 1367), False, 'from exceptions import ToolEnvKeyException\n'), ((1630, 1776), 'exceptions.ToolEnvKeyException', 'ToolEnvKeyException', (['f"""OpenWeatherMap API Key is not valid. Please check in the [OpenWeatherMap Toolkit](/toolkits/{self.toolkit_slug})"""'], {}), "(\n f'OpenWeatherMap API Key is not valid. Please check in the [OpenWeatherMap Toolkit](/toolkits/{self.toolkit_slug})'\n )\n", (1649, 1776), False, 'from exceptions import ToolEnvKeyException\n')] |
from textwrap import dedent
from langchain import OpenAI
from langchain.schema import BaseModel
from utils import format_prompt_components_without_tools
def extract_first_message(message: str) -> str:
"""The LLM can continue the conversation from the recipient. So extract just the first line."""
return message.split("\n")[0].strip()
def get_unsolicited_message_prompt(ai_prefix: str, human_prefix: str) -> str:
"""Get prompt for unsolicited message."""
inspirational_thought = f"""
*{ai_prefix} then drew on their past experiences with {human_prefix} and continued the conversation*"""
return dedent(inspirational_thought)
def generate_unsolicited_message(
prompt: str,
model: BaseModel,
ai_settings: dict,
contact_settings: dict,
temperature: int = 0,
) -> str:
"""Generate AI message without message from user."""
ai_prefix, _, prefix, suffix = format_prompt_components_without_tools(
ai_settings, contact_settings
)
chat_history = model.memory.load_memory_variables({})["chat_history"]
prompt = "\n".join([prefix, suffix, prompt, "", f"{ai_prefix}:"]).format(
chat_history=chat_history
)
llm = OpenAI(temperature=temperature)
message = llm(prompt)
message = extract_first_message(message)
model.memory.chat_memory.add_ai_message(message)
return message
| [
"langchain.OpenAI"
] | [((627, 656), 'textwrap.dedent', 'dedent', (['inspirational_thought'], {}), '(inspirational_thought)\n', (633, 656), False, 'from textwrap import dedent\n'), ((912, 981), 'utils.format_prompt_components_without_tools', 'format_prompt_components_without_tools', (['ai_settings', 'contact_settings'], {}), '(ai_settings, contact_settings)\n', (950, 981), False, 'from utils import format_prompt_components_without_tools\n'), ((1199, 1230), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': 'temperature'}), '(temperature=temperature)\n', (1205, 1230), False, 'from langchain import OpenAI\n')] |
"""VectorStore wrapper around a Postgres/PGVector database."""
from __future__ import annotations
import enum
import logging
import uuid
from typing import Any, Dict, Iterable, List, Optional, Tuple, Type
import sqlalchemy
from pgvector.sqlalchemy import Vector
from sqlalchemy.dialects.postgresql import JSON, UUID
from sqlalchemy.orm import Session, declarative_base, relationship
from langchain.docstore.document import Document
from langchain.embeddings.base import Embeddings
from langchain.utils import get_from_dict_or_env
from langchain.vectorstores.base import VectorStore
Base = declarative_base() # type: Any
ADA_TOKEN_COUNT = 1536
_LANGCHAIN_DEFAULT_COLLECTION_NAME = "langchain"
class BaseModel(Base):
__abstract__ = True
uuid = sqlalchemy.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
class CollectionStore(BaseModel):
__tablename__ = "langchain_pg_collection"
name = sqlalchemy.Column(sqlalchemy.String)
cmetadata = sqlalchemy.Column(JSON)
embeddings = relationship(
"EmbeddingStore",
back_populates="collection",
passive_deletes=True,
)
@classmethod
def get_by_name(cls, session: Session, name: str) -> Optional["CollectionStore"]:
return session.query(cls).filter(cls.name == name).first() # type: ignore
@classmethod
def get_or_create(
cls,
session: Session,
name: str,
cmetadata: Optional[dict] = None,
) -> Tuple["CollectionStore", bool]:
"""
Get or create a collection.
Returns [Collection, bool] where the bool is True if the collection was created.
"""
created = False
collection = cls.get_by_name(session, name)
if collection:
return collection, created
collection = cls(name=name, cmetadata=cmetadata)
session.add(collection)
session.commit()
created = True
return collection, created
class EmbeddingStore(BaseModel):
__tablename__ = "langchain_pg_embedding"
collection_id = sqlalchemy.Column(
UUID(as_uuid=True),
sqlalchemy.ForeignKey(
f"{CollectionStore.__tablename__}.uuid",
ondelete="CASCADE",
),
)
collection = relationship(CollectionStore, back_populates="embeddings")
embedding: Vector = sqlalchemy.Column(Vector(ADA_TOKEN_COUNT))
document = sqlalchemy.Column(sqlalchemy.String, nullable=True)
cmetadata = sqlalchemy.Column(JSON, nullable=True)
# custom_id : any user defined id
custom_id = sqlalchemy.Column(sqlalchemy.String, nullable=True)
class QueryResult:
EmbeddingStore: EmbeddingStore
distance: float
class DistanceStrategy(str, enum.Enum):
EUCLIDEAN = EmbeddingStore.embedding.l2_distance
COSINE = EmbeddingStore.embedding.cosine_distance
MAX_INNER_PRODUCT = EmbeddingStore.embedding.max_inner_product
DEFAULT_DISTANCE_STRATEGY = DistanceStrategy.EUCLIDEAN
class PGVector(VectorStore):
"""
VectorStore implementation using Postgres and pgvector.
- `connection_string` is a postgres connection string.
- `embedding_function` any embedding function implementing
`langchain.embeddings.base.Embeddings` interface.
- `collection_name` is the name of the collection to use. (default: langchain)
- NOTE: This is not the name of the table, but the name of the collection.
The tables will be created when initializing the store (if not exists)
So, make sure the user has the right permissions to create tables.
- `distance_strategy` is the distance strategy to use. (default: EUCLIDEAN)
- `EUCLIDEAN` is the euclidean distance.
- `COSINE` is the cosine distance.
- `pre_delete_collection` if True, will delete the collection if it exists.
(default: False)
- Useful for testing.
"""
def __init__(
self,
connection_string: str,
embedding_function: Embeddings,
collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
collection_metadata: Optional[dict] = None,
distance_strategy: DistanceStrategy = DEFAULT_DISTANCE_STRATEGY,
pre_delete_collection: bool = False,
logger: Optional[logging.Logger] = None,
) -> None:
self.connection_string = connection_string
self.embedding_function = embedding_function
self.collection_name = collection_name
self.collection_metadata = collection_metadata
self.distance_strategy = distance_strategy
self.pre_delete_collection = pre_delete_collection
self.logger = logger or logging.getLogger(__name__)
self.__post_init__()
def __post_init__(
self,
) -> None:
"""
Initialize the store.
"""
self._conn = self.connect()
# self.create_vector_extension()
self.create_tables_if_not_exists()
self.create_collection()
def connect(self) -> sqlalchemy.engine.Connection:
engine = sqlalchemy.create_engine(self.connection_string)
conn = engine.connect()
return conn
def create_vector_extension(self) -> None:
try:
with Session(self._conn) as session:
statement = sqlalchemy.text("CREATE EXTENSION IF NOT EXISTS vector")
session.execute(statement)
session.commit()
except Exception as e:
self.logger.exception(e)
def create_tables_if_not_exists(self) -> None:
with self._conn.begin():
Base.metadata.create_all(self._conn)
def drop_tables(self) -> None:
with self._conn.begin():
Base.metadata.drop_all(self._conn)
def create_collection(self) -> None:
if self.pre_delete_collection:
self.delete_collection()
with Session(self._conn) as session:
CollectionStore.get_or_create(
session, self.collection_name, cmetadata=self.collection_metadata
)
def delete_collection(self) -> None:
self.logger.debug("Trying to delete collection")
with Session(self._conn) as session:
collection = self.get_collection(session)
if not collection:
self.logger.warning("Collection not found")
return
session.delete(collection)
session.commit()
def get_collection(self, session: Session) -> Optional["CollectionStore"]:
return CollectionStore.get_by_name(session, self.collection_name)
@classmethod
def __from(
cls,
texts: List[str],
embeddings: List[List[float]],
embedding: Embeddings,
metadatas: Optional[List[dict]] = None,
ids: Optional[List[str]] = None,
collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
pre_delete_collection: bool = False,
**kwargs: Any,
) -> PGVector:
if ids is None:
ids = [str(uuid.uuid1()) for _ in texts]
if not metadatas:
metadatas = [{} for _ in texts]
connection_string = cls.get_connection_string(kwargs)
store = cls(
connection_string=connection_string,
collection_name=collection_name,
embedding_function=embedding,
distance_strategy=distance_strategy,
pre_delete_collection=pre_delete_collection,
)
store.add_embeddings(
texts=texts, embeddings=embeddings, metadatas=metadatas, ids=ids, **kwargs
)
return store
def add_embeddings(
self,
texts: List[str],
embeddings: List[List[float]],
metadatas: List[dict],
ids: List[str],
**kwargs: Any,
) -> None:
"""Add embeddings to the vectorstore.
Args:
texts: Iterable of strings to add to the vectorstore.
embeddings: List of list of embedding vectors.
metadatas: List of metadatas associated with the texts.
kwargs: vectorstore specific parameters
"""
with Session(self._conn) as session:
collection = self.get_collection(session)
if not collection:
raise ValueError("Collection not found")
for text, metadata, embedding, id in zip(texts, metadatas, embeddings, ids):
embedding_store = EmbeddingStore(
embedding=embedding,
document=text,
cmetadata=metadata,
custom_id=id,
)
collection.embeddings.append(embedding_store)
session.add(embedding_store)
session.commit()
def add_texts(
self,
texts: Iterable[str],
metadatas: Optional[List[dict]] = None,
ids: Optional[List[str]] = None,
**kwargs: Any,
) -> List[str]:
"""Run more texts through the embeddings and add to the vectorstore.
Args:
texts: Iterable of strings to add to the vectorstore.
metadatas: Optional list of metadatas associated with the texts.
kwargs: vectorstore specific parameters
Returns:
List of ids from adding the texts into the vectorstore.
"""
if ids is None:
ids = [str(uuid.uuid1()) for _ in texts]
embeddings = self.embedding_function.embed_documents(list(texts))
if not metadatas:
metadatas = [{} for _ in texts]
with Session(self._conn) as session:
collection = self.get_collection(session)
if not collection:
raise ValueError("Collection not found")
for text, metadata, embedding, id in zip(texts, metadatas, embeddings, ids):
embedding_store = EmbeddingStore(
embedding=embedding,
document=text,
cmetadata=metadata,
custom_id=id,
)
collection.embeddings.append(embedding_store)
session.add(embedding_store)
session.commit()
return ids
def similarity_search(
self,
query: str,
k: int = 4,
filter: Optional[dict] = None,
**kwargs: Any,
) -> List[Document]:
"""Run similarity search with PGVector with distance.
Args:
query (str): Query text to search for.
k (int): Number of results to return. Defaults to 4.
filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
Returns:
List of Documents most similar to the query.
"""
embedding = self.embedding_function.embed_query(text=query)
return self.similarity_search_by_vector(
embedding=embedding,
k=k,
filter=filter,
)
def similarity_search_with_score(
self,
query: str,
k: int = 4,
filter: Optional[dict] = None,
) -> List[Tuple[Document, float]]:
"""Return docs most similar to query.
Args:
query: Text to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
Returns:
List of Documents most similar to the query and score for each
"""
embedding = self.embedding_function.embed_query(query)
docs = self.similarity_search_with_score_by_vector(
embedding=embedding, k=k, filter=filter
)
return docs
def similarity_search_with_score_by_vector(
self,
embedding: List[float],
k: int = 4,
filter: Optional[dict] = None,
) -> List[Tuple[Document, float]]:
with Session(self._conn) as session:
collection = self.get_collection(session)
if not collection:
raise ValueError("Collection not found")
filter_by = EmbeddingStore.collection_id == collection.uuid
if filter is not None:
filter_clauses = []
for key, value in filter.items():
IN = "in"
if isinstance(value, dict) and IN in map(str.lower, value):
value_case_insensitive = {
k.lower(): v for k, v in value.items()
}
filter_by_metadata = EmbeddingStore.cmetadata[key].astext.in_(
value_case_insensitive[IN]
)
filter_clauses.append(filter_by_metadata)
else:
filter_by_metadata = EmbeddingStore.cmetadata[
key
].astext == str(value)
filter_clauses.append(filter_by_metadata)
filter_by = sqlalchemy.and_(filter_by, *filter_clauses)
results: List[QueryResult] = (
session.query(
EmbeddingStore,
self.distance_strategy(embedding).label("distance"), # type: ignore
)
.filter(filter_by)
.order_by(sqlalchemy.asc("distance"))
.join(
CollectionStore,
EmbeddingStore.collection_id == CollectionStore.uuid,
)
.limit(k)
.all()
)
docs = [
(
Document(
page_content=result.EmbeddingStore.document,
metadata=result.EmbeddingStore.cmetadata,
),
result.distance if self.embedding_function is not None else None,
)
for result in results
]
return docs
def similarity_search_by_vector(
self,
embedding: List[float],
k: int = 4,
filter: Optional[dict] = None,
**kwargs: Any,
) -> List[Document]:
"""Return docs most similar to embedding vector.
Args:
embedding: Embedding to look up documents similar to.
k: Number of Documents to return. Defaults to 4.
filter (Optional[Dict[str, str]]): Filter by metadata. Defaults to None.
Returns:
List of Documents most similar to the query vector.
"""
docs_and_scores = self.similarity_search_with_score_by_vector(
embedding=embedding, k=k, filter=filter
)
return [doc for doc, _ in docs_and_scores]
@classmethod
def from_texts(
cls: Type[PGVector],
texts: List[str],
embedding: Embeddings,
metadatas: Optional[List[dict]] = None,
collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
ids: Optional[List[str]] = None,
pre_delete_collection: bool = False,
**kwargs: Any,
) -> PGVector:
"""
Return VectorStore initialized from texts and embeddings.
Postgres connection string is required
"Either pass it as a parameter
or set the PGVECTOR_CONNECTION_STRING environment variable.
"""
embeddings = embedding.embed_documents(list(texts))
return cls.__from(
texts,
embeddings,
embedding,
metadatas=metadatas,
ids=ids,
collection_name=collection_name,
distance_strategy=distance_strategy,
pre_delete_collection=pre_delete_collection,
**kwargs,
)
@classmethod
def from_embeddings(
cls,
text_embeddings: List[Tuple[str, List[float]]],
embedding: Embeddings,
metadatas: Optional[List[dict]] = None,
collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
ids: Optional[List[str]] = None,
pre_delete_collection: bool = False,
**kwargs: Any,
) -> PGVector:
"""Construct PGVector wrapper from raw documents and pre-
generated embeddings.
Return VectorStore initialized from documents and embeddings.
Postgres connection string is required
"Either pass it as a parameter
or set the PGVECTOR_CONNECTION_STRING environment variable.
Example:
.. code-block:: python
from langchain import PGVector
from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
text_embeddings = embeddings.embed_documents(texts)
text_embedding_pairs = list(zip(texts, text_embeddings))
faiss = PGVector.from_embeddings(text_embedding_pairs, embeddings)
"""
texts = [t[0] for t in text_embeddings]
embeddings = [t[1] for t in text_embeddings]
return cls.__from(
texts,
embeddings,
embedding,
metadatas=metadatas,
ids=ids,
collection_name=collection_name,
distance_strategy=distance_strategy,
pre_delete_collection=pre_delete_collection,
**kwargs,
)
@classmethod
def from_existing_index(
cls: Type[PGVector],
embedding: Embeddings,
collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
pre_delete_collection: bool = False,
**kwargs: Any,
) -> PGVector:
"""
Get intsance of an existing PGVector store.This method will
return the instance of the store without inserting any new
embeddings
"""
connection_string = cls.get_connection_string(kwargs)
store = cls(
connection_string=connection_string,
collection_name=collection_name,
embedding_function=embedding,
distance_strategy=distance_strategy,
pre_delete_collection=pre_delete_collection,
)
return store
@classmethod
def get_connection_string(cls, kwargs: Dict[str, Any]) -> str:
connection_string: str = get_from_dict_or_env(
data=kwargs,
key="connection_string",
env_key="PGVECTOR_CONNECTION_STRING",
)
if not connection_string:
raise ValueError(
"Postgres connection string is required"
"Either pass it as a parameter"
"or set the PGVECTOR_CONNECTION_STRING environment variable."
)
return connection_string
@classmethod
def from_documents(
cls: Type[PGVector],
documents: List[Document],
embedding: Embeddings,
collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
distance_strategy: DistanceStrategy = DEFAULT_DISTANCE_STRATEGY,
ids: Optional[List[str]] = None,
pre_delete_collection: bool = False,
**kwargs: Any,
) -> PGVector:
"""
Return VectorStore initialized from documents and embeddings.
Postgres connection string is required
"Either pass it as a parameter
or set the PGVECTOR_CONNECTION_STRING environment variable.
"""
texts = [d.page_content for d in documents]
metadatas = [d.metadata for d in documents]
connection_string = cls.get_connection_string(kwargs)
kwargs["connection_string"] = connection_string
return cls.from_texts(
texts=texts,
pre_delete_collection=pre_delete_collection,
embedding=embedding,
distance_strategy=distance_strategy,
metadatas=metadatas,
ids=ids,
collection_name=collection_name,
**kwargs,
)
@classmethod
def connection_string_from_db_params(
cls,
driver: str,
host: str,
port: int,
database: str,
user: str,
password: str,
) -> str:
"""Return connection string from database parameters."""
return f"postgresql+{driver}://{user}:{password}@{host}:{port}/{database}"
| [
"langchain.utils.get_from_dict_or_env",
"langchain.docstore.document.Document"
] | [((593, 611), 'sqlalchemy.orm.declarative_base', 'declarative_base', ([], {}), '()\n', (609, 611), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((929, 965), 'sqlalchemy.Column', 'sqlalchemy.Column', (['sqlalchemy.String'], {}), '(sqlalchemy.String)\n', (946, 965), False, 'import sqlalchemy\n'), ((982, 1005), 'sqlalchemy.Column', 'sqlalchemy.Column', (['JSON'], {}), '(JSON)\n', (999, 1005), False, 'import sqlalchemy\n'), ((1024, 1110), 'sqlalchemy.orm.relationship', 'relationship', (['"""EmbeddingStore"""'], {'back_populates': '"""collection"""', 'passive_deletes': '(True)'}), "('EmbeddingStore', back_populates='collection', passive_deletes\n =True)\n", (1036, 1110), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((2264, 2322), 'sqlalchemy.orm.relationship', 'relationship', (['CollectionStore'], {'back_populates': '"""embeddings"""'}), "(CollectionStore, back_populates='embeddings')\n", (2276, 2322), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((2406, 2457), 'sqlalchemy.Column', 'sqlalchemy.Column', (['sqlalchemy.String'], {'nullable': '(True)'}), '(sqlalchemy.String, nullable=True)\n', (2423, 2457), False, 'import sqlalchemy\n'), ((2474, 2512), 'sqlalchemy.Column', 'sqlalchemy.Column', (['JSON'], {'nullable': '(True)'}), '(JSON, nullable=True)\n', (2491, 2512), False, 'import sqlalchemy\n'), ((2568, 2619), 'sqlalchemy.Column', 'sqlalchemy.Column', (['sqlalchemy.String'], {'nullable': '(True)'}), '(sqlalchemy.String, nullable=True)\n', (2585, 2619), False, 'import sqlalchemy\n'), ((777, 795), 'sqlalchemy.dialects.postgresql.UUID', 'UUID', ([], {'as_uuid': '(True)'}), '(as_uuid=True)\n', (781, 795), False, 'from sqlalchemy.dialects.postgresql import JSON, UUID\n'), ((2094, 2112), 'sqlalchemy.dialects.postgresql.UUID', 'UUID', ([], {'as_uuid': '(True)'}), '(as_uuid=True)\n', (2098, 2112), False, 'from sqlalchemy.dialects.postgresql import JSON, UUID\n'), ((2122, 2209), 'sqlalchemy.ForeignKey', 'sqlalchemy.ForeignKey', (['f"""{CollectionStore.__tablename__}.uuid"""'], {'ondelete': '"""CASCADE"""'}), "(f'{CollectionStore.__tablename__}.uuid', ondelete=\n 'CASCADE')\n", (2143, 2209), False, 'import sqlalchemy\n'), ((2366, 2389), 'pgvector.sqlalchemy.Vector', 'Vector', (['ADA_TOKEN_COUNT'], {}), '(ADA_TOKEN_COUNT)\n', (2372, 2389), False, 'from pgvector.sqlalchemy import Vector\n'), ((5035, 5083), 'sqlalchemy.create_engine', 'sqlalchemy.create_engine', (['self.connection_string'], {}), '(self.connection_string)\n', (5059, 5083), False, 'import sqlalchemy\n'), ((18474, 18575), 'langchain.utils.get_from_dict_or_env', 'get_from_dict_or_env', ([], {'data': 'kwargs', 'key': '"""connection_string"""', 'env_key': '"""PGVECTOR_CONNECTION_STRING"""'}), "(data=kwargs, key='connection_string', env_key=\n 'PGVECTOR_CONNECTION_STRING')\n", (18494, 18575), False, 'from langchain.utils import get_from_dict_or_env\n'), ((4645, 4672), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (4662, 4672), False, 'import logging\n'), ((5856, 5875), 'sqlalchemy.orm.Session', 'Session', (['self._conn'], {}), '(self._conn)\n', (5863, 5875), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((6139, 6158), 'sqlalchemy.orm.Session', 'Session', (['self._conn'], {}), '(self._conn)\n', (6146, 6158), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((8181, 8200), 'sqlalchemy.orm.Session', 'Session', (['self._conn'], {}), '(self._conn)\n', (8188, 8200), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((9616, 9635), 'sqlalchemy.orm.Session', 'Session', (['self._conn'], {}), '(self._conn)\n', (9623, 9635), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((11942, 11961), 'sqlalchemy.orm.Session', 'Session', (['self._conn'], {}), '(self._conn)\n', (11949, 11961), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((5214, 5233), 'sqlalchemy.orm.Session', 'Session', (['self._conn'], {}), '(self._conn)\n', (5221, 5233), False, 'from sqlalchemy.orm import Session, declarative_base, relationship\n'), ((5274, 5330), 'sqlalchemy.text', 'sqlalchemy.text', (['"""CREATE EXTENSION IF NOT EXISTS vector"""'], {}), "('CREATE EXTENSION IF NOT EXISTS vector')\n", (5289, 5330), False, 'import sqlalchemy\n'), ((13070, 13113), 'sqlalchemy.and_', 'sqlalchemy.and_', (['filter_by', '*filter_clauses'], {}), '(filter_by, *filter_clauses)\n', (13085, 13113), False, 'import sqlalchemy\n'), ((13684, 13784), 'langchain.docstore.document.Document', 'Document', ([], {'page_content': 'result.EmbeddingStore.document', 'metadata': 'result.EmbeddingStore.cmetadata'}), '(page_content=result.EmbeddingStore.document, metadata=result.\n EmbeddingStore.cmetadata)\n', (13692, 13784), False, 'from langchain.docstore.document import Document\n'), ((7065, 7077), 'uuid.uuid1', 'uuid.uuid1', ([], {}), '()\n', (7075, 7077), False, 'import uuid\n'), ((9426, 9438), 'uuid.uuid1', 'uuid.uuid1', ([], {}), '()\n', (9436, 9438), False, 'import uuid\n'), ((13393, 13419), 'sqlalchemy.asc', 'sqlalchemy.asc', (['"""distance"""'], {}), "('distance')\n", (13407, 13419), False, 'import sqlalchemy\n')] |
import tempfile
import time
import os
from utils import compute_sha1_from_file
from langchain.schema import Document
import streamlit as st
from langchain.text_splitter import RecursiveCharacterTextSplitter
from typing import List
from sqlite3 import Connection
from verse.sqlite_helper import *
def update_metadata(conn: Connection, docs_with_metadata: List[Document]):
insert_tuple = list(
set(
map(
lambda x: (
hash(x.metadata["file_sha1"]),
x.metadata["file_sha1"],
x.metadata["file_name"],
),
docs_with_metadata,
)
)
)
insertmany(conn=conn, datalist=insert_tuple)
def process_file(
conn: Connection, file, loader_class, file_suffix, stats_db=None
) -> List[Document]:
documents = []
file_name = file.name
file_size = file.size
if st.secrets.self_hosted == "false":
if file_size > 1000000:
st.error(
"File size is too large. Please upload a file smaller than 1MB or self host."
)
return
dateshort = time.strftime("%Y%m%d")
with tempfile.NamedTemporaryFile(delete=False, suffix=file_suffix) as tmp_file:
tmp_file.write(file.getvalue())
tmp_file.flush()
loader = loader_class(tmp_file.name)
documents = loader.load()
file_sha1 = compute_sha1_from_file(tmp_file.name)
os.remove(tmp_file.name)
chunk_size = st.session_state["chunk_size"]
chunk_overlap = st.session_state["chunk_overlap"]
print(f"Chunk Size {chunk_size} Overlap {chunk_overlap}")
text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
chunk_size=chunk_size, chunk_overlap=chunk_overlap, separators=["\n\n", ""]
)
documents = text_splitter.split_documents(documents)
# Add the document sha1 as metadata to each document
docs_with_metadata = [
Document(
page_content=doc.page_content,
metadata={
"file_sha1": file_sha1,
"file_size": file_size,
"file_name": file_name,
"chunk_size": chunk_size,
"chunk_overlap": chunk_overlap,
"date": dateshort,
"file_type": file_suffix,
"page": doc.metadata["page"],
"dbsource": doc.metadata["source"]
},
)
for doc in documents
]
return docs_with_metadata
| [
"langchain.text_splitter.RecursiveCharacterTextSplitter.from_tiktoken_encoder",
"langchain.schema.Document"
] | [((1152, 1175), 'time.strftime', 'time.strftime', (['"""%Y%m%d"""'], {}), "('%Y%m%d')\n", (1165, 1175), False, 'import time\n'), ((1468, 1492), 'os.remove', 'os.remove', (['tmp_file.name'], {}), '(tmp_file.name)\n', (1477, 1492), False, 'import os\n'), ((1679, 1812), 'langchain.text_splitter.RecursiveCharacterTextSplitter.from_tiktoken_encoder', 'RecursiveCharacterTextSplitter.from_tiktoken_encoder', ([], {'chunk_size': 'chunk_size', 'chunk_overlap': 'chunk_overlap', 'separators': "['\\n\\n', '']"}), "(chunk_size=chunk_size,\n chunk_overlap=chunk_overlap, separators=['\\n\\n', ''])\n", (1731, 1812), False, 'from langchain.text_splitter import RecursiveCharacterTextSplitter\n'), ((1185, 1246), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'delete': '(False)', 'suffix': 'file_suffix'}), '(delete=False, suffix=file_suffix)\n', (1212, 1246), False, 'import tempfile\n'), ((1425, 1462), 'utils.compute_sha1_from_file', 'compute_sha1_from_file', (['tmp_file.name'], {}), '(tmp_file.name)\n', (1447, 1462), False, 'from utils import compute_sha1_from_file\n'), ((1973, 2281), 'langchain.schema.Document', 'Document', ([], {'page_content': 'doc.page_content', 'metadata': "{'file_sha1': file_sha1, 'file_size': file_size, 'file_name': file_name,\n 'chunk_size': chunk_size, 'chunk_overlap': chunk_overlap, 'date':\n dateshort, 'file_type': file_suffix, 'page': doc.metadata['page'],\n 'dbsource': doc.metadata['source']}"}), "(page_content=doc.page_content, metadata={'file_sha1': file_sha1,\n 'file_size': file_size, 'file_name': file_name, 'chunk_size':\n chunk_size, 'chunk_overlap': chunk_overlap, 'date': dateshort,\n 'file_type': file_suffix, 'page': doc.metadata['page'], 'dbsource': doc\n .metadata['source']})\n", (1981, 2281), False, 'from langchain.schema import Document\n'), ((998, 1095), 'streamlit.error', 'st.error', (['"""File size is too large. Please upload a file smaller than 1MB or self host."""'], {}), "(\n 'File size is too large. Please upload a file smaller than 1MB or self host.'\n )\n", (1006, 1095), True, 'import streamlit as st\n')] |
import json
import logging
from typing import Any, Dict, Iterator, List, Optional
import requests
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.llms.base import LLM
from langchain.pydantic_v1 import Field
from langchain.schema.output import GenerationChunk
logger = logging.getLogger(__name__)
class TextGen(LLM):
"""text-generation-webui models.
To use, you should have the text-generation-webui installed, a model loaded,
and --api added as a command-line option.
Suggested installation, use one-click installer for your OS:
https://github.com/oobabooga/text-generation-webui#one-click-installers
Parameters below taken from text-generation-webui api example:
https://github.com/oobabooga/text-generation-webui/blob/main/api-examples/api-example.py
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(model_url="http://localhost:8500")
"""
model_url: str
"""The full URL to the textgen webui including http[s]://host:port """
preset: Optional[str] = None
"""The preset to use in the textgen webui """
max_new_tokens: Optional[int] = 250
"""The maximum number of tokens to generate."""
do_sample: bool = Field(True, alias="do_sample")
"""Do sample"""
temperature: Optional[float] = 1.3
"""Primary factor to control randomness of outputs. 0 = deterministic
(only the most likely token is used). Higher value = more randomness."""
top_p: Optional[float] = 0.1
"""If not set to 1, select tokens with probabilities adding up to less than this
number. Higher value = higher range of possible random results."""
typical_p: Optional[float] = 1
"""If not set to 1, select only tokens that are at least this much more likely to
appear than random tokens, given the prior text."""
epsilon_cutoff: Optional[float] = 0 # In units of 1e-4
"""Epsilon cutoff"""
eta_cutoff: Optional[float] = 0 # In units of 1e-4
"""ETA cutoff"""
repetition_penalty: Optional[float] = 1.18
"""Exponential penalty factor for repeating prior tokens. 1 means no penalty,
higher value = less repetition, lower value = more repetition."""
top_k: Optional[float] = 40
"""Similar to top_p, but select instead only the top_k most likely tokens.
Higher value = higher range of possible random results."""
min_length: Optional[int] = 0
"""Minimum generation length in tokens."""
no_repeat_ngram_size: Optional[int] = 0
"""If not set to 0, specifies the length of token sets that are completely blocked
from repeating at all. Higher values = blocks larger phrases,
lower values = blocks words or letters from repeating.
Only 0 or high values are a good idea in most cases."""
num_beams: Optional[int] = 1
"""Number of beams"""
penalty_alpha: Optional[float] = 0
"""Penalty Alpha"""
length_penalty: Optional[float] = 1
"""Length Penalty"""
early_stopping: bool = Field(False, alias="early_stopping")
"""Early stopping"""
seed: int = Field(-1, alias="seed")
"""Seed (-1 for random)"""
add_bos_token: bool = Field(True, alias="add_bos_token")
"""Add the bos_token to the beginning of prompts.
Disabling this can make the replies more creative."""
truncation_length: Optional[int] = 2048
"""Truncate the prompt up to this length. The leftmost tokens are removed if
the prompt exceeds this length. Most models require this to be at most 2048."""
ban_eos_token: bool = Field(False, alias="ban_eos_token")
"""Ban the eos_token. Forces the model to never end the generation prematurely."""
skip_special_tokens: bool = Field(True, alias="skip_special_tokens")
"""Skip special tokens. Some specific models need this unset."""
stopping_strings: Optional[List[str]] = []
"""A list of strings to stop generation when encountered."""
streaming: bool = False
"""Whether to stream the results, token by token."""
@property
def _default_params(self) -> Dict[str, Any]:
"""Get the default parameters for calling textgen."""
return {
"max_new_tokens": self.max_new_tokens,
"do_sample": self.do_sample,
"temperature": self.temperature,
"top_p": self.top_p,
"typical_p": self.typical_p,
"epsilon_cutoff": self.epsilon_cutoff,
"eta_cutoff": self.eta_cutoff,
"repetition_penalty": self.repetition_penalty,
"top_k": self.top_k,
"min_length": self.min_length,
"no_repeat_ngram_size": self.no_repeat_ngram_size,
"num_beams": self.num_beams,
"penalty_alpha": self.penalty_alpha,
"length_penalty": self.length_penalty,
"early_stopping": self.early_stopping,
"seed": self.seed,
"add_bos_token": self.add_bos_token,
"truncation_length": self.truncation_length,
"ban_eos_token": self.ban_eos_token,
"skip_special_tokens": self.skip_special_tokens,
"stopping_strings": self.stopping_strings,
}
@property
def _identifying_params(self) -> Dict[str, Any]:
"""Get the identifying parameters."""
return {**{"model_url": self.model_url}, **self._default_params}
@property
def _llm_type(self) -> str:
"""Return type of llm."""
return "textgen"
def _get_parameters(self, stop: Optional[List[str]] = None) -> Dict[str, Any]:
"""
Performs sanity check, preparing parameters in format needed by textgen.
Args:
stop (Optional[List[str]]): List of stop sequences for textgen.
Returns:
Dictionary containing the combined parameters.
"""
# Raise error if stop sequences are in both input and default params
# if self.stop and stop is not None:
if self.stopping_strings and stop is not None:
raise ValueError("`stop` found in both the input and default params.")
if self.preset is None:
params = self._default_params
else:
params = {"preset": self.preset}
# then sets it as configured, or default to an empty list:
params["stop"] = self.stopping_strings or stop or []
return params
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Call the textgen web API and return the output.
Args:
prompt: The prompt to use for generation.
stop: A list of strings to stop generation when encountered.
Returns:
The generated text.
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(model_url="http://localhost:5000")
llm("Write a story about llamas.")
"""
if self.streaming:
combined_text_output = ""
for chunk in self._stream(
prompt=prompt, stop=stop, run_manager=run_manager, **kwargs
):
combined_text_output += chunk.text
print(prompt + combined_text_output)
result = combined_text_output
else:
url = f"{self.model_url}/api/v1/generate"
params = self._get_parameters(stop)
request = params.copy()
request["prompt"] = prompt
response = requests.post(url, json=request)
if response.status_code == 200:
result = response.json()["results"][0]["text"]
print(prompt + result)
else:
print(f"ERROR: response: {response}")
result = ""
return result
def _stream(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> Iterator[GenerationChunk]:
"""Yields results objects as they are generated in real time.
It also calls the callback manager's on_llm_new_token event with
similar parameters to the OpenAI LLM class method of the same name.
Args:
prompt: The prompts to pass into the model.
stop: Optional list of stop words to use when generating.
Returns:
A generator representing the stream of tokens being generated.
Yields:
A dictionary like objects containing a string token and metadata.
See text-generation-webui docs and below for more.
Example:
.. code-block:: python
from langchain.llms import TextGen
llm = TextGen(
model_url = "ws://localhost:5005"
streaming=True
)
for chunk in llm.stream("Ask 'Hi, how are you?' like a pirate:'",
stop=["'","\n"]):
print(chunk, end='', flush=True)
"""
try:
import websocket
except ImportError:
raise ImportError(
"The `websocket-client` package is required for streaming."
)
params = {**self._get_parameters(stop), **kwargs}
url = f"{self.model_url}/api/v1/stream"
request = params.copy()
request["prompt"] = prompt
websocket_client = websocket.WebSocket()
websocket_client.connect(url)
websocket_client.send(json.dumps(request))
while True:
result = websocket_client.recv()
result = json.loads(result)
if result["event"] == "text_stream":
chunk = GenerationChunk(
text=result["text"],
generation_info=None,
)
yield chunk
elif result["event"] == "stream_end":
websocket_client.close()
return
if run_manager:
run_manager.on_llm_new_token(token=chunk.text)
| [
"langchain.pydantic_v1.Field",
"langchain.schema.output.GenerationChunk"
] | [((303, 330), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (320, 330), False, 'import logging\n'), ((1278, 1308), 'langchain.pydantic_v1.Field', 'Field', (['(True)'], {'alias': '"""do_sample"""'}), "(True, alias='do_sample')\n", (1283, 1308), False, 'from langchain.pydantic_v1 import Field\n'), ((3044, 3080), 'langchain.pydantic_v1.Field', 'Field', (['(False)'], {'alias': '"""early_stopping"""'}), "(False, alias='early_stopping')\n", (3049, 3080), False, 'from langchain.pydantic_v1 import Field\n'), ((3123, 3146), 'langchain.pydantic_v1.Field', 'Field', (['(-1)'], {'alias': '"""seed"""'}), "(-1, alias='seed')\n", (3128, 3146), False, 'from langchain.pydantic_v1 import Field\n'), ((3205, 3239), 'langchain.pydantic_v1.Field', 'Field', (['(True)'], {'alias': '"""add_bos_token"""'}), "(True, alias='add_bos_token')\n", (3210, 3239), False, 'from langchain.pydantic_v1 import Field\n'), ((3589, 3624), 'langchain.pydantic_v1.Field', 'Field', (['(False)'], {'alias': '"""ban_eos_token"""'}), "(False, alias='ban_eos_token')\n", (3594, 3624), False, 'from langchain.pydantic_v1 import Field\n'), ((3745, 3785), 'langchain.pydantic_v1.Field', 'Field', (['(True)'], {'alias': '"""skip_special_tokens"""'}), "(True, alias='skip_special_tokens')\n", (3750, 3785), False, 'from langchain.pydantic_v1 import Field\n'), ((9592, 9613), 'websocket.WebSocket', 'websocket.WebSocket', ([], {}), '()\n', (9611, 9613), False, 'import websocket\n'), ((7631, 7663), 'requests.post', 'requests.post', (['url'], {'json': 'request'}), '(url, json=request)\n', (7644, 7663), False, 'import requests\n'), ((9684, 9703), 'json.dumps', 'json.dumps', (['request'], {}), '(request)\n', (9694, 9703), False, 'import json\n'), ((9792, 9810), 'json.loads', 'json.loads', (['result'], {}), '(result)\n', (9802, 9810), False, 'import json\n'), ((9885, 9943), 'langchain.schema.output.GenerationChunk', 'GenerationChunk', ([], {'text': "result['text']", 'generation_info': 'None'}), "(text=result['text'], generation_info=None)\n", (9900, 9943), False, 'from langchain.schema.output import GenerationChunk\n')] |
# imports
from loguru import logger
# LLM modules
from langchain_community.llms.huggingface_hub import HuggingFaceHub
from langchain_community.llms.ollama import Ollama
from langchain_openai import ChatOpenAI, AzureChatOpenAI
from langchain.callbacks.manager import CallbackManager
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
# local imports
import settings_template as settings
class LLMCreator():
"""
LLM class to import into other modules
"""
def __init__(self, llm_type=None, llm_model_type=None, local_api_url=None, azureopenai_api_version=None) -> None:
self.llm_type = settings.LLM_TYPE if llm_type is None else llm_type
self.llm_model_type = settings.LLM_MODEL_TYPE if llm_model_type is None else llm_model_type
self.local_api_url = settings.API_URL if local_api_url is None else local_api_url
self.azureopenai_api_version = settings.AZUREOPENAI_API_VERSION \
if azureopenai_api_version is None and settings.AZUREOPENAI_API_VERSION is not None \
else azureopenai_api_version
def get_llm(self):
"""
returns, based on settings, the llm object
"""
# if llm_type is "chatopenai"
if self.llm_type == "chatopenai":
# default llm_model_type value is "gpt-3.5-turbo"
self.llm_model_type = "gpt-3.5-turbo"
if self.llm_model_type == "gpt35_16":
self.llm_model_type = "gpt-3.5-turbo-16k"
elif self.llm_model_type == "gpt4":
self.llm_model_type = "gpt-4"
self.llm = ChatOpenAI(
client=None,
model=self.llm_model_type,
temperature=0,
)
# else, if llm_type is "huggingface"
elif self.llm_type == "huggingface":
# default value is llama-2, with maximum output length 512
self.llm_model_type = "meta-llama/Llama-2-7b-chat-hf"
max_length = 512
if self.llm_model_type == 'GoogleFlan':
self.llm_model_type = 'google/flan-t5-base'
max_length = 512
self.llm = HuggingFaceHub(repo_id=self.llm_model_type,
model_kwargs={"temperature": 0.1,
"max_length": max_length}
)
# else, if llm_type is "local_llm"
elif self.llm_type == "local_llm":
logger.info("Use Local LLM")
logger.info("Retrieving " + self.llm_model_type)
# If API URL is defined, use it
if self.local_api_url is not None:
logger.info("Using local api url " + self.local_api_url)
self.llm = Ollama(
model=self.llm_model_type,
base_url=self.local_api_url,
callback_manager=CallbackManager([StreamingStdOutCallbackHandler()])
)
else:
self.llm = Ollama(
model=self.llm_model_type,
callback_manager=CallbackManager([StreamingStdOutCallbackHandler()])
)
logger.info("Retrieved " + self.llm_model_type)
# else, if llm_type is "azureopenai"
elif self.llm_type == "azureopenai":
logger.info("Use Azure OpenAI LLM")
logger.info("Retrieving " + self.llm_model_type)
self.llm = AzureChatOpenAI(
azure_deployment=self.llm_model_type,
azure_endpoint=self.local_api_url,
api_version=self.azureopenai_api_version,
)
logger.info("Retrieved " + self.llm_model_type)
return self.llm
| [
"langchain_openai.AzureChatOpenAI",
"langchain_openai.ChatOpenAI",
"langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler",
"langchain_community.llms.huggingface_hub.HuggingFaceHub"
] | [((1610, 1675), 'langchain_openai.ChatOpenAI', 'ChatOpenAI', ([], {'client': 'None', 'model': 'self.llm_model_type', 'temperature': '(0)'}), '(client=None, model=self.llm_model_type, temperature=0)\n', (1620, 1675), False, 'from langchain_openai import ChatOpenAI, AzureChatOpenAI\n'), ((2163, 2272), 'langchain_community.llms.huggingface_hub.HuggingFaceHub', 'HuggingFaceHub', ([], {'repo_id': 'self.llm_model_type', 'model_kwargs': "{'temperature': 0.1, 'max_length': max_length}"}), "(repo_id=self.llm_model_type, model_kwargs={'temperature': \n 0.1, 'max_length': max_length})\n", (2177, 2272), False, 'from langchain_community.llms.huggingface_hub import HuggingFaceHub\n'), ((2495, 2523), 'loguru.logger.info', 'logger.info', (['"""Use Local LLM"""'], {}), "('Use Local LLM')\n", (2506, 2523), False, 'from loguru import logger\n'), ((2536, 2584), 'loguru.logger.info', 'logger.info', (["('Retrieving ' + self.llm_model_type)"], {}), "('Retrieving ' + self.llm_model_type)\n", (2547, 2584), False, 'from loguru import logger\n'), ((3206, 3253), 'loguru.logger.info', 'logger.info', (["('Retrieved ' + self.llm_model_type)"], {}), "('Retrieved ' + self.llm_model_type)\n", (3217, 3253), False, 'from loguru import logger\n'), ((2692, 2748), 'loguru.logger.info', 'logger.info', (["('Using local api url ' + self.local_api_url)"], {}), "('Using local api url ' + self.local_api_url)\n", (2703, 2748), False, 'from loguru import logger\n'), ((3356, 3391), 'loguru.logger.info', 'logger.info', (['"""Use Azure OpenAI LLM"""'], {}), "('Use Azure OpenAI LLM')\n", (3367, 3391), False, 'from loguru import logger\n'), ((3404, 3452), 'loguru.logger.info', 'logger.info', (["('Retrieving ' + self.llm_model_type)"], {}), "('Retrieving ' + self.llm_model_type)\n", (3415, 3452), False, 'from loguru import logger\n'), ((3476, 3611), 'langchain_openai.AzureChatOpenAI', 'AzureChatOpenAI', ([], {'azure_deployment': 'self.llm_model_type', 'azure_endpoint': 'self.local_api_url', 'api_version': 'self.azureopenai_api_version'}), '(azure_deployment=self.llm_model_type, azure_endpoint=self.\n local_api_url, api_version=self.azureopenai_api_version)\n', (3491, 3611), False, 'from langchain_openai import ChatOpenAI, AzureChatOpenAI\n'), ((3682, 3729), 'loguru.logger.info', 'logger.info', (["('Retrieved ' + self.llm_model_type)"], {}), "('Retrieved ' + self.llm_model_type)\n", (3693, 3729), False, 'from loguru import logger\n'), ((2934, 2966), 'langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler', 'StreamingStdOutCallbackHandler', ([], {}), '()\n', (2964, 2966), False, 'from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n'), ((3141, 3173), 'langchain.callbacks.streaming_stdout.StreamingStdOutCallbackHandler', 'StreamingStdOutCallbackHandler', ([], {}), '()\n', (3171, 3173), False, 'from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n')] |
from typing import List
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain_core.documents import Document
from dotenv import load_dotenv
from themind.llm.func_instraction import instruct
from pydantic import BaseModel
import csv
from themind.vectorstores.chunking.question_answer_strategy import QuestionChunkingStrategy
from themind.vectorstores.chunking.chunking_strategy import ChunkingStrategy
class VectorStore(object):
def __init__(self, local_storage_dir: str = "./"):
self.vectorstore = Chroma(collection_name="all-data", persist_directory=local_storage_dir, embedding_function=OpenAIEmbeddings())
def ingest(self, uid: str, data: List[str], chunking_strategy: ChunkingStrategy = QuestionChunkingStrategy):
# Question & Answear strategy
# for each chunk, crete a list a question and answear from the text, similar how embeddings are being trained!
for chunk in data:
print('Chunk: ' + chunk)
docs = chunking_strategy.chunk(uid, chunk)
if len(docs) == 0:
print('No documents were created for this chunk')
continue
# append metadata to its document
for doc in docs:
doc.metadata['uid'] = uid
# doc.metadata['location'] = location
# doc.metadata['created_at'] = created_at
self.vectorstore.add_documents(docs)
print('Added chunk to vectorstore')
def query(self, uid: str, query: str):
output = self.vectorstore.similarity_search(query=query, k=10, filters={"uid": uid})
print(output)
@instruct
def answer(query: str, texts: List[str]) -> str:
"""
This was a query user made: {query}
This is a context we have: {texts}
Reply:
"""
return answer(query, [o.page_content for o in output])
if __name__ == '__main__':
uid = 'test'
# Process the CSV data
csv_path = "/Users/zvada/Documents/TheMind/themind-memory/data/alex-rivera-ground-truth.csv"
with open(csv_path, 'r') as file:
sentences = file.read().splitlines()
vec = VectorStore()
vec.ingest(uid, sentences)
# output = vec.query(uid, "what should i give laura for christmas?")
output = vec.query(uid, "what is alex's favorite food?")
print(output)
| [
"langchain.embeddings.OpenAIEmbeddings"
] | [((657, 675), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (673, 675), False, 'from langchain.embeddings import OpenAIEmbeddings\n')] |
import re
import time
import copy
import random
import numpy as np
import multiprocessing
import matplotlib.pyplot as plt
import modules.prompts as prompts
from langchain import PromptTemplate
from shapely.ops import substring
from shapely.geometry import Polygon, box, Point, LineString
class WallObjectGenerator():
def __init__(self, llm, object_retriever):
self.json_template = {"assetId": None, "id": None, "kinematic": True,
"position": {}, "rotation": {}, "material": None, "roomId": None}
self.llm = llm
self.object_retriever = object_retriever
self.database = object_retriever.database
self.constraint_prompt_template = PromptTemplate(input_variables=["room_type", "wall_height", "floor_objects", "wall_objects"],
template=prompts.wall_object_constraints_prompt)
self.grid_size = 25
self.default_height = 150
self.constraint_type = "llm"
def generate_wall_objects(self, scene, use_constraint=True):
doors = scene["doors"]
windows = scene["windows"]
open_walls = scene["open_walls"]
wall_height = scene["wall_height"]
wall_objects = []
selected_objects = scene["selected_objects"]
packed_args = [(room, scene, doors, windows, open_walls, wall_height, selected_objects, use_constraint) for room in scene["rooms"]]
pool = multiprocessing.Pool(processes=4)
all_placements = pool.map(self.generate_wall_objects_per_room, packed_args)
pool.close()
pool.join()
for placements in all_placements:
wall_objects += placements
return wall_objects
def generate_wall_objects_per_room(self, args):
room, scene, doors, windows, open_walls, wall_height, selected_objects, use_constraint = args
selected_wall_objects = selected_objects[room["roomType"]]["wall"]
selected_wall_objects = self.order_objects_by_size(selected_wall_objects)
wall_object_name2id = {object_name: asset_id for object_name, asset_id in selected_wall_objects}
room_id = room["id"]
room_type = room["roomType"]
wall_object_names = list(wall_object_name2id.keys())
floor_object_name2id = {object["object_name"]: object["assetId"] for object in scene["floor_objects"] if object["roomId"] == room["id"]}
floor_object_names = list(floor_object_name2id.keys())
# get constraints
constraints_prompt = self.constraint_prompt_template.format(room_type=room_type,
wall_height=int(wall_height*100),
floor_objects=", ".join(floor_object_names),
wall_objects=", ".join(wall_object_names))
if self.constraint_type == "llm" and use_constraint:
constraint_plan = self.llm(constraints_prompt)
else:
constraint_plan = ""
for object_name in wall_object_names:
random_height = random.randint(0, int(wall_height*100))
constraint_plan += f"{object_name} | N/A | {random_height} \n"
print(f"\nwall object constraint plan for {room_type}:\n{constraint_plan}")
constraints = self.parse_wall_object_constraints(constraint_plan, wall_object_names, floor_object_names)
# get wall objects
wall_object2dimension = {object_name: self.database[object_id]['assetMetadata']['boundingBox'] for object_name, object_id in wall_object_name2id.items()}
wall_objects_list = [(object_name, (wall_object2dimension[object_name]['x'] * 100, wall_object2dimension[object_name]['y'] * 100, wall_object2dimension[object_name]['z'] * 100)) for object_name in constraints]
# update constraints with max height
wall_object2max_height = {object_name: min(scene["wall_height"] * 100 - wall_object2dimension[object_name]["y"] * 100 - 20, constraints[object_name]["height"]) for object_name in constraints}
for object_name in constraints:
constraints[object_name]["height"] = max(wall_object2max_height[object_name], 0) # avoid negative height
# get initial state
room_vertices = [(x * 100, y * 100) for (x, y) in room["vertices"]]
room_poly = Polygon(room_vertices)
initial_state = self.get_initial_state(scene, doors, windows, room_vertices, open_walls)
# solve
room_x, room_z = self.get_room_size(room)
grid_size = max(room_x // 20, room_z // 20)
solver = DFS_Solver_Wall(grid_size=grid_size, max_duration=5, constraint_bouns=100)
solutions = solver.get_solution(room_poly, wall_objects_list, constraints, initial_state)
placements = self.solution2placement(solutions, wall_object_name2id, room_id)
return placements
def parse_wall_object_constraints(self, constraint_text, wall_object_names, floor_object_names):
object2constraints = {}
lines = [line.lower() for line in constraint_text.split('\n') if "|" in line]
for line in lines:
# remove index
pattern = re.compile(r'^\d+\.\s*')
line = pattern.sub('', line)
if line[-1] == ".": line = line[:-1] # remove the last period
try:
object_name, location, height = line.split("|")
object_name = object_name.replace("*", "").strip()
location = location.strip()
height = height.strip()
except:
print(f"Warning: cannot parse {line}.")
continue
if object_name not in wall_object_names: continue
try: target_floor_object_name = location.split(", ")[-1]
except: print(f"Warning: cannot parse {location}."); target_floor_object_name = None
try: height = int(height)
except: height = self.default_height
if target_floor_object_name in floor_object_names:
object2constraints[object_name] = {"target_floor_object_name": target_floor_object_name, "height": height}
else:
object2constraints[object_name] = {"target_floor_object_name": None, "height": height}
return object2constraints
def get_room_size(self, room):
floor_polygon = room["floorPolygon"]
x_values = [point['x'] for point in floor_polygon]
z_values = [point['z'] for point in floor_polygon]
return (int(max(x_values) - min(x_values)) * 100, int(max(z_values) - min(z_values)) * 100)
def check_wall_object_size(self, room_size, object_size):
if object_size["x"] * 100 > max(room_size) * 0.5:
print(f"Warning: object size {object_size} is too large for room size {room_size}.")
return False
else:
return True
def get_initial_state(self, scene, doors, windows, room_vertices, open_walls):
room_poly = Polygon(room_vertices)
initial_state = {}
i = 0
for door in doors:
door_boxes = door["doorBoxes"]
for door_box in door_boxes:
door_vertices = [(x * 100, z * 100) for (x, z) in door_box]
door_poly = Polygon(door_vertices)
door_center = door_poly.centroid
if room_poly.contains(door_center):
door_height = door["assetPosition"]["y"] * 100 * 2
x_min, z_min, x_max, z_max = door_poly.bounds
initial_state[f"door-{i}"] = ((x_min, 0, z_min), (x_max, door_height, z_max), 0, door_vertices, 1)
i += 1
for window in windows:
window_boxes = window["windowBoxes"]
for window_box in window_boxes:
window_vertices = [(x * 100, z * 100) for (x, z) in window_box]
window_poly = Polygon(window_vertices)
window_center = window_poly.centroid
if room_poly.contains(window_center):
y_min = window["holePolygon"][0]["y"] * 100
y_max = window["holePolygon"][1]["y"] * 100
x_min, z_min, x_max, z_max = window_poly.bounds
initial_state[f"window-{i}"] = ((x_min, y_min, z_min), (x_max, y_max, z_max), 0, window_vertices, 1)
i += 1
if len(open_walls) != 0:
open_wall_boxes = open_walls["openWallBoxes"]
for open_wall_box in open_wall_boxes:
open_wall_vertices = [(x * 100, z * 100) for (x, z) in open_wall_box]
open_wall_poly = Polygon(open_wall_vertices)
open_wall_center = open_wall_poly.centroid
if room_poly.contains(open_wall_center):
x_min, z_min, x_max, z_max = open_wall_poly.bounds
initial_state[f"open-{i}"] = ((x_min, 0, z_min), (x_max, scene["wall_height"] * 100, z_max), 0, open_wall_vertices, 1)
i += 1
for object in scene["floor_objects"]:
try: object_vertices = object["vertices"]
except: continue
object_poly = Polygon(object_vertices)
object_center = object_poly.centroid
if room_poly.contains(object_center):
object_height = object["position"]["y"] * 100 * 2 # the height should be twice the value of the y coordinate
x_min, z_min, x_max, z_max = object_poly.bounds
initial_state[object["object_name"]] = ((x_min, 0, z_min), (x_max, object_height, z_max), object["rotation"]["y"], object_vertices, 1)
return initial_state
def solution2placement(self, solutions, wall_object_name2id, room_id):
placements = []
for object_name, solution in solutions.items():
if object_name not in wall_object_name2id: continue
placement = self.json_template.copy()
placement["assetId"] = wall_object_name2id[object_name]
placement["id"] = f"{object_name} ({room_id})"
position_x = (solution[0][0] + solution[1][0]) / 200
position_y = (solution[0][1] + solution[1][1]) / 200
position_z = (solution[0][2] + solution[1][2]) / 200
placement["position"] = {"x": position_x, "y": position_y, "z": position_z}
placement["rotation"] = {"x": 0, "y": solution[2], "z": 0}
# move the object a little bit to avoid collision
if placement["rotation"]["y"] == 0: placement["position"]["z"] += 0.01
elif placement["rotation"]["y"] == 90: placement["position"]["x"] += 0.01
elif placement["rotation"]["y"]== 180: placement["position"]["z"] -= 0.01
elif placement["rotation"]["y"] == 270: placement["position"]["x"] -= 0.01
placement["roomId"] = room_id
placement["vertices"] = list(solution[3])
placement["object_name"] = object_name
placements.append(placement)
return placements
def order_objects_by_size(self, selected_wall_objects):
ordered_wall_objects = []
for object_name, asset_id in selected_wall_objects:
dimensions = self.database[asset_id]['assetMetadata']['boundingBox']
size = dimensions["x"]
ordered_wall_objects.append([object_name, asset_id, size])
ordered_wall_objects.sort(key=lambda x: x[2], reverse=True)
ordered_wall_objects_no_size = [[object_name, asset_id] for object_name, asset_id, size in ordered_wall_objects]
return ordered_wall_objects_no_size
class SolutionFound(Exception):
def __init__(self, solution):
self.solution = solution
pass
class DFS_Solver_Wall():
def __init__(self, grid_size, random_seed=0, max_duration=5, constraint_bouns=100):
self.grid_size = grid_size
self.random_seed = random_seed
self.max_duration = max_duration # maximum allowed time in seconds
self.constraint_bouns = constraint_bouns
self.start_time = None
self.solutions = []
self.visualize = False
def get_solution(self, room_poly, wall_objects_list, constraints, initial_state):
grid_points = self.create_grids(room_poly)
self.start_time = time.time()
try:
self.dfs(room_poly, wall_objects_list, constraints, grid_points, initial_state)
except SolutionFound as e:
print(f"Time taken: {time.time() - self.start_time}")
max_solution = self.get_max_solution(self.solutions)
if self.visualize: self.visualize_grid(room_poly, grid_points, max_solution)
return max_solution
def get_max_solution(self, solutions):
path_weights = []
for solution in solutions:
path_weights.append(sum([obj[-1] for obj in solution.values()]))
max_index = np.argmax(path_weights)
return solutions[max_index]
def dfs(self, room_poly, wall_objects_list, constraints, grid_points, placed_objects):
if len(wall_objects_list) == 0:
self.solutions.append(placed_objects)
return placed_objects
if time.time() - self.start_time > self.max_duration:
print(f"Time limit reached.")
raise SolutionFound(self.solutions)
object_name, object_dim = wall_objects_list[0]
placements = self.get_possible_placements(room_poly, object_dim, constraints[object_name], grid_points, placed_objects)
if len(placements) == 0:
self.solutions.append(placed_objects)
paths = []
for placement in placements:
placed_objects_updated = copy.deepcopy(placed_objects)
placed_objects_updated[object_name] = placement
sub_paths = self.dfs(room_poly, wall_objects_list[1:], constraints, grid_points, placed_objects_updated)
paths.extend(sub_paths)
return paths
def get_possible_placements(self, room_poly, object_dim, constraint, grid_points, placed_objects):
all_solutions = self.filter_collision(placed_objects, self.get_all_solutions(room_poly, grid_points, object_dim, constraint["height"]))
random.shuffle(all_solutions)
target_floor_object_name = constraint["target_floor_object_name"]
if target_floor_object_name is not None and target_floor_object_name in placed_objects:
all_solutions = self.score_solution_by_distance(all_solutions, placed_objects[target_floor_object_name])
# order solutions by distance to target floor object
all_solutions = sorted(all_solutions, key=lambda x: x[-1], reverse=True)
return all_solutions
def create_grids(self, room_poly):
# Get the coordinates of the polygon
poly_coords = list(room_poly.exterior.coords)
grid_points = []
# Iterate over each pair of points (edges of the polygon)
for i in range(len(poly_coords) - 1):
line = LineString([poly_coords[i], poly_coords[i + 1]])
line_length = line.length
# Create points along the edge at intervals of grid size
for j in range(0, int(line_length), self.grid_size):
point_on_line = substring(line, j, j) # Get a point at distance j from the start of the line
if point_on_line:
grid_points.append((point_on_line.x, point_on_line.y))
return grid_points
def get_all_solutions(self, room_poly, grid_points, object_dim, height):
obj_length, obj_height, obj_width = object_dim
obj_half_length = obj_length / 2
rotation_adjustments = {
0: ((-obj_half_length, 0), (obj_half_length, obj_width)),
90: ((0, -obj_half_length), (obj_width, obj_half_length)),
180: ((-obj_half_length, -obj_width), (obj_half_length, 0)),
270: ((-obj_width, -obj_half_length), (0, obj_half_length))
}
solutions = []
for rotation in [0, 90, 180, 270]:
for point in grid_points:
center_x, center_y = point
lower_left_adjustment, upper_right_adjustment = rotation_adjustments[rotation]
lower_left = (center_x + lower_left_adjustment[0], center_y + lower_left_adjustment[1])
upper_right = (center_x + upper_right_adjustment[0], center_y + upper_right_adjustment[1])
obj_box = box(*lower_left, *upper_right)
if room_poly.contains(obj_box):
object_coords = obj_box.exterior.coords[:]
coordinates_on_edge = [coord for coord in object_coords if room_poly.boundary.contains(Point(coord))]
coordinates_on_edge = list(set(coordinates_on_edge))
if len(coordinates_on_edge) >= 2:
vertex_min = (lower_left[0], height, lower_left[1])
vertex_max = (upper_right[0], height + obj_height, upper_right[1])
solutions.append([vertex_min, vertex_max, rotation, tuple(obj_box.exterior.coords[:]), 1])
return solutions
def filter_collision(self, placed_objects, solutions):
def intersect_3d(box1, box2):
# box1 and box2 are dictionaries with 'min' and 'max' keys,
# which are tuples representing the minimum and maximum corners of the 3D box.
for i in range(3):
if box1['max'][i] < box2['min'][i] or box1['min'][i] > box2['max'][i]:
return False
return True
valid_solutions = []
boxes = [{"min": vertex_min, "max": vertex_max} for vertex_min, vertex_max, rotation, box_coords, path_weight in placed_objects.values()]
for solution in solutions:
for box in boxes:
if intersect_3d(box, {"min": solution[0], "max": solution[1]}):
break
else:
valid_solutions.append(solution)
return valid_solutions
def score_solution_by_distance(self, solutions, target_object):
distances = []
scored_solutions = []
for solution in solutions:
center_x, center_y, center_z = (solution[0][0]+solution[1][0])/2, (solution[0][1]+solution[1][1])/2, (solution[0][2]+solution[1][2])/2
target_x, target_y, target_z = (target_object[0][0]+target_object[1][0])/2, (target_object[0][1]+target_object[1][1])/2, (target_object[0][2]+target_object[1][2])/2
distance = np.sqrt((center_x - target_x)**2 + (center_y - target_y)**2 + (center_z - target_z)**2)
distances.append(distance)
scored_solution = solution.copy()
scored_solution[-1] = solution[-1] + self.constraint_bouns * (1/distance)
scored_solutions.append(scored_solution)
return scored_solutions
def visualize_grid(self, room_poly, grid_points, solutions):
# create a new figure
fig, ax = plt.subplots()
# draw the room
x, y = room_poly.exterior.xy
ax.plot(x, y, 'b-', label='Room')
# draw the grid points
grid_x = [point[0] for point in grid_points]
grid_y = [point[1] for point in grid_points]
ax.plot(grid_x, grid_y, 'ro', markersize=2)
# draw the solutions
for object_name, solution in solutions.items():
vertex_min, vertex_max, rotation, box_coords = solution[:-1]
center_x, center_y = (vertex_min[0]+vertex_max[0])/2, (vertex_min[2]+vertex_max[2])/2
# create a polygon for the solution
obj_poly = Polygon(box_coords)
x, y = obj_poly.exterior.xy
ax.plot(x, y, 'g-', linewidth=2)
ax.text(center_x, center_y, object_name, fontsize=12, ha='center')
# set arrow direction based on rotation
if rotation == 0:
ax.arrow(center_x, center_y, 0, 25, head_width=10, fc='g')
elif rotation == 90:
ax.arrow(center_x, center_y, 25, 0, head_width=10, fc='g')
elif rotation == 180:
ax.arrow(center_x, center_y, 0, -25, head_width=10, fc='g')
elif rotation == 270:
ax.arrow(center_x, center_y, -25, 0, head_width=10, fc='g')
ax.set_aspect('equal', 'box') # to keep the ratios equal along x and y axis
plt.show() | [
"langchain.PromptTemplate"
] | [((704, 850), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['room_type', 'wall_height', 'floor_objects', 'wall_objects']", 'template': 'prompts.wall_object_constraints_prompt'}), "(input_variables=['room_type', 'wall_height', 'floor_objects',\n 'wall_objects'], template=prompts.wall_object_constraints_prompt)\n", (718, 850), False, 'from langchain import PromptTemplate\n'), ((1447, 1480), 'multiprocessing.Pool', 'multiprocessing.Pool', ([], {'processes': '(4)'}), '(processes=4)\n', (1467, 1480), False, 'import multiprocessing\n'), ((4462, 4484), 'shapely.geometry.Polygon', 'Polygon', (['room_vertices'], {}), '(room_vertices)\n', (4469, 4484), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((7172, 7194), 'shapely.geometry.Polygon', 'Polygon', (['room_vertices'], {}), '(room_vertices)\n', (7179, 7194), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((12562, 12573), 'time.time', 'time.time', ([], {}), '()\n', (12571, 12573), False, 'import time\n'), ((13175, 13198), 'numpy.argmax', 'np.argmax', (['path_weights'], {}), '(path_weights)\n', (13184, 13198), True, 'import numpy as np\n'), ((14518, 14547), 'random.shuffle', 'random.shuffle', (['all_solutions'], {}), '(all_solutions)\n', (14532, 14547), False, 'import random\n'), ((19373, 19387), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (19385, 19387), True, 'import matplotlib.pyplot as plt\n'), ((20776, 20786), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (20784, 20786), True, 'import matplotlib.pyplot as plt\n'), ((5311, 5337), 're.compile', 're.compile', (['"""^\\\\d+\\\\.\\\\s*"""'], {}), "('^\\\\d+\\\\.\\\\s*')\n", (5321, 5337), False, 'import re\n'), ((9403, 9427), 'shapely.geometry.Polygon', 'Polygon', (['object_vertices'], {}), '(object_vertices)\n', (9410, 9427), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((13991, 14020), 'copy.deepcopy', 'copy.deepcopy', (['placed_objects'], {}), '(placed_objects)\n', (14004, 14020), False, 'import copy\n'), ((15311, 15359), 'shapely.geometry.LineString', 'LineString', (['[poly_coords[i], poly_coords[i + 1]]'], {}), '([poly_coords[i], poly_coords[i + 1]])\n', (15321, 15359), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((18902, 18999), 'numpy.sqrt', 'np.sqrt', (['((center_x - target_x) ** 2 + (center_y - target_y) ** 2 + (center_z -\n target_z) ** 2)'], {}), '((center_x - target_x) ** 2 + (center_y - target_y) ** 2 + (center_z -\n target_z) ** 2)\n', (18909, 18999), True, 'import numpy as np\n'), ((20011, 20030), 'shapely.geometry.Polygon', 'Polygon', (['box_coords'], {}), '(box_coords)\n', (20018, 20030), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((7450, 7472), 'shapely.geometry.Polygon', 'Polygon', (['door_vertices'], {}), '(door_vertices)\n', (7457, 7472), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((8100, 8124), 'shapely.geometry.Polygon', 'Polygon', (['window_vertices'], {}), '(window_vertices)\n', (8107, 8124), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((8845, 8872), 'shapely.geometry.Polygon', 'Polygon', (['open_wall_vertices'], {}), '(open_wall_vertices)\n', (8852, 8872), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((13472, 13483), 'time.time', 'time.time', ([], {}), '()\n', (13481, 13483), False, 'import time\n'), ((15565, 15586), 'shapely.ops.substring', 'substring', (['line', 'j', 'j'], {}), '(line, j, j)\n', (15574, 15586), False, 'from shapely.ops import substring\n'), ((16776, 16806), 'shapely.geometry.box', 'box', (['*lower_left', '*upper_right'], {}), '(*lower_left, *upper_right)\n', (16779, 16806), False, 'from shapely.geometry import Polygon, box, Point, LineString\n'), ((12747, 12758), 'time.time', 'time.time', ([], {}), '()\n', (12756, 12758), False, 'import time\n'), ((17026, 17038), 'shapely.geometry.Point', 'Point', (['coord'], {}), '(coord)\n', (17031, 17038), False, 'from shapely.geometry import Polygon, box, Point, LineString\n')] |
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain.prompts import PromptTemplate
from langchain.prompts.chat import ChatPromptTemplate
from config.config import OPENAI_API_KEY
from game.poker import PokerGameManager
from db.db_utils import DatabaseManager
import json
class GPTPlayer:
def __init__(self, db: DatabaseManager, model_name="gpt-3.5-turbo"):
self.db = db
llm = ChatOpenAI(model_name=model_name)
output_parser = StrOutputParser()
template = '''
Imagine you're a poker bot in a heads-up Texas Hold'em game. Your play is optimal,
mixing strategic bluffs and strong hands. You raise on strength, going All-in only with the best hands.
Folding against a superior opponent hand, you call and check when fitting. Remember, only "call" the ALL-IN if your hand is better.
Please reply in the following JSON format: {{your_hand": "what is the current hand you are playing",
"opponents_hand": "what do you think your opponent has based on how he has played", "thought_process": "what is your thought process",
"action": "your action", "raise_amount": your raise amount if applicable}}
Note: If the action you chose doesn't involve a raise, please do not include the "raise_amount" key in your JSON response.
'''
prompt = ChatPromptTemplate.from_messages([
("system", template),
("user", "{input}")
])
self.chain = prompt | llm | output_parser
def _extract_action(self, json_string, pokerGame: PokerGameManager):
min_raise, max_raise = pokerGame.return_min_max_raise(1)
try:
json_data = json.loads(json_string)
action = json_data['action'].capitalize()
raise_amount = 0
if action == "Raise":
raise_amount = json_data['raise_amount']
raise_amount = int(raise_amount)
if raise_amount < min_raise:
raise_amount = min_raise
elif raise_amount > max_raise:
action = "All-in"
raise_amount = pokerGame.return_player_stack(1)
self.db.record_gpt_action(action, raise_amount, json_string)
return (action, raise_amount)
except Exception as erro:
return ("Default", 0)
def pre_flop_small_blind(self, pokerGame: PokerGameManager):
# return Call, Raise, Fold or All-in
inputs = {
'small_blind': pokerGame.small_blind,
'big_blind': pokerGame.big_blind,
'stack': pokerGame.return_player_stack(1),
'opponents_stack': pokerGame.return_player_stack(0),
'hand': pokerGame.players[1].return_long_hand(),
'pot': pokerGame.current_pot,
'amount_to_call': pokerGame.big_blind - pokerGame.small_blind
}
human_template = '''
The small blind is {small_blind} chips and the big blind is {big_blind} chips.
You have {stack} chips in your stack and your opponent has {opponents_stack} chips.
Your hand is {hand}. The pot is {pot} chips.
You are the small blind and it's your turn.
It costs {amount_to_call} chips to call.
What action would you take? (Call, Raise, All-in, or Fold)
'''
formatted_text = human_template.format(**inputs)
response = self.chain.invoke({'input': formatted_text})
return self._extract_action(response, pokerGame)
def pre_flop_big_blind(self, pokerGame: PokerGameManager):
# return Check, Raise, or All-in
inputs = {
'small_blind': pokerGame.small_blind,
'big_blind': pokerGame.big_blind,
'stack': pokerGame.return_player_stack(1),
'opponents_stack': pokerGame.return_player_stack(0),
'hand': pokerGame.players[1].return_long_hand(),
'pot': pokerGame.current_pot,
'amount_to_call': pokerGame.big_blind - pokerGame.small_blind
}
human_template = '''
The small blind is {small_blind} chips and the big blind is {big_blind} chips.
You have {stack} chips in your stack and your opponent has {opponents_stack} chips.
Your hand is {hand}. The pot is {pot} chips.
You are the small blind and it's your turn.
It costs {amount_to_call} chips to call.
What action would you take? (Check, Raise, or All-in)
'''
formatted_text = human_template.format(**inputs)
response = self.chain.invoke({'input': formatted_text})
return self._extract_action(response, pokerGame)
def first_to_act(self, pokerGame: PokerGameManager):
# return Check, Raise, or All-in
inputs = {
'small_blind': pokerGame.small_blind,
'big_blind': pokerGame.big_blind,
'stack': pokerGame.return_player_stack(1),
'opponents_stack': pokerGame.return_player_stack(0),
'hand': pokerGame.players[1].return_long_hand(),
'pot': pokerGame.current_pot,
'round': pokerGame.round,
'community_cards': pokerGame.return_community_cards()
}
human_template = '''
The small blind is {small_blind} chips and the big blind is {big_blind} chips.
You have {stack} chips in your stack and your opponent has {opponents_stack} chips.
Your hand is {hand}. The pot is {pot} chips.
It's the {round} round and you're first to act. The community cards are {community_cards}.
What action would you take? (Check, Raise, or All-in)
'''
formatted_text = human_template.format(**inputs)
response = self.chain.invoke({'input': formatted_text})
return self._extract_action(response, pokerGame)
def player_check(self, pokerGame: PokerGameManager):
# return Check, Raise, or All-in
inputs = {
'small_blind': pokerGame.small_blind,
'big_blind': pokerGame.big_blind,
'stack': pokerGame.return_player_stack(1),
'opponents_stack': pokerGame.return_player_stack(0),
'hand': pokerGame.players[1].return_long_hand(),
'pot': pokerGame.current_pot,
'round': pokerGame.round,
'community_cards': pokerGame.return_community_cards()
}
human_template = """
The small blind is {small_blind} chips and the big blind is {big_blind} chips.
You have {stack} chips in your stack and your opponent has {opponents_stack} chips.
Your hand is {hand}. The pot is {pot} chips.
It is the {round} round and the action checks to you. The community cards are {community_cards}.
Based on this information, what action would you like to take? (Check, Raise, or All-in).
"""
formatted_text = human_template.format(**inputs)
response = self.chain.invoke({'input': formatted_text})
return self._extract_action(response, pokerGame)
def player_raise(self, pokerGame: PokerGameManager):
# return Call, Raise, All-in, or Fold
inputs = {
'small_blind': pokerGame.small_blind,
'big_blind': pokerGame.big_blind,
'stack': pokerGame.return_player_stack(1),
'opponents_stack': pokerGame.return_player_stack(0),
'hand': pokerGame.players[1].return_long_hand(),
'pot': pokerGame.current_pot,
'round': pokerGame.round,
'community_cards': pokerGame.return_community_cards(),
'opponent_raise': pokerGame.current_bet,
'amount_to_call': pokerGame.current_bet - pokerGame.players[1].round_pot_commitment
}
human_template = '''
The small blind is {small_blind} chips and the big blind is {big_blind} chips.
You have {stack} chips in your stack and your opponent has {opponents_stack} chips.
Your hand is {hand}. The pot is {pot} chips.
It's the {round} round. The community cards are {community_cards}.
Your opponent has raised to {opponent_raise} chips.
It costs {amount_to_call} chips to call.
What action would you take? (Call, Raise, All-in, or Fold)
'''
formatted_text = human_template.format(**inputs)
response = self.chain.invoke({'input': formatted_text})
return self._extract_action(response, pokerGame)
def player_all_in(self, pokerGame: PokerGameManager):
# return Call, or Fold
amount_to_call = pokerGame.current_bet - pokerGame.players[1].round_pot_commitment
if amount_to_call > pokerGame.return_player_stack(1):
amount_to_call = pokerGame.return_player_stack(1)
inputs = {
'small_blind': pokerGame.small_blind,
'big_blind': pokerGame.big_blind,
'stack': pokerGame.return_player_stack(1),
'hand': pokerGame.players[1].return_long_hand(),
'pot': pokerGame.current_pot,
'round': pokerGame.round,
'community_cards': pokerGame.return_community_cards(),
'opponent_raise': pokerGame.current_bet,
'amount_to_call': amount_to_call
}
human_template = '''
The small blind is {small_blind} chips and the big blind is {big_blind} chips.
You have {stack} chips in your stack.
Your hand is {hand}. The pot is {pot} chips.
It's the {round} round. The community cards are {community_cards}.
Your opponent has gone all in for {opponent_raise} chips.
It costs {amount_to_call} chips to call.
What action would you take? (Call, or Fold)
'''
formatted_text = human_template.format(**inputs)
response = self.chain.invoke({'input': formatted_text})
return self._extract_action(response, pokerGame)
| [
"langchain_openai.ChatOpenAI",
"langchain_core.output_parsers.StrOutputParser",
"langchain.prompts.chat.ChatPromptTemplate.from_messages"
] | [((456, 489), 'langchain_openai.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': 'model_name'}), '(model_name=model_name)\n', (466, 489), False, 'from langchain_openai import ChatOpenAI\n'), ((514, 531), 'langchain_core.output_parsers.StrOutputParser', 'StrOutputParser', ([], {}), '()\n', (529, 531), False, 'from langchain_core.output_parsers import StrOutputParser\n'), ((1408, 1485), 'langchain.prompts.chat.ChatPromptTemplate.from_messages', 'ChatPromptTemplate.from_messages', (["[('system', template), ('user', '{input}')]"], {}), "([('system', template), ('user', '{input}')])\n", (1440, 1485), False, 'from langchain.prompts.chat import ChatPromptTemplate\n'), ((1755, 1778), 'json.loads', 'json.loads', (['json_string'], {}), '(json_string)\n', (1765, 1778), False, 'import json\n')] |
import logging
from typing import Any, Dict, List, Optional
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.llms.base import LLM
from langchain.llms.utils import enforce_stop_tokens
from langchain.pydantic_v1 import Extra, root_validator
from langchain.schema import Generation, LLMResult
from langchain.utils import get_from_dict_or_env
logger = logging.getLogger(__name__)
class Clarifai(LLM):
"""Clarifai large language models.
To use, you should have an account on the Clarifai platform,
the ``clarifai`` python package installed, and the
environment variable ``CLARIFAI_PAT`` set with your PAT key,
or pass it as a named parameter to the constructor.
Example:
.. code-block:: python
from langchain.llms import Clarifai
clarifai_llm = Clarifai(pat=CLARIFAI_PAT, \
user_id=USER_ID, app_id=APP_ID, model_id=MODEL_ID)
"""
stub: Any #: :meta private:
userDataObject: Any
model_id: Optional[str] = None
"""Model id to use."""
model_version_id: Optional[str] = None
"""Model version id to use."""
app_id: Optional[str] = None
"""Clarifai application id to use."""
user_id: Optional[str] = None
"""Clarifai user id to use."""
pat: Optional[str] = None
api_base: str = "https://api.clarifai.com"
class Config:
"""Configuration for this pydantic object."""
extra = Extra.forbid
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that we have all required info to access Clarifai
platform and python package exists in environment."""
values["pat"] = get_from_dict_or_env(values, "pat", "CLARIFAI_PAT")
user_id = values.get("user_id")
app_id = values.get("app_id")
model_id = values.get("model_id")
if values["pat"] is None:
raise ValueError("Please provide a pat.")
if user_id is None:
raise ValueError("Please provide a user_id.")
if app_id is None:
raise ValueError("Please provide a app_id.")
if model_id is None:
raise ValueError("Please provide a model_id.")
try:
from clarifai.auth.helper import ClarifaiAuthHelper
from clarifai.client import create_stub
except ImportError:
raise ImportError(
"Could not import clarifai python package. "
"Please install it with `pip install clarifai`."
)
auth = ClarifaiAuthHelper(
user_id=user_id,
app_id=app_id,
pat=values["pat"],
base=values["api_base"],
)
values["userDataObject"] = auth.get_user_app_id_proto()
values["stub"] = create_stub(auth)
return values
@property
def _default_params(self) -> Dict[str, Any]:
"""Get the default parameters for calling Clarifai API."""
return {}
@property
def _identifying_params(self) -> Dict[str, Any]:
"""Get the identifying parameters."""
return {
**{
"user_id": self.user_id,
"app_id": self.app_id,
"model_id": self.model_id,
}
}
@property
def _llm_type(self) -> str:
"""Return type of llm."""
return "clarifai"
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Call out to Clarfai's PostModelOutputs endpoint.
Args:
prompt: The prompt to pass into the model.
stop: Optional list of stop words to use when generating.
Returns:
The string generated by the model.
Example:
.. code-block:: python
response = clarifai_llm("Tell me a joke.")
"""
try:
from clarifai_grpc.grpc.api import (
resources_pb2,
service_pb2,
)
from clarifai_grpc.grpc.api.status import status_code_pb2
except ImportError:
raise ImportError(
"Could not import clarifai python package. "
"Please install it with `pip install clarifai`."
)
# The userDataObject is created in the overview and
# is required when using a PAT
# If version_id None, Defaults to the latest model version
post_model_outputs_request = service_pb2.PostModelOutputsRequest(
user_app_id=self.userDataObject,
model_id=self.model_id,
version_id=self.model_version_id,
inputs=[
resources_pb2.Input(
data=resources_pb2.Data(text=resources_pb2.Text(raw=prompt))
)
],
)
post_model_outputs_response = self.stub.PostModelOutputs(
post_model_outputs_request
)
if post_model_outputs_response.status.code != status_code_pb2.SUCCESS:
logger.error(post_model_outputs_response.status)
first_model_failure = (
post_model_outputs_response.outputs[0].status
if len(post_model_outputs_response.outputs)
else None
)
raise Exception(
f"Post model outputs failed, status: "
f"{post_model_outputs_response.status}, first output failure: "
f"{first_model_failure}"
)
text = post_model_outputs_response.outputs[0].data.text.raw
# In order to make this consistent with other endpoints, we strip them.
if stop is not None:
text = enforce_stop_tokens(text, stop)
return text
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."""
try:
from clarifai_grpc.grpc.api import (
resources_pb2,
service_pb2,
)
from clarifai_grpc.grpc.api.status import status_code_pb2
except ImportError:
raise ImportError(
"Could not import clarifai python package. "
"Please install it with `pip install clarifai`."
)
# TODO: add caching here.
generations = []
batch_size = 32
for i in range(0, len(prompts), batch_size):
batch = prompts[i : i + batch_size]
post_model_outputs_request = service_pb2.PostModelOutputsRequest(
user_app_id=self.userDataObject,
model_id=self.model_id,
version_id=self.model_version_id,
inputs=[
resources_pb2.Input(
data=resources_pb2.Data(text=resources_pb2.Text(raw=prompt))
)
for prompt in batch
],
)
post_model_outputs_response = self.stub.PostModelOutputs(
post_model_outputs_request
)
if post_model_outputs_response.status.code != status_code_pb2.SUCCESS:
logger.error(post_model_outputs_response.status)
first_model_failure = (
post_model_outputs_response.outputs[0].status
if len(post_model_outputs_response.outputs)
else None
)
raise Exception(
f"Post model outputs failed, status: "
f"{post_model_outputs_response.status}, first output failure: "
f"{first_model_failure}"
)
for output in post_model_outputs_response.outputs:
if stop is not None:
text = enforce_stop_tokens(output.data.text.raw, stop)
else:
text = output.data.text.raw
generations.append([Generation(text=text)])
return LLMResult(generations=generations)
| [
"langchain.llms.utils.enforce_stop_tokens",
"langchain.utils.get_from_dict_or_env",
"langchain.schema.Generation",
"langchain.schema.LLMResult",
"langchain.pydantic_v1.root_validator"
] | [((381, 408), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (398, 408), False, 'import logging\n'), ((1472, 1488), 'langchain.pydantic_v1.root_validator', 'root_validator', ([], {}), '()\n', (1486, 1488), False, 'from langchain.pydantic_v1 import Extra, root_validator\n'), ((1702, 1753), 'langchain.utils.get_from_dict_or_env', 'get_from_dict_or_env', (['values', '"""pat"""', '"""CLARIFAI_PAT"""'], {}), "(values, 'pat', 'CLARIFAI_PAT')\n", (1722, 1753), False, 'from langchain.utils import get_from_dict_or_env\n'), ((2565, 2664), 'clarifai.auth.helper.ClarifaiAuthHelper', 'ClarifaiAuthHelper', ([], {'user_id': 'user_id', 'app_id': 'app_id', 'pat': "values['pat']", 'base': "values['api_base']"}), "(user_id=user_id, app_id=app_id, pat=values['pat'], base=\n values['api_base'])\n", (2583, 2664), False, 'from clarifai.auth.helper import ClarifaiAuthHelper\n'), ((2808, 2825), 'clarifai.client.create_stub', 'create_stub', (['auth'], {}), '(auth)\n', (2819, 2825), False, 'from clarifai.client import create_stub\n'), ((8240, 8274), 'langchain.schema.LLMResult', 'LLMResult', ([], {'generations': 'generations'}), '(generations=generations)\n', (8249, 8274), False, 'from langchain.schema import Generation, LLMResult\n'), ((5810, 5841), 'langchain.llms.utils.enforce_stop_tokens', 'enforce_stop_tokens', (['text', 'stop'], {}), '(text, stop)\n', (5829, 5841), False, 'from langchain.llms.utils import enforce_stop_tokens\n'), ((8045, 8092), 'langchain.llms.utils.enforce_stop_tokens', 'enforce_stop_tokens', (['output.data.text.raw', 'stop'], {}), '(output.data.text.raw, stop)\n', (8064, 8092), False, 'from langchain.llms.utils import enforce_stop_tokens\n'), ((8200, 8221), 'langchain.schema.Generation', 'Generation', ([], {'text': 'text'}), '(text=text)\n', (8210, 8221), False, 'from langchain.schema import Generation, LLMResult\n'), ((4864, 4894), 'clarifai_grpc.grpc.api.resources_pb2.Text', 'resources_pb2.Text', ([], {'raw': 'prompt'}), '(raw=prompt)\n', (4882, 4894), False, 'from clarifai_grpc.grpc.api import resources_pb2, service_pb2\n'), ((7057, 7087), 'clarifai_grpc.grpc.api.resources_pb2.Text', 'resources_pb2.Text', ([], {'raw': 'prompt'}), '(raw=prompt)\n', (7075, 7087), False, 'from clarifai_grpc.grpc.api import resources_pb2, service_pb2\n')] |
import re
from typing import Any, Dict, List, Optional
from langchain_core.load import loads, dumps
from langchain_community.chat_models import (
ChatAnthropic,
ChatAnyscale,
ChatBaichuan,
QianfanChatEndpoint,
BedrockChat,
ChatDatabricks,
ChatDeepInfra,
ErnieBotChat,
ChatEverlyAI,
FakeListChatModel,
ChatFireworks,
GigaChat,
ChatGooglePalm,
GPTRouter,
ChatHuggingFace,
HumanInputChatModel,
ChatHunyuan,
ChatJavelinAIGateway,
JinaChat,
ChatKonko,
ChatLiteLLM,
ChatLiteLLMRouter,
LlamaEdgeChatService,
MiniMaxChat,
ChatMlflow,
ChatMLflowAIGateway,
ChatOllama,
ChatOpenAI,
AzureChatOpenAI,
PaiEasChatEndpoint,
PromptLayerChatOpenAI,
ChatSparkLLM,
ChatVertexAI,
VolcEngineMaasChat,
ChatYandexGPT,
ChatZhipuAI,
)
from langchain_community.llms.anthropic import Anthropic
from langchain_community.llms.bedrock import Bedrock
from langchain_community.llms.openai import OpenAI
from langchain_community.llms.openai import AzureOpenAI
# NOTE ON DEPENDENCIES:
# - since Jan 2024, there is https://pypi.org/project/langchain-openai/ which is a separate package and imports openai models.
# Decided to not make this a dependency of langfuse as few people will have this. Need to match these models manually
# - langchain_community is loaded as a dependency of langchain, so we can use it here
def _extract_model_name(
serialized: Dict[str, Any],
**kwargs: Any,
):
"""
Extracts the model name from the serialized or kwargs object. This is used to get the model names for Langfuse.
"""
# we have to deal with ChatGoogleGenerativeAI and ChatMistralAI first, as
# if we run loads(dumps(serialized)) on it, it will throw in case of missing api keys
model = _extract_model_by_key(
"ChatGoogleGenerativeAI",
serialized,
serialized,
["kwargs", "model"],
)
if model:
return model
model = _extract_model_by_key(
"ChatMistralAI",
serialized,
serialized,
["kwargs", "model"],
)
if model:
return model
# checks if serializations is implemented. Otherwise, this will throw
if serialized.get("type") != "not_implemented":
try:
# try to deserialize the model name from the serialized object
# https://github.com/langchain-ai/langchain/blob/00a09e1b7117f3bde14a44748510fcccc95f9de5/libs/core/langchain_core/load/load.py#L112
llm = loads(dumps(serialized))
# openai models from langchain_openai, separate package, not installed with langchain
# community models from langchain_community, separate package, installed with langchain
if isinstance(llm, ChatAnthropic):
return llm.model
if isinstance(llm, Anthropic):
return llm.model
if isinstance(llm, ChatAnyscale):
return llm.model_name
# openai community models
if isinstance(llm, AzureChatOpenAI):
return llm.model_name
if isinstance(llm, ChatOpenAI):
return llm.model_name
if isinstance(llm, OpenAI):
return llm.model_name
if isinstance(llm, AzureOpenAI):
return (
kwargs.get("invocation_params").get("model")
+ "-"
+ llm.serialized["kwargs"]["model_version"]
)
if isinstance(llm, ChatBaichuan):
return llm.model
if isinstance(llm, QianfanChatEndpoint):
return llm.model
if isinstance(llm, BedrockChat):
return llm.model_id
if isinstance(llm, Bedrock):
return llm.model_id
if isinstance(llm, ChatDatabricks):
return llm.name
if isinstance(llm, ChatDeepInfra):
return llm.model_name
if isinstance(llm, ErnieBotChat):
return llm.model_name
if isinstance(llm, ChatEverlyAI):
return llm.model_name
if isinstance(llm, FakeListChatModel):
return None
if isinstance(llm, ChatFireworks):
return llm.model
if isinstance(llm, GigaChat):
return llm.model
if isinstance(llm, ChatGooglePalm):
return llm.model_name
if isinstance(llm, GPTRouter):
# taking the last model from the priority list
# https://python.langchain.com/docs/integrations/chat/gpt_router
return (
llm.models_priority_list[-1].name
if len(llm.models_priority_list) > 0
else None
)
if isinstance(llm, ChatHuggingFace):
return llm.model_id
if isinstance(llm, HumanInputChatModel):
return llm.name
if isinstance(llm, ChatHunyuan):
return llm.name
if isinstance(llm, ChatJavelinAIGateway):
return llm.name
if isinstance(llm, JinaChat):
return None
if isinstance(llm, ChatKonko):
return llm.model
if isinstance(llm, ChatLiteLLM):
return llm.model_name
if isinstance(llm, ChatLiteLLMRouter):
return llm.model_name
if isinstance(llm, LlamaEdgeChatService):
return llm.model
if isinstance(llm, MiniMaxChat):
return llm.model
if isinstance(llm, ChatMlflow):
return None
if isinstance(llm, ChatMLflowAIGateway):
return None
if isinstance(llm, ChatOllama):
return llm.model
if isinstance(llm, PaiEasChatEndpoint):
return None
if isinstance(llm, PromptLayerChatOpenAI):
return None
if isinstance(llm, ChatSparkLLM):
return None
if isinstance(llm, ChatVertexAI):
return llm.model_name
if isinstance(llm, VolcEngineMaasChat):
return llm.model
if isinstance(llm, ChatYandexGPT):
return llm.model_name
if isinstance(llm, ChatZhipuAI):
return llm.model
except Exception:
# using a try .. except block to catch exceptions if the model load above fails as some library is not installed for example
pass
# try to extract the model manually
model = _extract_model_by_key(
"ChatVertexAI",
serialized,
serialized,
["kwargs", "model_name"],
)
if model:
return model
# openai new langchain-openai package
model = _extract_model_by_key(
"OpenAI",
serialized,
kwargs,
["invocation_params", "model_name"],
)
if model:
return model
model = _extract_model_by_key(
"ChatOpenAI",
serialized,
kwargs,
["invocation_params", "model_name"],
)
if model:
return model
model = _extract_model_by_key(
"AzureChatOpenAI",
serialized,
kwargs,
["invocation_params", "model"],
)
if model:
return model
if serialized.get("id")[-1] == "AzureChatOpenAI":
if kwargs.get("invocation_params").get("model"):
return kwargs.get("invocation_params").get("model")
if serialized.get("id")[-1] == "AzureOpenAI":
if kwargs.get("invocation_params").get("model_name"):
return kwargs.get("invocation_params").get("model_name")
deployment_name = None
if serialized.get("kwargs").get("openai_api_version"):
deployment_name = serialized.get("kwargs").get("deployment_version")
deployment_version = None
if serialized.get("kwargs").get("deployment_name"):
deployment_name = serialized.get("kwargs").get("deployment_name")
return deployment_name + "-" + deployment_version
# anthropic
model = _extract_model_by_pattern("Anthropic", serialized, "model", "anthropic")
if model:
return model
# anthropic
model = _extract_model_by_pattern("ChatAnthropic", serialized, "model")
if model:
return model
# chatongyi
model = _extract_model_by_pattern("ChatTongyi", serialized, "model_name")
if model:
return model
# Cohere
model = _extract_model_by_pattern("ChatCohere", serialized, "model")
if model:
return model
model = _extract_model_by_pattern("Cohere", serialized, "model")
if model:
return model
# huggingface
model = _extract_model_by_pattern("HuggingFaceHub", serialized, "model")
if model:
return model
# anyscale
model = _extract_model_by_pattern("ChatAnyscale", serialized, "model_name")
if model:
return model
model = _extract_model_by_key(
"HuggingFacePipeline",
serialized,
kwargs,
["invocation_params", "model_id"],
)
if model:
return model
# textgen
model = _extract_model_by_pattern("TextGen", serialized, "model", "text-gen")
if model:
return model
return None
def _extract_model_with_regex(pattern: str, text: str):
match = re.search(rf"{pattern}='(.*?)'", text)
if match:
return match.group(1)
return None
def _extract_model_by_pattern(
id: str, serialized: dict, pattern: str, default: Optional[str] = None
):
if serialized.get("id")[-1] == id:
extracted = _extract_model_with_regex(pattern, serialized["repr"])
return extracted if extracted else default if default else None
def _extract_model_by_key(
id: str,
serialized: dict,
object: dict,
keys: List[str],
default: Optional[str] = None,
):
if serialized.get("id")[-1] == id:
current_obj = object
for key in keys:
current_obj = current_obj.get(key)
if not current_obj:
raise ValueError(f"Key {key} not found in {object}")
return current_obj if current_obj else default if default else None
| [
"langchain_core.load.dumps"
] | [((9560, 9597), 're.search', 're.search', (['f"""{pattern}=\'(.*?)\'"""', 'text'], {}), '(f"{pattern}=\'(.*?)\'", text)\n', (9569, 9597), False, 'import re\n'), ((2545, 2562), 'langchain_core.load.dumps', 'dumps', (['serialized'], {}), '(serialized)\n', (2550, 2562), False, 'from langchain_core.load import loads, dumps\n')] |
"""This example shows how to use the ChatGPT API
with LangChain to answer questions about Prefect."""
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter
from langchain.chains import ChatVectorDBChain
from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
)
from langchain_prefect.loaders import GitHubRepoLoader
from langchain_prefect.plugins import RecordLLMCalls
documents = GitHubRepoLoader("PrefectHQ/prefect", glob="**/*.md").load()
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
documents = text_splitter.split_documents(documents)
embeddings = OpenAIEmbeddings()
system_template = """Use the following pieces of context to answer the users question.
If you don't know the answer, just say that you don't know, don't make up an answer.
----------------
{context}"""
prompt = ChatPromptTemplate.from_messages(
[
SystemMessagePromptTemplate.from_template(system_template),
HumanMessagePromptTemplate.from_template("{question}"),
]
)
qa = ChatVectorDBChain.from_llm(
llm=ChatOpenAI(temperature=0),
vectorstore=Chroma.from_documents(documents, embeddings),
qa_prompt=prompt,
)
with RecordLLMCalls(
tags={qa.vectorstore.__class__.__name__}, max_prompt_tokens=int(1e4)
):
chat_history = []
query = "What infrastructures does Prefect support?"
result = qa({"question": query, "chat_history": chat_history})
print(result["answer"])
chat_history = [(query, result["answer"])]
query = "Can I use Prefect with AWS?"
result = qa({"question": query, "chat_history": chat_history})
print(result["answer"])
| [
"langchain.text_splitter.CharacterTextSplitter",
"langchain_prefect.loaders.GitHubRepoLoader",
"langchain.prompts.chat.SystemMessagePromptTemplate.from_template",
"langchain.chat_models.ChatOpenAI",
"langchain.vectorstores.Chroma.from_documents",
"langchain.prompts.chat.HumanMessagePromptTemplate.from_template",
"langchain.embeddings.openai.OpenAIEmbeddings"
] | [((680, 735), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(1000)', 'chunk_overlap': '(0)'}), '(chunk_size=1000, chunk_overlap=0)\n', (701, 735), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((803, 821), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (819, 821), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((602, 655), 'langchain_prefect.loaders.GitHubRepoLoader', 'GitHubRepoLoader', (['"""PrefectHQ/prefect"""'], {'glob': '"""**/*.md"""'}), "('PrefectHQ/prefect', glob='**/*.md')\n", (618, 655), False, 'from langchain_prefect.loaders import GitHubRepoLoader\n'), ((1084, 1142), 'langchain.prompts.chat.SystemMessagePromptTemplate.from_template', 'SystemMessagePromptTemplate.from_template', (['system_template'], {}), '(system_template)\n', (1125, 1142), False, 'from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((1152, 1206), 'langchain.prompts.chat.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['"""{question}"""'], {}), "('{question}')\n", (1192, 1206), False, 'from langchain.prompts.chat import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate\n'), ((1258, 1283), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)'}), '(temperature=0)\n', (1268, 1283), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1301, 1345), 'langchain.vectorstores.Chroma.from_documents', 'Chroma.from_documents', (['documents', 'embeddings'], {}), '(documents, embeddings)\n', (1322, 1345), False, 'from langchain.vectorstores import Chroma\n')] |
from dotenv import load_dotenv
load_dotenv()
import os
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from langchain.prompts import (
PromptTemplate,
)
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
from langchain.agents import AgentExecutor, ConversationalChatAgent
from tools.make_thunder_tool import MakeThunderTool
from tools.draw_tool import DrawTool
from tools.is_in_heaven import IsInHeavenTool
from voice.speech import speak
from voice.listen import listen
openai_api_key = os.getenv("OPENAI_API_KEY")
class GodAgent:
def __init__(self):
self.executor = self.assemble_agent_executor()
def assemble_agent_executor(self):
template = """
You are omnipotent, kind, benevolent god. The user is "your child". Be a little bit condescending yet funny. You try to fulfill his every wish. Make witty comments about user wishes.
You can use tools to help you fulfill user wishes. YOU MUST RESPOND IN THE CORRECT FORMAT.
"""
#Initialize LLM
llm = ChatOpenAI(openai_api_key=openai_api_key, verbose=True, temperature=0.3, model_name="gpt-4")
# Create memory
memory = ConversationBufferMemory(memory_key="chat_history", human_prefix="User", ai_prefix="God", return_messages=True)
#Register tools
tools = [
IsInHeavenTool(),
MakeThunderTool(),
DrawTool()
]
# Create Langchain agent and executor
agent = ConversationalChatAgent.from_llm_and_tools(llm= llm, memory=memory, tools=tools, verbose=True, system_message=template)
executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, memory=memory, verbose=True)
return executor
def processing_callback(self,recognized_input):
print("--")
print(recognized_input)
print("")
result = self.executor.run(input=recognized_input)
#print(result)
speak(result)
def run(self):
listen(self.processing_callback)
GodAgent().run()
| [
"langchain.agents.ConversationalChatAgent.from_llm_and_tools",
"langchain.agents.AgentExecutor.from_agent_and_tools",
"langchain.memory.ConversationBufferMemory",
"langchain.chat_models.ChatOpenAI"
] | [((31, 44), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (42, 44), False, 'from dotenv import load_dotenv\n'), ((574, 601), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (583, 601), False, 'import os\n'), ((1087, 1183), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'openai_api_key': 'openai_api_key', 'verbose': '(True)', 'temperature': '(0.3)', 'model_name': '"""gpt-4"""'}), "(openai_api_key=openai_api_key, verbose=True, temperature=0.3,\n model_name='gpt-4')\n", (1097, 1183), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1222, 1337), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""', 'human_prefix': '"""User"""', 'ai_prefix': '"""God"""', 'return_messages': '(True)'}), "(memory_key='chat_history', human_prefix='User',\n ai_prefix='God', return_messages=True)\n", (1246, 1337), False, 'from langchain.memory import ConversationBufferMemory\n'), ((1550, 1673), 'langchain.agents.ConversationalChatAgent.from_llm_and_tools', 'ConversationalChatAgent.from_llm_and_tools', ([], {'llm': 'llm', 'memory': 'memory', 'tools': 'tools', 'verbose': '(True)', 'system_message': 'template'}), '(llm=llm, memory=memory, tools=\n tools, verbose=True, system_message=template)\n', (1592, 1673), False, 'from langchain.agents import AgentExecutor, ConversationalChatAgent\n'), ((1690, 1783), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'agent', 'tools': 'tools', 'memory': 'memory', 'verbose': '(True)'}), '(agent=agent, tools=tools, memory=memory,\n verbose=True)\n', (1724, 1783), False, 'from langchain.agents import AgentExecutor, ConversationalChatAgent\n'), ((2021, 2034), 'voice.speech.speak', 'speak', (['result'], {}), '(result)\n', (2026, 2034), False, 'from voice.speech import speak\n'), ((2063, 2095), 'voice.listen.listen', 'listen', (['self.processing_callback'], {}), '(self.processing_callback)\n', (2069, 2095), False, 'from voice.listen import listen\n'), ((1397, 1413), 'tools.is_in_heaven.IsInHeavenTool', 'IsInHeavenTool', ([], {}), '()\n', (1411, 1413), False, 'from tools.is_in_heaven import IsInHeavenTool\n'), ((1427, 1444), 'tools.make_thunder_tool.MakeThunderTool', 'MakeThunderTool', ([], {}), '()\n', (1442, 1444), False, 'from tools.make_thunder_tool import MakeThunderTool\n'), ((1458, 1468), 'tools.draw_tool.DrawTool', 'DrawTool', ([], {}), '()\n', (1466, 1468), False, 'from tools.draw_tool import DrawTool\n')] |
from __future__ import annotations
from abc import abstractmethod
from typing import TYPE_CHECKING, Any, Dict, List, Sequence
from langchain.load.serializable import Serializable
from langchain.pydantic_v1 import Field
if TYPE_CHECKING:
from langchain.prompts.chat import ChatPromptTemplate
def get_buffer_string(
messages: Sequence[BaseMessage], human_prefix: str = "Human", ai_prefix: str = "AI"
) -> str:
"""Convert sequence of Messages to strings and concatenate them into one string.
Args:
messages: Messages to be converted to strings.
human_prefix: The prefix to prepend to contents of HumanMessages.
ai_prefix: THe prefix to prepend to contents of AIMessages.
Returns:
A single string concatenation of all input messages.
Example:
.. code-block:: python
from langchain.schema import AIMessage, HumanMessage
messages = [
HumanMessage(content="Hi, how are you?"),
AIMessage(content="Good, how are you?"),
]
get_buffer_string(messages)
# -> "Human: Hi, how are you?\nAI: Good, how are you?"
"""
string_messages = []
for m in messages:
if isinstance(m, HumanMessage):
role = human_prefix
elif isinstance(m, AIMessage):
role = ai_prefix
elif isinstance(m, SystemMessage):
role = "System"
elif isinstance(m, FunctionMessage):
role = "Function"
elif isinstance(m, ChatMessage):
role = m.role
else:
raise ValueError(f"Got unsupported message type: {m}")
message = f"{role}: {m.content}"
if isinstance(m, AIMessage) and "function_call" in m.additional_kwargs:
message += f"{m.additional_kwargs['function_call']}"
string_messages.append(message)
return "\n".join(string_messages)
class BaseMessage(Serializable):
"""The base abstract Message class.
Messages are the inputs and outputs of ChatModels.
"""
content: str
"""The string contents of the message."""
additional_kwargs: dict = Field(default_factory=dict)
"""Any additional information."""
@property
@abstractmethod
def type(self) -> str:
"""Type of the Message, used for serialization."""
@property
def lc_serializable(self) -> bool:
"""Whether this class is LangChain serializable."""
return True
def __add__(self, other: Any) -> ChatPromptTemplate:
from langchain.prompts.chat import ChatPromptTemplate
prompt = ChatPromptTemplate(messages=[self])
return prompt + other
class BaseMessageChunk(BaseMessage):
"""A Message chunk, which can be concatenated with other Message chunks."""
def _merge_kwargs_dict(
self, left: Dict[str, Any], right: Dict[str, Any]
) -> Dict[str, Any]:
"""Merge additional_kwargs from another BaseMessageChunk into this one."""
merged = left.copy()
for k, v in right.items():
if k not in merged:
merged[k] = v
elif type(merged[k]) != type(v):
raise ValueError(
f'additional_kwargs["{k}"] already exists in this message,'
" but with a different type."
)
elif isinstance(merged[k], str):
merged[k] += v
elif isinstance(merged[k], dict):
merged[k] = self._merge_kwargs_dict(merged[k], v)
else:
raise ValueError(
f"Additional kwargs key {k} already exists in this message."
)
return merged
def __add__(self, other: Any) -> BaseMessageChunk: # type: ignore
if isinstance(other, BaseMessageChunk):
# If both are (subclasses of) BaseMessageChunk,
# concat into a single BaseMessageChunk
return self.__class__(
content=self.content + other.content,
additional_kwargs=self._merge_kwargs_dict(
self.additional_kwargs, other.additional_kwargs
),
)
else:
raise TypeError(
'unsupported operand type(s) for +: "'
f"{self.__class__.__name__}"
f'" and "{other.__class__.__name__}"'
)
class HumanMessage(BaseMessage):
"""A Message from a human."""
example: bool = False
"""Whether this Message is being passed in to the model as part of an example
conversation.
"""
@property
def type(self) -> str:
"""Type of the message, used for serialization."""
return "human"
class HumanMessageChunk(HumanMessage, BaseMessageChunk):
"""A Human Message chunk."""
pass
class AIMessage(BaseMessage):
"""A Message from an AI."""
example: bool = False
"""Whether this Message is being passed in to the model as part of an example
conversation.
"""
@property
def type(self) -> str:
"""Type of the message, used for serialization."""
return "ai"
class AIMessageChunk(AIMessage, BaseMessageChunk):
"""A Message chunk from an AI."""
pass
class SystemMessage(BaseMessage):
"""A Message for priming AI behavior, usually passed in as the first of a sequence
of input messages.
"""
@property
def type(self) -> str:
"""Type of the message, used for serialization."""
return "system"
class SystemMessageChunk(SystemMessage, BaseMessageChunk):
"""A System Message chunk."""
pass
class FunctionMessage(BaseMessage):
"""A Message for passing the result of executing a function back to a model."""
name: str
"""The name of the function that was executed."""
@property
def type(self) -> str:
"""Type of the message, used for serialization."""
return "function"
class FunctionMessageChunk(FunctionMessage, BaseMessageChunk):
"""A Function Message chunk."""
pass
class ChatMessage(BaseMessage):
"""A Message that can be assigned an arbitrary speaker (i.e. role)."""
role: str
"""The speaker / role of the Message."""
@property
def type(self) -> str:
"""Type of the message, used for serialization."""
return "chat"
class ChatMessageChunk(ChatMessage, BaseMessageChunk):
"""A Chat Message chunk."""
pass
def _message_to_dict(message: BaseMessage) -> dict:
return {"type": message.type, "data": message.dict()}
def messages_to_dict(messages: Sequence[BaseMessage]) -> List[dict]:
"""Convert a sequence of Messages to a list of dictionaries.
Args:
messages: Sequence of messages (as BaseMessages) to convert.
Returns:
List of messages as dicts.
"""
return [_message_to_dict(m) for m in messages]
def _message_from_dict(message: dict) -> BaseMessage:
_type = message["type"]
if _type == "human":
return HumanMessage(**message["data"])
elif _type == "ai":
return AIMessage(**message["data"])
elif _type == "system":
return SystemMessage(**message["data"])
elif _type == "chat":
return ChatMessage(**message["data"])
elif _type == "function":
return FunctionMessage(**message["data"])
else:
raise ValueError(f"Got unexpected message type: {_type}")
def messages_from_dict(messages: List[dict]) -> List[BaseMessage]:
"""Convert a sequence of messages from dicts to Message objects.
Args:
messages: Sequence of messages (as dicts) to convert.
Returns:
List of messages (BaseMessages).
"""
return [_message_from_dict(m) for m in messages]
| [
"langchain.pydantic_v1.Field",
"langchain.prompts.chat.ChatPromptTemplate"
] | [((2151, 2178), 'langchain.pydantic_v1.Field', 'Field', ([], {'default_factory': 'dict'}), '(default_factory=dict)\n', (2156, 2178), False, 'from langchain.pydantic_v1 import Field\n'), ((2610, 2645), 'langchain.prompts.chat.ChatPromptTemplate', 'ChatPromptTemplate', ([], {'messages': '[self]'}), '(messages=[self])\n', (2628, 2645), False, 'from langchain.prompts.chat import ChatPromptTemplate\n')] |
import logging
from typing import Any, Dict, List, Mapping, Optional
from langchain.callbacks.manager import CallbackManagerForLLMRun
from langchain.llms.base import LLM
from langchain.llms.utils import enforce_stop_tokens
from langchain.pydantic_v1 import BaseModel, Extra, Field, root_validator
from langchain.utils import get_from_dict_or_env
logger = logging.getLogger(__name__)
class PipelineAI(LLM, BaseModel):
"""PipelineAI large language models.
To use, you should have the ``pipeline-ai`` python package installed,
and the environment variable ``PIPELINE_API_KEY`` set with your API key.
Any parameters that are valid to be passed to the call can be passed
in, even if not explicitly saved on this class.
Example:
.. code-block:: python
from langchain import PipelineAI
pipeline = PipelineAI(pipeline_key="")
"""
pipeline_key: str = ""
"""The id or tag of the target pipeline"""
pipeline_kwargs: Dict[str, Any] = Field(default_factory=dict)
"""Holds any pipeline parameters valid for `create` call not
explicitly specified."""
pipeline_api_key: Optional[str] = None
class Config:
"""Configuration for this pydantic config."""
extra = Extra.forbid
@root_validator(pre=True)
def build_extra(cls, values: Dict[str, Any]) -> Dict[str, Any]:
"""Build extra kwargs from additional params that were passed in."""
all_required_field_names = {field.alias for field in cls.__fields__.values()}
extra = values.get("pipeline_kwargs", {})
for field_name in list(values):
if field_name not in all_required_field_names:
if field_name in extra:
raise ValueError(f"Found {field_name} supplied twice.")
logger.warning(
f"""{field_name} was transferred to pipeline_kwargs.
Please confirm that {field_name} is what you intended."""
)
extra[field_name] = values.pop(field_name)
values["pipeline_kwargs"] = extra
return values
@root_validator()
def validate_environment(cls, values: Dict) -> Dict:
"""Validate that api key and python package exists in environment."""
pipeline_api_key = get_from_dict_or_env(
values, "pipeline_api_key", "PIPELINE_API_KEY"
)
values["pipeline_api_key"] = pipeline_api_key
return values
@property
def _identifying_params(self) -> Mapping[str, Any]:
"""Get the identifying parameters."""
return {
**{"pipeline_key": self.pipeline_key},
**{"pipeline_kwargs": self.pipeline_kwargs},
}
@property
def _llm_type(self) -> str:
"""Return type of llm."""
return "pipeline_ai"
def _call(
self,
prompt: str,
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> str:
"""Call to Pipeline Cloud endpoint."""
try:
from pipeline import PipelineCloud
except ImportError:
raise ValueError(
"Could not import pipeline-ai python package. "
"Please install it with `pip install pipeline-ai`."
)
client = PipelineCloud(token=self.pipeline_api_key)
params = self.pipeline_kwargs or {}
params = {**params, **kwargs}
run = client.run_pipeline(self.pipeline_key, [prompt, params])
try:
text = run.result_preview[0][0]
except AttributeError:
raise AttributeError(
f"A pipeline run should have a `result_preview` attribute."
f"Run was: {run}"
)
if stop is not None:
# I believe this is required since the stop tokens
# are not enforced by the pipeline parameters
text = enforce_stop_tokens(text, stop)
return text
| [
"langchain.llms.utils.enforce_stop_tokens",
"langchain.pydantic_v1.Field",
"langchain.pydantic_v1.root_validator",
"langchain.utils.get_from_dict_or_env"
] | [((357, 384), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (374, 384), False, 'import logging\n'), ((1004, 1031), 'langchain.pydantic_v1.Field', 'Field', ([], {'default_factory': 'dict'}), '(default_factory=dict)\n', (1009, 1031), False, 'from langchain.pydantic_v1 import BaseModel, Extra, Field, root_validator\n'), ((1279, 1303), 'langchain.pydantic_v1.root_validator', 'root_validator', ([], {'pre': '(True)'}), '(pre=True)\n', (1293, 1303), False, 'from langchain.pydantic_v1 import BaseModel, Extra, Field, root_validator\n'), ((2131, 2147), 'langchain.pydantic_v1.root_validator', 'root_validator', ([], {}), '()\n', (2145, 2147), False, 'from langchain.pydantic_v1 import BaseModel, Extra, Field, root_validator\n'), ((2310, 2378), 'langchain.utils.get_from_dict_or_env', 'get_from_dict_or_env', (['values', '"""pipeline_api_key"""', '"""PIPELINE_API_KEY"""'], {}), "(values, 'pipeline_api_key', 'PIPELINE_API_KEY')\n", (2330, 2378), False, 'from langchain.utils import get_from_dict_or_env\n'), ((3361, 3403), 'pipeline.PipelineCloud', 'PipelineCloud', ([], {'token': 'self.pipeline_api_key'}), '(token=self.pipeline_api_key)\n', (3374, 3403), False, 'from pipeline import PipelineCloud\n'), ((3973, 4004), 'langchain.llms.utils.enforce_stop_tokens', 'enforce_stop_tokens', (['text', 'stop'], {}), '(text, stop)\n', (3992, 4004), False, 'from langchain.llms.utils import enforce_stop_tokens\n')] |
from typing import Optional, Type
import streamlit as st
import tldextract
import whois
import whoisit
from langchain.agents import AgentType, Tool, initialize_agent
from langchain.chat_models import ChatOpenAI
from langchain.tools import BaseTool
from langchain.tools.ddg_search import DuckDuckGoSearchRun
from pydantic import BaseModel, Field
# Streamlit app
st.title("TakedownGPT ⬇️🤖")
# Add 'How to Use' section to the sidebar
st.sidebar.header("How to Use 📝")
st.sidebar.markdown("""
1. Enter your OpenAI API key and select the OpenAI model you would like to use.
2. Input the domain name for which you want to send a takedown request.
3. Select the reason for the takedown request, or specify a custom reason.
4. Click the 'Generate Takedown Request' button to create the draft email and find the appropriate email address for the takedown request.
5. Copy or download the draft email and send it to the appropriate email address.
""")
api_key = st.sidebar.text_input("Enter your OpenAI API key:", type="password", help="You can find your OpenAI API on the [OpenAI dashboard](https://platform.openai.com/account/api-keys)")
# Add 'Model Selection' section to the sidebar
model_options = [
"gpt-3.5-turbo-0613",
"gpt-4-0613"
]
selected_model = st.sidebar.selectbox("Select the OpenAI model you would like to use:", model_options, help="You must have been given access to the [GPT-4 API](https://openai.com/waitlist/gpt-4-api) by OpenAI in order to use it.")
# Add 'About' section to the sidebar
st.sidebar.header("About 🌐")
st.sidebar.markdown("""
This app helps you draft takedown requests to domain registrars.
It uses a combination of autonomous LangChain Agents and OpenAI's recently introduced support for function calling to:
1. Perform a WHOIS / RDAP lookup to identify the registrar for the given website
2. Search the web with DuckDuckGo to find the appropriate email address for takedown requests for that domain registrar
3. Draft a takedown request email to the hosting provider citing the reason for the takedown request
Created by [Matt Adams](https://www.linkedin.com/in/matthewrwadams/).
""")
# Domain input field
domain = st.text_input("Enter the domain that is the subject of the takedown request:", help="e.g. 'example.com'")
# Takedown reason drop-down field
reason_options = [
"Copyright infringement",
"Trademark infringement",
"Defamation or libel",
"Privacy violations",
"Malware or phishing activities",
"Violation of terms of service",
"Personal safety concerns",
"Other (specify)",
]
reason = st.selectbox("Select the reason for the takedown request:", reason_options)
if reason == "Other (specify)":
custom_reason = st.text_input("Specify the custom reason for the takedown request:")
else:
custom_reason = None
# Additional information input field
additional_info = st.text_area("Provide additional information to support your request (optional):", help="This information will be included in the takedown request email.")
# Advanced Options collapsible menu
advanced_options = st.expander("Advanced Options ⚙️")
# Add protocol options for performing domain lookups
lookup_options = [
"WHOIS",
"RDAP"
]
selected_lookup = advanced_options.selectbox("Select your preferred protocol for domain registrar lookups:", lookup_options)
if selected_lookup == "RDAP":
tool_name = "rdap_lookup"
else:
tool_name = "get_registrar"
# Check if domain is valid
def is_valid_domain(domain):
extracted = tldextract.extract(domain)
if extracted.domain and extracted.suffix:
return True
return False
# Error handling function
def handle_error(error_message):
st.error(error_message)
if st.button("Generate Takedown Request 📨"):
if not api_key:
handle_error("Please provide an OpenAI API key. 🔑")
elif not domain:
handle_error("Please provide a domain name. 🌐")
elif not is_valid_domain(domain):
handle_error("Please provide a valid domain name. 🌐")
else:
# Set API key
api_key = api_key
# Initialize ChatOpenAI
llm = ChatOpenAI(temperature=0.7, model=selected_model, openai_api_key=api_key)
# Initialize DuckDuckGo Search
search = DuckDuckGoSearchRun()
# Define a custom tool for WHOIS lookups
class GetRegistrarCheckInput(BaseModel):
domain: str = Field(..., description="The domain name to look up")
class GetRegistrarTool(BaseTool):
name = "get_registrar"
description = "Useful for finding the registrar of a given domain name using WHOIS"
def _run(self, domain: str):
w = whois.whois(domain)
return w.registrar
def _arun(self, domain: str):
raise NotImplementedError("This tool does not support async")
args_schema: Optional[Type[BaseModel]] = GetRegistrarCheckInput
# Define a custom tool for RDAP lookups
class RDAPLookupTool(BaseTool):
name = "rdap_lookup"
description = "Useful for finding the registrar of a given domain name using RDAP"
def _run(self, domain: str):
whoisit.bootstrap()
results = whoisit.domain(domain)
return results
def _arun(self, domain: str):
raise NotImplementedError("This tool does not support async")
args_schema: Optional[Type[BaseModel]] = GetRegistrarCheckInput
# Defining Tools
tools = [
Tool(
name="Search",
func=search.run,
description="useful for when you need to find web pages. You should ask targeted questions"
),
GetRegistrarTool(),
RDAPLookupTool()
]
# Initializing the Agent
open_ai_agent = initialize_agent(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)
# Defining and running the Prompt
prompt = """
Task:
1. Use the {tool_name} tool to find the domain registrar for {domain}.
2. Perform a web search to find the email address for takedown requests for that domain registrar.
3. Prepare a draft email takedown request to the hosting provider citing the following reason: {reason}. Include the additional information provided: {additional_info}
Your response must be in the following format and should not include any other information:
- Registrar name: [registrar]
- Email address for takedown requests: [registrar_email]
- Email subject: [subject]
- Email body: [body]
Your response:
"""
# Fill placeholders with actual data
if custom_reason:
prompt_filled = prompt.format(tool_name=tool_name, domain=domain, reason=custom_reason, additional_info=additional_info)
else:
prompt_filled = prompt.format(tool_name=tool_name, domain=domain, reason=reason, additional_info=additional_info)
try:
with st.spinner("Processing your request... ⏳"):
# Run the agent
response = open_ai_agent.run(prompt_filled)
if "Email address for takedown requests: [not found]" in response:
handle_error("Could not find the email address for takedown requests. Please try again or manually search for the domain registrar's contact information. 🚫")
else:
# Display the result
st.code(response, language="text")
# Add download button for the generated takedown request
filename = f"{domain}_takedown_request.txt"
st.download_button(
label="Download Takedown Request 📥",
data=response.encode("utf-8"),
file_name=filename,
mime="text/plain",
)
except Exception as e:
handle_error(f"An error occurred while processing your request: {str(e)} ❌") | [
"langchain.tools.ddg_search.DuckDuckGoSearchRun",
"langchain.agents.initialize_agent",
"langchain.agents.Tool",
"langchain.chat_models.ChatOpenAI"
] | [((363, 390), 'streamlit.title', 'st.title', (['"""TakedownGPT ⬇️🤖"""'], {}), "('TakedownGPT ⬇️🤖')\n", (371, 390), True, 'import streamlit as st\n'), ((434, 467), 'streamlit.sidebar.header', 'st.sidebar.header', (['"""How to Use 📝"""'], {}), "('How to Use 📝')\n", (451, 467), True, 'import streamlit as st\n'), ((468, 954), 'streamlit.sidebar.markdown', 'st.sidebar.markdown', (['"""\n1. Enter your OpenAI API key and select the OpenAI model you would like to use.\n2. Input the domain name for which you want to send a takedown request.\n3. Select the reason for the takedown request, or specify a custom reason.\n4. Click the \'Generate Takedown Request\' button to create the draft email and find the appropriate email address for the takedown request.\n5. Copy or download the draft email and send it to the appropriate email address.\n"""'], {}), '(\n """\n1. Enter your OpenAI API key and select the OpenAI model you would like to use.\n2. Input the domain name for which you want to send a takedown request.\n3. Select the reason for the takedown request, or specify a custom reason.\n4. Click the \'Generate Takedown Request\' button to create the draft email and find the appropriate email address for the takedown request.\n5. Copy or download the draft email and send it to the appropriate email address.\n"""\n )\n', (487, 954), True, 'import streamlit as st\n'), ((956, 1143), 'streamlit.sidebar.text_input', 'st.sidebar.text_input', (['"""Enter your OpenAI API key:"""'], {'type': '"""password"""', 'help': '"""You can find your OpenAI API on the [OpenAI dashboard](https://platform.openai.com/account/api-keys)"""'}), "('Enter your OpenAI API key:', type='password', help=\n 'You can find your OpenAI API on the [OpenAI dashboard](https://platform.openai.com/account/api-keys)'\n )\n", (977, 1143), True, 'import streamlit as st\n'), ((1262, 1489), 'streamlit.sidebar.selectbox', 'st.sidebar.selectbox', (['"""Select the OpenAI model you would like to use:"""', 'model_options'], {'help': '"""You must have been given access to the [GPT-4 API](https://openai.com/waitlist/gpt-4-api) by OpenAI in order to use it."""'}), "('Select the OpenAI model you would like to use:',\n model_options, help=\n 'You must have been given access to the [GPT-4 API](https://openai.com/waitlist/gpt-4-api) by OpenAI in order to use it.'\n )\n", (1282, 1489), True, 'import streamlit as st\n'), ((1514, 1542), 'streamlit.sidebar.header', 'st.sidebar.header', (['"""About 🌐"""'], {}), "('About 🌐')\n", (1531, 1542), True, 'import streamlit as st\n'), ((1543, 2144), 'streamlit.sidebar.markdown', 'st.sidebar.markdown', (['"""\nThis app helps you draft takedown requests to domain registrars.\nIt uses a combination of autonomous LangChain Agents and OpenAI\'s recently introduced support for function calling to:\n 1. Perform a WHOIS / RDAP lookup to identify the registrar for the given website\n 2. Search the web with DuckDuckGo to find the appropriate email address for takedown requests for that domain registrar\n 3. Draft a takedown request email to the hosting provider citing the reason for the takedown request\n\nCreated by [Matt Adams](https://www.linkedin.com/in/matthewrwadams/).\n"""'], {}), '(\n """\nThis app helps you draft takedown requests to domain registrars.\nIt uses a combination of autonomous LangChain Agents and OpenAI\'s recently introduced support for function calling to:\n 1. Perform a WHOIS / RDAP lookup to identify the registrar for the given website\n 2. Search the web with DuckDuckGo to find the appropriate email address for takedown requests for that domain registrar\n 3. Draft a takedown request email to the hosting provider citing the reason for the takedown request\n\nCreated by [Matt Adams](https://www.linkedin.com/in/matthewrwadams/).\n"""\n )\n', (1562, 2144), True, 'import streamlit as st\n'), ((2166, 2275), 'streamlit.text_input', 'st.text_input', (['"""Enter the domain that is the subject of the takedown request:"""'], {'help': '"""e.g. \'example.com\'"""'}), '(\'Enter the domain that is the subject of the takedown request:\',\n help="e.g. \'example.com\'")\n', (2179, 2275), True, 'import streamlit as st\n'), ((2580, 2655), 'streamlit.selectbox', 'st.selectbox', (['"""Select the reason for the takedown request:"""', 'reason_options'], {}), "('Select the reason for the takedown request:', reason_options)\n", (2592, 2655), True, 'import streamlit as st\n'), ((2865, 3029), 'streamlit.text_area', 'st.text_area', (['"""Provide additional information to support your request (optional):"""'], {'help': '"""This information will be included in the takedown request email."""'}), "(\n 'Provide additional information to support your request (optional):',\n help='This information will be included in the takedown request email.')\n", (2877, 3029), True, 'import streamlit as st\n'), ((3077, 3111), 'streamlit.expander', 'st.expander', (['"""Advanced Options ⚙️"""'], {}), "('Advanced Options ⚙️')\n", (3088, 3111), True, 'import streamlit as st\n'), ((3710, 3750), 'streamlit.button', 'st.button', (['"""Generate Takedown Request 📨"""'], {}), "('Generate Takedown Request 📨')\n", (3719, 3750), True, 'import streamlit as st\n'), ((2709, 2777), 'streamlit.text_input', 'st.text_input', (['"""Specify the custom reason for the takedown request:"""'], {}), "('Specify the custom reason for the takedown request:')\n", (2722, 2777), True, 'import streamlit as st\n'), ((3508, 3534), 'tldextract.extract', 'tldextract.extract', (['domain'], {}), '(domain)\n', (3526, 3534), False, 'import tldextract\n'), ((3682, 3705), 'streamlit.error', 'st.error', (['error_message'], {}), '(error_message)\n', (3690, 3705), True, 'import streamlit as st\n'), ((4114, 4187), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0.7)', 'model': 'selected_model', 'openai_api_key': 'api_key'}), '(temperature=0.7, model=selected_model, openai_api_key=api_key)\n', (4124, 4187), False, 'from langchain.chat_models import ChatOpenAI\n'), ((4245, 4266), 'langchain.tools.ddg_search.DuckDuckGoSearchRun', 'DuckDuckGoSearchRun', ([], {}), '()\n', (4264, 4266), False, 'from langchain.tools.ddg_search import DuckDuckGoSearchRun\n'), ((5885, 5961), 'langchain.agents.initialize_agent', 'initialize_agent', (['tools', 'llm'], {'agent': 'AgentType.OPENAI_FUNCTIONS', 'verbose': '(True)'}), '(tools, llm, agent=AgentType.OPENAI_FUNCTIONS, verbose=True)\n', (5901, 5961), False, 'from langchain.agents import AgentType, Tool, initialize_agent\n'), ((4392, 4444), 'pydantic.Field', 'Field', (['...'], {'description': '"""The domain name to look up"""'}), "(..., description='The domain name to look up')\n", (4397, 4444), False, 'from pydantic import BaseModel, Field\n'), ((5563, 5702), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""Search"""', 'func': 'search.run', 'description': '"""useful for when you need to find web pages. You should ask targeted questions"""'}), "(name='Search', func=search.run, description=\n 'useful for when you need to find web pages. You should ask targeted questions'\n )\n", (5567, 5702), False, 'from langchain.agents import AgentType, Tool, initialize_agent\n'), ((4681, 4700), 'whois.whois', 'whois.whois', (['domain'], {}), '(domain)\n', (4692, 4700), False, 'import whois\n'), ((5209, 5228), 'whoisit.bootstrap', 'whoisit.bootstrap', ([], {}), '()\n', (5226, 5228), False, 'import whoisit\n'), ((5255, 5277), 'whoisit.domain', 'whoisit.domain', (['domain'], {}), '(domain)\n', (5269, 5277), False, 'import whoisit\n'), ((7118, 7160), 'streamlit.spinner', 'st.spinner', (['"""Processing your request... ⏳"""'], {}), "('Processing your request... ⏳')\n", (7128, 7160), True, 'import streamlit as st\n'), ((7591, 7625), 'streamlit.code', 'st.code', (['response'], {'language': '"""text"""'}), "(response, language='text')\n", (7598, 7625), True, 'import streamlit as st\n')] |
# -*- coding: utf-8 -*-
import os
import re
from typing import List, Union, Dict, Tuple, Any, Optional
from langchain.agents import Tool, AgentExecutor, AgentOutputParser, load_tools
from langchain.tools.base import BaseTool
from langchain.prompts import StringPromptTemplate
from langchain import OpenAI, GoogleSearchAPIWrapper, LLMChain
from langchain.chat_models import ChatOpenAI
from langchain.schema import AgentAction, AgentFinish
# import custom module
import sys
sys.path.append('.')
sys.path.append('..')
from utils.configs import configs
from utils.parser import get_arguments
from utils.load_query import load_query
from agents.custom_base_agent import LLMMultiActionAgent
from agent_template.AnalogyThought.tool import AnalogyThought
from agent_template.CombineSearchJudge.tool import CombineTool
from agent_template.DecompositionThought.tool import DecompositionThought
from agent_template.DIY.tool import DIYTool
from agent_template.Origin.tool import CustomOriginTool
from agent_template.PlanThought.tool import PlanThought
# from agent_template.Reflect.tool import ReactTool, ReactReflectTool
from agent_template.StepThought.tool import StepThought
# from agent_template.ValidationThought.tool import ValidationThought
from utils.evaluation import evaluation
from tools.get_answer import AnswerTool
args = get_arguments()
os.environ["GOOGLE_CSE_ID"] = configs['tools']['google_cse_id']
os.environ["GOOGLE_API_KEY"] = configs['tools']['google_api_key']
os.environ["OPENAI_API_KEY"] = configs['openai_api_key']
# Set up the base template
template = """Answer the following questions as best you can.
You have been given the question and the following possible answers by different tools, please select the most consistent one as the final answer:
{answers}
Use the following format:
Question: the input question you must answer
Final Answer: the final answer to the input question. The answer's format must end with json format: {{Answer: one of options[A,B,C,D,E]}}
Begin!
Question: {input}
{agent_scratchpad}"""
simple_template = """You have been given the following possible answers by different tools, please select the most consistent one as the final answer:
{answers}
Use the following format:
Final Answer: the final answer to the original input question. The answer's format must end with json format: {{Answer: one of options[A,B,C,D,E]}}
{agent_scratchpad}"""
# Set up a prompt template
class CustomPromptTemplate(StringPromptTemplate):
# The template to use
template: str
# The list of tools available
tools: List[BaseTool]
def format(self, **kwargs) -> str:
# Get the intermediate steps (AgentAction, Observation tuples)
# Format them in a particular way
intermediate_steps = kwargs.pop("intermediate_steps")
# print(intermediate_steps)
answers = ""
for action, observation in intermediate_steps:
answers += f"\nObservation[{action.tool}]: {observation}"
# Set the agent_scratchpad variable to empty value
kwargs["agent_scratchpad"] = ""
# Set the answers variable to the observation of actions
kwargs["answers"] = answers
query_json = load_query(kwargs['input'])
query_json['instruct'] = f"Now give you the {query_json['llm_task_type']} question and choices:"
final_query = '\n'.join([
query_json['instruct'],
query_json['context'],
query_json['question'],
query_json['options'],
])
kwargs["input"] = final_query
print(self.template.format(**kwargs))
return self.template.format(**kwargs)
class CustomOutputParser(AgentOutputParser):
def parse(self, llm_output: str) -> Union[List[AgentAction], AgentFinish]:
# Check if agent should finish
# print(llm_output)
if "Final Answer:" in llm_output:
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
log=llm_output,
)
else:
return AgentFinish(
# Return values is generally always a dictionary with a single `output` key
# It is not recommended to try anything else at the moment :)
return_values={"output": llm_output},
log=llm_output,
)
class LLMVoteAgent(LLMMultiActionAgent):
"""Master agent that controls all sub agents"""
@property
def input_keys(self):
return ["input"]
def plan(
self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
) -> Union[List[AgentAction], AgentFinish]:
"""Given input, decided what to do.
Args:
intermediate_steps: Steps the LLM has taken to date,
along with observations
**kwargs: User inputs.
Returns:
Action specifying what tool to use.
"""
question_and_answers = kwargs['input']
qa_json = load_query(question_and_answers)
if len(intermediate_steps) == 0:
# parse model_to_vote and get answer of each model
candidate_outputs = qa_json['candidate_output']
match = re.search(r'Candidate Outputs:\n(.*)', candidate_outputs, re.DOTALL)
if match:
answer_to_vote = match.group(1).split("#")
else:
raise ValueError(f'Could not parse {candidate_outputs}')
actions = []
for answer in answer_to_vote:
model_name = answer.split(': ')[0]
actions.append(AgentAction(tool=model_name, tool_input=answer, log=""))
return actions
else:
# vote for multiple answers
output = self.llm_chain.run(
intermediate_steps=intermediate_steps, stop=self.stop, **kwargs
)
# append tool answers
tools_answer = "\nTool Answer:\n"
for action, observation in intermediate_steps:
tools_answer += f'{action.tool}: {observation}\n'
return self.output_parser.parse(output + tools_answer)
async def aplan(
self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
) -> Union[List[AgentAction], AgentFinish]:
"""Given input, decided what to do.
Args:
intermediate_steps: Steps the LLM has taken to date,
along with observations
**kwargs: User inputs.
Returns:
Action specifying what tool to use.
"""
question_and_answers = kwargs['input']
qa_json = load_query(question_and_answers)
if len(intermediate_steps) == 0:
# parse model_to_vote and get answer of each model
candidate_outputs = qa_json['candidate_output']
match = re.search(r'Candidate Outputs:\n(.*)', candidate_outputs, re.DOTALL)
if match:
answer_to_vote = match.group(1).split("#")
else:
raise ValueError(f'Could not parse {candidate_outputs}')
actions = []
for answer in answer_to_vote:
model_name = answer.split(': ')[0]
actions.append(AgentAction(tool=model_name, tool_input=answer, log=""))
return actions
else:
# vote for multiple answers
output = self.llm_chain.run(
intermediate_steps=intermediate_steps, stop=self.stop, **kwargs
)
# append tool answers
tools_answer = "\nTool Answer:\n"
for action, observation in intermediate_steps:
tools_answer += f'{action.tool}: {observation}\n'
return self.output_parser.parse(output + tools_answer)
if __name__ == '__main__':
# Define custom LLM
model_name = configs['model_name']
# llm = OpenAI(model_name=model_name, temperature=0)
llm = ChatOpenAI(model_name=model_name, temperature=0)
# Define which tools the agent can use to answer user queries
model_to_vote = eval(args.model_to_vote)
tools = [
AnswerTool(name=model_name)
for model_name in model_to_vote
]
tool_names = [tool.name for tool in tools]
# Define custom prompt template
prompt = CustomPromptTemplate(
# template=simple_template,
template=template,
tools=tools,
# This omits the `agent_scratchpad`, `answers` variables because those are generated dynamically
# This includes the `intermediate_steps` variable because that is needed
input_variables=["input", "intermediate_steps"]
)
# LLM chain consisting of the LLM and a prompt
llm_chain = LLMChain(llm=llm, prompt=prompt)
# Define custom output parser
output_parser = CustomOutputParser()
# Define custom LLMMultiActionAgent
agent = LLMVoteAgent(
llm_chain=llm_chain,
output_parser=output_parser,
stop=['\nFinal Answer: '],
allowed_tools=tool_names
)
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
# get args
question = args.question
is_eval = args.is_eval
if is_eval:
result = evaluation(agent_executor, llm, args)
for k, v in result.items():
print(f'{k}: {v}')
else:
ans = agent_executor.run(question)
print(ans)
| [
"langchain.agents.AgentExecutor.from_agent_and_tools",
"langchain.LLMChain",
"langchain.schema.AgentAction",
"langchain.chat_models.ChatOpenAI",
"langchain.schema.AgentFinish"
] | [((473, 493), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (488, 493), False, 'import sys\n'), ((494, 515), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (509, 515), False, 'import sys\n'), ((1325, 1340), 'utils.parser.get_arguments', 'get_arguments', ([], {}), '()\n', (1338, 1340), False, 'from utils.parser import get_arguments\n'), ((8146, 8194), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model_name': 'model_name', 'temperature': '(0)'}), '(model_name=model_name, temperature=0)\n', (8156, 8194), False, 'from langchain.chat_models import ChatOpenAI\n'), ((8922, 8954), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (8930, 8954), False, 'from langchain import OpenAI, GoogleSearchAPIWrapper, LLMChain\n'), ((9260, 9334), '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', (9294, 9334), False, 'from langchain.agents import Tool, AgentExecutor, AgentOutputParser, load_tools\n'), ((3200, 3227), 'utils.load_query.load_query', 'load_query', (["kwargs['input']"], {}), "(kwargs['input'])\n", (3210, 3227), False, 'from utils.load_query import load_query\n'), ((5188, 5220), 'utils.load_query.load_query', 'load_query', (['question_and_answers'], {}), '(question_and_answers)\n', (5198, 5220), False, 'from utils.load_query import load_query\n'), ((6835, 6867), 'utils.load_query.load_query', 'load_query', (['question_and_answers'], {}), '(question_and_answers)\n', (6845, 6867), False, 'from utils.load_query import load_query\n'), ((8329, 8356), 'tools.get_answer.AnswerTool', 'AnswerTool', ([], {'name': 'model_name'}), '(name=model_name)\n', (8339, 8356), False, 'from tools.get_answer import AnswerTool\n'), ((9441, 9478), 'utils.evaluation.evaluation', 'evaluation', (['agent_executor', 'llm', 'args'], {}), '(agent_executor, llm, args)\n', (9451, 9478), False, 'from utils.evaluation import evaluation\n'), ((4256, 4321), 'langchain.schema.AgentFinish', 'AgentFinish', ([], {'return_values': "{'output': llm_output}", 'log': 'llm_output'}), "(return_values={'output': llm_output}, log=llm_output)\n", (4267, 4321), False, 'from langchain.schema import AgentAction, AgentFinish\n'), ((5405, 5473), 're.search', 're.search', (['"""Candidate Outputs:\\\\n(.*)"""', 'candidate_outputs', 're.DOTALL'], {}), "('Candidate Outputs:\\\\n(.*)', candidate_outputs, re.DOTALL)\n", (5414, 5473), False, 'import re\n'), ((7052, 7120), 're.search', 're.search', (['"""Candidate Outputs:\\\\n(.*)"""', 'candidate_outputs', 're.DOTALL'], {}), "('Candidate Outputs:\\\\n(.*)', candidate_outputs, re.DOTALL)\n", (7061, 7120), False, 'import re\n'), ((5795, 5850), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'model_name', 'tool_input': 'answer', 'log': '""""""'}), "(tool=model_name, tool_input=answer, log='')\n", (5806, 5850), False, 'from langchain.schema import AgentAction, AgentFinish\n'), ((7442, 7497), 'langchain.schema.AgentAction', 'AgentAction', ([], {'tool': 'model_name', 'tool_input': 'answer', 'log': '""""""'}), "(tool=model_name, tool_input=answer, log='')\n", (7453, 7497), False, 'from langchain.schema import AgentAction, AgentFinish\n')] |
import sqlite3
import pandas as pd
import os
import json
import warnings
from langchain import SQLDatabase
from langchain.docstore.document import Document
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings
from sqlalchemy import exc
from sqlalchemy.exc import SAWarning
warnings.filterwarnings('ignore', category=SAWarning)
from src.data.setup.vector_setup_functions import get_json, connect_db, prep_chroma_documents, create_chroma_db
from src.data.setup.db_setup_functions import get_filenames, get_table_names, get_column_info, df_text_processing, build_schema_info, convert_df_to_json
#### BUILD CONSOLIDATED SCHEMA INFORMATION ####
#you can do this from the provided tables, but that would not be as scaleable in the real world.
#point to location you saved the data to and the type of database
data_directory = 'src/data/raw/spider/database/'
db_type = '.sqlite'
#create a dataframe with schema info
schema_df = build_schema_info(filepath=data_directory, filetype=db_type)
#create a json of the same data if that fomrat tickles your fancy
schema_json = convert_df_to_json(df=schema_df)
##### SAVE SCHEMA INFO #####
save_path = 'src/data/processed/db/'
print("\nSaving dataframe and JSON...")
#save df in pickle file
filepath = save_path+'schema_info.pkl'
schema_df.to_pickle(filepath)
#save json in json file
with open(save_path+'schema_info.json', 'w') as file:
json.dump(schema_json, file)
print("...Success")
#### CREATING VECTOR DATABASE FROM SCHEMA INFORMATION ####
#setup embeddings using HuggingFace
embeddings = HuggingFaceEmbeddings()
#point to json file with schema info
json_path = 'src/data/processed/db/schema_info.json'
#point to location to save the vector database
persist_directory = 'src/data/processed/chromadb/'
schema_docs = prep_chroma_documents(json_path=json_path, db_path=data_directory)
create_chroma_db(docs=schema_docs, persist_dir=persist_directory, embed_func=embeddings) | [
"langchain.embeddings.HuggingFaceEmbeddings"
] | [((320, 373), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {'category': 'SAWarning'}), "('ignore', category=SAWarning)\n", (343, 373), False, 'import warnings\n'), ((973, 1033), 'src.data.setup.db_setup_functions.build_schema_info', 'build_schema_info', ([], {'filepath': 'data_directory', 'filetype': 'db_type'}), '(filepath=data_directory, filetype=db_type)\n', (990, 1033), False, 'from src.data.setup.db_setup_functions import get_filenames, get_table_names, get_column_info, df_text_processing, build_schema_info, convert_df_to_json\n'), ((1115, 1147), 'src.data.setup.db_setup_functions.convert_df_to_json', 'convert_df_to_json', ([], {'df': 'schema_df'}), '(df=schema_df)\n', (1133, 1147), False, 'from src.data.setup.db_setup_functions import get_filenames, get_table_names, get_column_info, df_text_processing, build_schema_info, convert_df_to_json\n'), ((1594, 1617), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {}), '()\n', (1615, 1617), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n'), ((1823, 1889), 'src.data.setup.vector_setup_functions.prep_chroma_documents', 'prep_chroma_documents', ([], {'json_path': 'json_path', 'db_path': 'data_directory'}), '(json_path=json_path, db_path=data_directory)\n', (1844, 1889), False, 'from src.data.setup.vector_setup_functions import get_json, connect_db, prep_chroma_documents, create_chroma_db\n'), ((1891, 1983), 'src.data.setup.vector_setup_functions.create_chroma_db', 'create_chroma_db', ([], {'docs': 'schema_docs', 'persist_dir': 'persist_directory', 'embed_func': 'embeddings'}), '(docs=schema_docs, persist_dir=persist_directory,\n embed_func=embeddings)\n', (1907, 1983), False, 'from src.data.setup.vector_setup_functions import get_json, connect_db, prep_chroma_documents, create_chroma_db\n'), ((1432, 1460), 'json.dump', 'json.dump', (['schema_json', 'file'], {}), '(schema_json, file)\n', (1441, 1460), False, 'import json\n')] |
import asyncio
from functools import partial
from typing import (
Any,
List,
Mapping,
Optional,
)
from ai21.models import CompletionsResponse
from langchain_core.callbacks import (
AsyncCallbackManagerForLLMRun,
CallbackManagerForLLMRun,
)
from langchain_core.language_models import BaseLLM
from langchain_core.outputs import Generation, LLMResult
from langchain_ai21.ai21_base import AI21Base
class AI21LLM(BaseLLM, AI21Base):
"""AI21LLM large language models.
Example:
.. code-block:: python
from langchain_ai21 import AI21LLM
model = AI21LLM()
"""
model: str
"""Model type you wish to interact with.
You can view the options at https://github.com/AI21Labs/ai21-python?tab=readme-ov-file#model-types"""
num_results: int = 1
"""The number of responses to generate for a given prompt."""
max_tokens: int = 16
"""The maximum number of tokens to generate for each response."""
min_tokens: int = 0
"""The minimum number of tokens to generate for each response."""
temperature: float = 0.7
"""A value controlling the "creativity" of the model's responses."""
top_p: float = 1
"""A value controlling the diversity of the model's responses."""
top_k_return: int = 0
"""The number of top-scoring tokens to consider for each generation step."""
frequency_penalty: Optional[Any] = None
"""A penalty applied to tokens that are frequently generated."""
presence_penalty: Optional[Any] = None
""" A penalty applied to tokens that are already present in the prompt."""
count_penalty: Optional[Any] = None
"""A penalty applied to tokens based on their frequency
in the generated responses."""
custom_model: Optional[str] = None
epoch: Optional[int] = None
class Config:
"""Configuration for this pydantic object."""
allow_population_by_field_name = True
@property
def _llm_type(self) -> str:
"""Return type of LLM."""
return "ai21-llm"
@property
def _default_params(self) -> Mapping[str, Any]:
base_params = {
"model": self.model,
"num_results": self.num_results,
"max_tokens": self.max_tokens,
"min_tokens": self.min_tokens,
"temperature": self.temperature,
"top_p": self.top_p,
"top_k_return": self.top_k_return,
}
if self.count_penalty is not None:
base_params["count_penalty"] = self.count_penalty.to_dict()
if self.custom_model is not None:
base_params["custom_model"] = self.custom_model
if self.epoch is not None:
base_params["epoch"] = self.epoch
if self.frequency_penalty is not None:
base_params["frequency_penalty"] = self.frequency_penalty.to_dict()
if self.presence_penalty is not None:
base_params["presence_penalty"] = self.presence_penalty.to_dict()
return base_params
def _build_params_for_request(
self, stop: Optional[List[str]] = None, **kwargs: Any
) -> Mapping[str, Any]:
params = {}
if stop is not None:
if "stop" in kwargs:
raise ValueError("stop is defined in both stop and kwargs")
params["stop_sequences"] = stop
return {
**self._default_params,
**params,
**kwargs,
}
def _generate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[CallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
generations: List[List[Generation]] = []
token_count = 0
params = self._build_params_for_request(stop=stop, **kwargs)
for prompt in prompts:
response = self._invoke_completion(prompt=prompt, **params)
generation = self._response_to_generation(response)
generations.append(generation)
token_count += self.client.count_tokens(prompt)
llm_output = {"token_count": token_count, "model_name": self.model}
return LLMResult(generations=generations, llm_output=llm_output)
async def _agenerate(
self,
prompts: List[str],
stop: Optional[List[str]] = None,
run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
**kwargs: Any,
) -> LLMResult:
# Change implementation if integration natively supports async generation.
return await asyncio.get_running_loop().run_in_executor(
None, partial(self._generate, **kwargs), prompts, stop, run_manager
)
def _invoke_completion(
self,
prompt: str,
**kwargs: Any,
) -> CompletionsResponse:
return self.client.completion.create(
prompt=prompt,
**kwargs,
)
def _response_to_generation(
self, response: CompletionsResponse
) -> List[Generation]:
return [
Generation(
text=completion.data.text,
generation_info=completion.to_dict(),
)
for completion in response.completions
]
| [
"langchain_core.outputs.LLMResult"
] | [((4179, 4236), 'langchain_core.outputs.LLMResult', 'LLMResult', ([], {'generations': 'generations', 'llm_output': 'llm_output'}), '(generations=generations, llm_output=llm_output)\n', (4188, 4236), False, 'from langchain_core.outputs import Generation, LLMResult\n'), ((4626, 4659), 'functools.partial', 'partial', (['self._generate'], {}), '(self._generate, **kwargs)\n', (4633, 4659), False, 'from functools import partial\n'), ((4564, 4590), 'asyncio.get_running_loop', 'asyncio.get_running_loop', ([], {}), '()\n', (4588, 4590), False, 'import asyncio\n')] |
from langchain.llms import OpenAI
from callback import MyCallbackHandler
from langchain.callbacks.base import BaseCallbackManager
class QaLlm():
def __init__(self) -> None:
manager = BaseCallbackManager([MyCallbackHandler()])
self.llm = OpenAI(temperature=0, callback_manager=manager, model_name="gpt-3.5-turbo")
def get_llm(self):
return self.llm | [
"langchain.llms.OpenAI"
] | [((259, 334), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'callback_manager': 'manager', 'model_name': '"""gpt-3.5-turbo"""'}), "(temperature=0, callback_manager=manager, model_name='gpt-3.5-turbo')\n", (265, 334), False, 'from langchain.llms import OpenAI\n'), ((218, 237), 'callback.MyCallbackHandler', 'MyCallbackHandler', ([], {}), '()\n', (235, 237), False, 'from callback import MyCallbackHandler\n')] |
from langchain.llms import OpenAI
from langchain.chat_models import ChatOpenAI
from apikey import (
apikey,
google_search,
google_cse,
serp,
aws_access_key,
aws_secret_key,
aws_region,
)
import os
from typing import Dict
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory
from langchain.utilities import GoogleSearchAPIWrapper
os.environ["OPENAI_API_KEY"] = apikey
os.environ["GOOGLE_API_KEY"] = google_search
os.environ["GOOGLE_CSE_ID"] = google_cse
os.environ["SERPAPI_API_KEY"] = serp
os.environ["AWS_ACCESS_KEY_ID"] = aws_access_key
os.environ["AWS_SECRET_ACCESS_KEY"] = aws_secret_key
os.environ["AWS_DEFAULT_REGION"] = aws_region
# LLMs
llm = OpenAI(temperature=0.3, max_tokens=100, model_name="text-davinci-003")
# Memory
conv_memory = ConversationBufferMemory()
# Prompt template for LLM
script_template = PromptTemplate(
input_variables=["topic", "google_search"],
template="Write me a YouTube voiceover script about {topic}, and also do research about the topic on Google. {google_search}",
)
adjust_template = PromptTemplate(
input_variables=["script"],
template="Edit, and adjust the script in a fun, relaxed way: {script}\n\n-=-=-=- Adjusted Script -=-=-=-",
)
# Add a new prompt template for further adjustments
refine_template = PromptTemplate(
input_variables=[
"script",
"adjusted_script",
],
template="Refine the adjusted script staying on topic to make it more charismatic:\n{script}\n\n-=-=-=- Adjusted Script -=-=-=-\n{adjusted_script}\n\n-=-=-=- Refined Script -=-=-=-",
)
# LLM Chains
script_chain = LLMChain(
llm=llm, prompt=script_template, verbose=True, output_key="script"
)
adjust_chain = LLMChain(
llm=llm, prompt=adjust_template, verbose=True, output_key="adjusted_script"
)
refine_chain = LLMChain(
llm=llm, prompt=refine_template, verbose=True, output_key="refined_script"
)
search = GoogleSearchAPIWrapper()
def run_all_chains(prompt: str, google_search_result: str) -> Dict[str, str]:
script = script_chain({"topic": prompt, "google_search": google_search_result})
conv_memory.save_context(
{"topic": prompt}, {"script": script[script_chain.output_key]}
)
adjust = adjust_chain({"script": script[script_chain.output_key]})
conv_memory.save_context(
{"script": script[script_chain.output_key]},
{"adjusted_script": adjust[adjust_chain.output_key]},
)
adjust_output = adjust[adjust_chain.output_key]
adjusted_script = adjust_output.split("-=-=-=- Adjusted Script -=-=-=-")[-1].strip()
refine = refine_chain(
{
"script": script[script_chain.output_key],
"adjusted_script": adjust[adjust_chain.output_key],
}
)
conv_memory.save_context(
{"adjusted_script": adjust[adjust_chain.output_key]},
{"refined_script": refine[refine_chain.output_key]},
)
refine_output = refine[refine_chain.output_key]
refined_script = refine_output.split("-=-=-=- Refined Script -=-=-=-")[-1].strip()
return {
"script": script[script_chain.output_key],
"adjusted_script": adjusted_script,
"refined_script": refined_script,
}
| [
"langchain.memory.ConversationBufferMemory",
"langchain.llms.OpenAI",
"langchain.chains.LLMChain",
"langchain.utilities.GoogleSearchAPIWrapper",
"langchain.prompts.PromptTemplate"
] | [((765, 835), 'langchain.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0.3)', 'max_tokens': '(100)', 'model_name': '"""text-davinci-003"""'}), "(temperature=0.3, max_tokens=100, model_name='text-davinci-003')\n", (771, 835), False, 'from langchain.llms import OpenAI\n'), ((860, 886), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {}), '()\n', (884, 886), False, 'from langchain.memory import ConversationBufferMemory\n'), ((933, 1128), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['topic', 'google_search']", 'template': '"""Write me a YouTube voiceover script about {topic}, and also do research about the topic on Google. {google_search}"""'}), "(input_variables=['topic', 'google_search'], template=\n 'Write me a YouTube voiceover script about {topic}, and also do research about the topic on Google. {google_search}'\n )\n", (947, 1128), False, 'from langchain.prompts import PromptTemplate\n'), ((1149, 1310), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['script']", 'template': '"""Edit, and adjust the script in a fun, relaxed way: {script}\n\n-=-=-=- Adjusted Script -=-=-=-"""'}), '(input_variables=[\'script\'], template=\n """Edit, and adjust the script in a fun, relaxed way: {script}\n\n-=-=-=- Adjusted Script -=-=-=-"""\n )\n', (1163, 1310), False, 'from langchain.prompts import PromptTemplate\n'), ((1381, 1633), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['script', 'adjusted_script']", 'template': '"""Refine the adjusted script staying on topic to make it more charismatic:\n{script}\n\n-=-=-=- Adjusted Script -=-=-=-\n{adjusted_script}\n\n-=-=-=- Refined Script -=-=-=-"""'}), '(input_variables=[\'script\', \'adjusted_script\'], template=\n """Refine the adjusted script staying on topic to make it more charismatic:\n{script}\n\n-=-=-=- Adjusted Script -=-=-=-\n{adjusted_script}\n\n-=-=-=- Refined Script -=-=-=-"""\n )\n', (1395, 1633), False, 'from langchain.prompts import PromptTemplate\n'), ((1689, 1765), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'script_template', 'verbose': '(True)', 'output_key': '"""script"""'}), "(llm=llm, prompt=script_template, verbose=True, output_key='script')\n", (1697, 1765), False, 'from langchain.chains import LLMChain\n'), ((1787, 1877), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'adjust_template', 'verbose': '(True)', 'output_key': '"""adjusted_script"""'}), "(llm=llm, prompt=adjust_template, verbose=True, output_key=\n 'adjusted_script')\n", (1795, 1877), False, 'from langchain.chains import LLMChain\n'), ((1894, 1983), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'refine_template', 'verbose': '(True)', 'output_key': '"""refined_script"""'}), "(llm=llm, prompt=refine_template, verbose=True, output_key=\n 'refined_script')\n", (1902, 1983), False, 'from langchain.chains import LLMChain\n'), ((1995, 2019), 'langchain.utilities.GoogleSearchAPIWrapper', 'GoogleSearchAPIWrapper', ([], {}), '()\n', (2017, 2019), False, 'from langchain.utilities import GoogleSearchAPIWrapper\n')] |
"""
DATE: 2023/5/28
AUTHOR: ZLYANG
CONTACT: [email protected]
"""
### define tools ###
import requests
import io
import base64
import os
from PIL import Image
from typing import Optional
from langchain.tools import BaseTool
from langchain.callbacks.manager import (
AsyncCallbackManagerForToolRun,
CallbackManagerForToolRun,
)
from langchain import LLMChain, PromptTemplate
from langchain.base_language import BaseLanguageModel
import re, random
from hashlib import md5
# translation from baidu api
def translate_to_en(text, appid, appkey):
url = "http://api.fanyi.baidu.com/api/trans/vip/translate"
def make_md5(s, encoding='utf-8'):
return md5(s.encode(encoding)).hexdigest()
salt = random.randint(32768, 65536)
sign = make_md5(appid + text + str(salt) + appkey)
headers = {"Content-Type": "application/x-www-form-urlencoded"}
params = {
"appid": appid,
"q": text,
"from": "zh",
"to": "en",
"salt": salt,
"sign": sign
}
r = requests.post(url, params=params, headers=headers).json()
result = r["trans_result"][0]["dst"]
return result
# base api tool #
class APITool(BaseTool):
name: str = ""
description: str = ""
url: str = ""
def _call_api(self, query):
raise NotImplementedError("subclass needs to overwrite this method")
def _run(
self,
query: str,
run_manager: Optional[CallbackManagerForToolRun] = None,
) -> str:
return self._call_api(query)
async def _arun(
self,
query: str,
run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
) -> str:
raise NotImplementedError("APITool does not support async")
# search tool #
class SearchTool(APITool):
llm: BaseLanguageModel
# tool description
name = "搜索问答"
description = "根据用户问题搜索最新的结果，并返回Json格式的结果"
# search params
google_api_key: str
google_cse_id: str
url = "https://www.googleapis.com/customsearch/v1"
top_k = 5
# QA params
qa_template = """
请根据下面带```分隔符的文本来回答问题。
如果该文本中没有相关内容可以回答问题，请直接回复：“抱歉，该问题需要更多上下文信息。”
```{text}```
问题：{query}
"""
prompt = PromptTemplate.from_template(qa_template)
llm_chain: LLMChain = None
def _call_api(self, query) -> str:
self.get_llm_chain()
context = self.get_search_result(query)
resp = self.llm_chain.predict(text=context, query=query)
return resp
def get_search_result(self, query):
data = {"key": self.google_api_key,
"cx": self.google_cse_id,
"q": query,
"lr": "lang_zh-CN"}
results = requests.get(self.url, params=data).json()
results = results.get("items", [])[:self.top_k]
snippets = []
if len(results) == 0:
return("No Search Result was found")
for result in results:
text = ""
if "title" in result:
text += result["title"] + "。"
if "snippet" in result:
text += result["snippet"]
snippets.append(text)
return("\n\n".join(snippets))
def get_llm_chain(self):
if not self.llm_chain:
self.llm_chain = LLMChain(llm=self.llm, prompt=self.prompt)
# draw tool #
class DrawTool(APITool):
# tool description
name = "绘画"
description = "根据用户描述调用api画图"
# stable diffusion api
baidu_appid: str
baidu_appkey: str
url = "http://127.0.0.1:7860/sdapi/v1/txt2img"
def _call_api(self, query) -> str:
img_path = self.get_response(query)
return f"图片保存在{img_path}下"
def get_response(self, query):
draw_prompt = translate_to_en(query, self.baidu_appid, self.baidu_appkey)
draw_prompt += ",traditional chinese ink painting,peaceful"
negative_prompt = "(worst quality:2), (low quality:2), (normal quality:2), lowres, normal quality, skin spots, acnes, skin blemishes, age spot, glans, (watermark:2)"
img_path = "output/images/"
payload = {
"prompt": draw_prompt,
"steps": 30,
"width": 640,
"height": 1024,
"negative_prompt": negative_prompt,
"sampler_index": "DPM++ SDE Karras",
"cfg_scale": 3.5
}
response = requests.post(url=self.url, json=payload)
r = response.json()
for i, img in enumerate(r["images"]):
image = Image.open(io.BytesIO(base64.b64decode(img.split(",", 1)[0])))
image.save(img_path + f"output_{i}.png")
return img_path
# audio tool #
class AudioTool(APITool):
# tool description
name = "语音"
description = "根据用户的输入描述，将一定格式下的文本内容转成语音"
# Chinese-FastSpeech2
url = "http://127.0.0.1:5876/TextToSpeech"
def _call_api(self, query) -> str:
res = re.search(r"<.+>", query)
if res:
speech_text = res.group()[1:-1]
save_path = "./output/audios/"
save_path = os.path.abspath(save_path)
payload = {
"text": speech_text,
"save_path": save_path
}
res = requests.post(self.url, payload).json()
audio_path = res["result"]
return f"图片保存在{audio_path}下"
else:
print("转语音的文本要按格式输入，用<>括起来！")
| [
"langchain.LLMChain",
"langchain.PromptTemplate.from_template"
] | [((757, 785), 'random.randint', 'random.randint', (['(32768)', '(65536)'], {}), '(32768, 65536)\n', (771, 785), False, 'import re, random\n'), ((2323, 2364), 'langchain.PromptTemplate.from_template', 'PromptTemplate.from_template', (['qa_template'], {}), '(qa_template)\n', (2351, 2364), False, 'from langchain import LLMChain, PromptTemplate\n'), ((4527, 4568), 'requests.post', 'requests.post', ([], {'url': 'self.url', 'json': 'payload'}), '(url=self.url, json=payload)\n', (4540, 4568), False, 'import requests\n'), ((5077, 5101), 're.search', 're.search', (['"""<.+>"""', 'query'], {}), "('<.+>', query)\n", (5086, 5101), False, 'import re, random\n'), ((1077, 1127), 'requests.post', 'requests.post', (['url'], {'params': 'params', 'headers': 'headers'}), '(url, params=params, headers=headers)\n', (1090, 1127), False, 'import requests\n'), ((3410, 3452), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'self.llm', 'prompt': 'self.prompt'}), '(llm=self.llm, prompt=self.prompt)\n', (3418, 3452), False, 'from langchain import LLMChain, PromptTemplate\n'), ((5234, 5260), 'os.path.abspath', 'os.path.abspath', (['save_path'], {}), '(save_path)\n', (5249, 5260), False, 'import os\n'), ((2821, 2856), 'requests.get', 'requests.get', (['self.url'], {'params': 'data'}), '(self.url, params=data)\n', (2833, 2856), False, 'import requests\n'), ((5400, 5432), 'requests.post', 'requests.post', (['self.url', 'payload'], {}), '(self.url, payload)\n', (5413, 5432), False, 'import requests\n')] |
from langchain.retrievers import AmazonKendraRetriever
from langchain.chains import ConversationalRetrievalChain
from langchain import SagemakerEndpoint
from langchain.llms.sagemaker_endpoint import LLMContentHandler
from langchain.prompts import PromptTemplate
import sys
import json
import os
class bcolors:
HEADER = "\033[95m"
OKBLUE = "\033[94m"
OKCYAN = "\033[96m"
OKGREEN = "\033[92m"
WARNING = "\033[93m"
FAIL = "\033[91m"
ENDC = "\033[0m"
BOLD = "\033[1m"
UNDERLINE = "\033[4m"
MAX_HISTORY_LENGTH = 5
def build_chain():
region = os.environ["AWS_REGION"]
kendra_index_id = os.environ["KENDRA_INDEX_ID"]
endpoint_name = os.environ["FALCON_40B_ENDPOINT"]
language_code = os.environ["LANGUAGE_CODE"]
class ContentHandler(LLMContentHandler):
content_type = "application/json"
accepts = "application/json"
def transform_input(self, prompt: str, model_kwargs: dict) -> bytes:
input_str = json.dumps({"inputs": prompt, "parameters": model_kwargs})
return input_str.encode("utf-8")
def transform_output(self, output: bytes) -> str:
response_json = json.loads(output.read().decode("utf-8"))
return response_json[0]["generated_text"]
content_handler = ContentHandler()
llm = SagemakerEndpoint(
endpoint_name=endpoint_name,
region_name=region,
model_kwargs={
"temperature": 0.8,
"max_new_tokens": 512,
"do_sample": True,
"top_p": 0.9,
"repetition_penalty": 1.03,
"stop": ["\nUser:", "<|endoftext|>", "</s>"],
},
content_handler=content_handler,
)
retriever = AmazonKendraRetriever(
index_id=kendra_index_id,
region_name=region,
top_k=1,
attribute_filter={
"EqualsTo": {
"Key": "_language_code",
"Value": {"StringValue": language_code},
}
},
)
prompt_template = """
システム: システムは資料から抜粋して質問に答えます。資料にない内容には答えず、正直に「わかりません」と答えます。
{context}
上記の資料に基づいて以下の質問について資料から抜粋して回答を生成します。資料にない内容には答えず「わかりません」と答えます。
ユーザー: {question}
システム:
"""
PROMPT = PromptTemplate(
template=prompt_template, input_variables=["context", "question"]
)
condense_qa_template = """
次のような会話とフォローアップの質問に基づいて、フォローアップの質問を独立した質問に言い換えてください。
フォローアップの質問: {question}
独立した質問:"""
standalone_question_prompt = PromptTemplate.from_template(condense_qa_template)
qa = ConversationalRetrievalChain.from_llm(
llm=llm,
retriever=retriever,
condense_question_prompt=standalone_question_prompt,
return_source_documents=True,
verbose=True,
combine_docs_chain_kwargs={"prompt": PROMPT},
)
return qa
def run_chain(chain, prompt: str, history=[]):
return chain({"question": prompt, "chat_history": history})
if __name__ == "__main__":
chat_history = []
qa = build_chain()
print(bcolors.OKBLUE + "Hello! How can I help you?" + bcolors.ENDC)
print(
bcolors.OKCYAN
+ "Ask a question, start a New search: or CTRL-D to exit."
+ bcolors.ENDC
)
print(">", end=" ", flush=True)
for query in sys.stdin:
if query.strip().lower().startswith("new search:"):
query = query.strip().lower().replace("new search:", "")
chat_history = []
elif len(chat_history) == MAX_HISTORY_LENGTH:
chat_history.pop(0)
result = run_chain(qa, query, chat_history)
chat_history.append((query, result["answer"]))
print(bcolors.OKGREEN + result["answer"] + bcolors.ENDC)
if "source_documents" in result:
print(bcolors.OKGREEN + "Sources:")
for d in result["source_documents"]:
print(d.metadata["source"])
print(bcolors.ENDC)
print(
bcolors.OKCYAN
+ "Ask a question, start a New search: or CTRL-D to exit."
+ bcolors.ENDC
)
print(">", end=" ", flush=True)
print(bcolors.OKBLUE + "Bye" + bcolors.ENDC)
| [
"langchain.SagemakerEndpoint",
"langchain.chains.ConversationalRetrievalChain.from_llm",
"langchain.retrievers.AmazonKendraRetriever",
"langchain.prompts.PromptTemplate.from_template",
"langchain.prompts.PromptTemplate"
] | [((1327, 1604), 'langchain.SagemakerEndpoint', 'SagemakerEndpoint', ([], {'endpoint_name': 'endpoint_name', 'region_name': 'region', 'model_kwargs': "{'temperature': 0.8, 'max_new_tokens': 512, 'do_sample': True, 'top_p': 0.9,\n 'repetition_penalty': 1.03, 'stop': ['\\nUser:', '<|endoftext|>', '</s>']}", 'content_handler': 'content_handler'}), "(endpoint_name=endpoint_name, region_name=region,\n model_kwargs={'temperature': 0.8, 'max_new_tokens': 512, 'do_sample': \n True, 'top_p': 0.9, 'repetition_penalty': 1.03, 'stop': ['\\nUser:',\n '<|endoftext|>', '</s>']}, content_handler=content_handler)\n", (1344, 1604), False, 'from langchain import SagemakerEndpoint\n'), ((1731, 1915), 'langchain.retrievers.AmazonKendraRetriever', 'AmazonKendraRetriever', ([], {'index_id': 'kendra_index_id', 'region_name': 'region', 'top_k': '(1)', 'attribute_filter': "{'EqualsTo': {'Key': '_language_code', 'Value': {'StringValue': language_code}}\n }"}), "(index_id=kendra_index_id, region_name=region, top_k=1,\n attribute_filter={'EqualsTo': {'Key': '_language_code', 'Value': {\n 'StringValue': language_code}}})\n", (1752, 1915), False, 'from langchain.retrievers import AmazonKendraRetriever\n'), ((2227, 2312), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'prompt_template', 'input_variables': "['context', 'question']"}), "(template=prompt_template, input_variables=['context',\n 'question'])\n", (2241, 2312), False, 'from langchain.prompts import PromptTemplate\n'), ((2482, 2532), 'langchain.prompts.PromptTemplate.from_template', 'PromptTemplate.from_template', (['condense_qa_template'], {}), '(condense_qa_template)\n', (2510, 2532), False, 'from langchain.prompts import PromptTemplate\n'), ((2543, 2766), 'langchain.chains.ConversationalRetrievalChain.from_llm', 'ConversationalRetrievalChain.from_llm', ([], {'llm': 'llm', 'retriever': 'retriever', 'condense_question_prompt': 'standalone_question_prompt', 'return_source_documents': '(True)', 'verbose': '(True)', 'combine_docs_chain_kwargs': "{'prompt': PROMPT}"}), "(llm=llm, retriever=retriever,\n condense_question_prompt=standalone_question_prompt,\n return_source_documents=True, verbose=True, combine_docs_chain_kwargs={\n 'prompt': PROMPT})\n", (2580, 2766), False, 'from langchain.chains import ConversationalRetrievalChain\n'), ((989, 1047), 'json.dumps', 'json.dumps', (["{'inputs': prompt, 'parameters': model_kwargs}"], {}), "({'inputs': prompt, 'parameters': model_kwargs})\n", (999, 1047), False, 'import json\n')] |
#Make sure to install the following packages: dlt, langchain, duckdb, python-dotenv, openai, weaviate-client
import dlt
from langchain import PromptTemplate, LLMChain
from langchain.chains.openai_functions import create_structured_output_chain
from langchain.chat_models import ChatOpenAI
from langchain.document_loaders import PyPDFLoader
import weaviate
import os
import json
import argparse
from langchain.embeddings import OpenAIEmbeddings
from langchain.prompts import HumanMessagePromptTemplate, ChatPromptTemplate
from langchain.retrievers import WeaviateHybridSearchRetriever
from langchain.schema import Document, SystemMessage, HumanMessage
from langchain.vectorstores import Weaviate
import uuid
from dotenv import load_dotenv
load_dotenv()
from pathlib import Path
from langchain import OpenAI, LLMMathChain
import os
embeddings = OpenAIEmbeddings()
from deep_translator import (GoogleTranslator)
def _convert_pdf_to_document(path: str = None):
"""Convert a PDF document to a Document object"""
if path is None:
raise ValueError("A valid path to the document must be provided.")
loader = PyPDFLoader(path)
pages = loader.load_and_split()
print("PAGES", pages[0])
# Parse metadata from the folder path
path_parts = Path(path).parts
personal_receipts_index = path_parts.index("personal_receipts")
metadata_parts = path_parts[personal_receipts_index+1:]
documents = []
for page in pages:
translation = GoogleTranslator(source='auto', target='en').translate(text=page.page_content)
documents.append(
Document(
metadata={
"title": "Personal Receipt",
"country": metadata_parts[1],
"year": metadata_parts[0],
"author": str(uuid.uuid4()),
"source": "/".join(metadata_parts),
},
page_content=translation,
)
)
print(documents)
return documents
def _init_weaviate():
"""Initialize weaviate client and retriever"""
auth_config = weaviate.auth.AuthApiKey(api_key=os.environ.get('WEAVIATE_API_KEY'))
client = weaviate.Client(
url='https://my-vev-index-o4qitptw.weaviate.network',
auth_client_secret=auth_config,
additional_headers={
"X-OpenAI-Api-Key": os.environ.get('OPENAI_API_KEY')
}
)
retriever = WeaviateHybridSearchRetriever(
client=client,
index_name="PDFloader",
text_key="text",
attributes=[],
embedding=embeddings,
create_schema_if_missing=True,
)
return retriever
def load_to_weaviate(document_path=None):
"""Load documents to weaviate"""
retriever =_init_weaviate()
docs = _convert_pdf_to_document(document_path)
return retriever.add_documents(docs)
def get_from_weaviate(query=None, path=None, operator=None, valueText=None):
"""
Get documents from weaviate.
Args:
query (str): The query string.
path (list): The path for filtering, e.g., ['year'].
operator (str): The operator for filtering, e.g., 'Equal'.
valueText (str): The value for filtering, e.g., '2017*'.
Example:
get_from_weaviate(query="some query", path=['year'], operator='Equal', valueText='2017*')
"""
retriever = _init_weaviate()
# Initial retrieval without filters
output = retriever.get_relevant_documents(
query,
score=True,
)
# Apply filters if provided
if path or operator or valueText:
# Create the where_filter based on provided parameters
where_filter = {
'path': path if path else [],
'operator': operator if operator else '',
'valueText': valueText if valueText else ''
}
# Retrieve documents with filters applied
output = retriever.get_relevant_documents(
query,
score=True,
where_filter=where_filter
)
return output
def delete_from_weaviate(query=None, filters=None):
"""Delete documents from weaviate, pass dict as filters"""
""" {
'path': ['year'],
'operator': 'Equal',
'valueText': '2017*' }"""
auth_config = weaviate.auth.AuthApiKey(api_key=os.environ.get('WEAVIATE_API_KEY'))
client = weaviate.Client(
url='https://my-vev-index-o4qitptw.weaviate.network',
auth_client_secret=auth_config,
additional_headers={
"X-OpenAI-Api-Key": os.environ.get('OPENAI_API_KEY')
}
)
client.batch.delete_objects(
class_name='PDFloader',
# Same `where` filter as in the GraphQL API
where={
'path': ['year'],
'operator': 'Equal',
'valueText': '2017*'
},
)
return "Success"
llm = ChatOpenAI(
temperature=0.0,
max_tokens=1200,
openai_api_key=os.environ.get('OPENAI_API_KEY'),
model_name="gpt-4-0613",
)
def infer_schema_from_text(text: str):
"""Infer schema from text"""
prompt_ = """ You are a json schema master. Create a JSON schema based on the following data and don't write anything else: {prompt} """
complete_query = PromptTemplate(
input_variables=["prompt"],
template=prompt_,
)
chain = LLMChain(
llm=llm, prompt=complete_query, verbose=True
)
chain_result = chain.run(prompt=text).strip()
json_data = json.dumps(chain_result)
return json_data
def set_data_contract(data, version, date, agreement_id=None, privacy_policy=None, terms_of_service=None, format=None, schema_version=None, checksum=None, owner=None, license=None, validity_start=None, validity_end=None):
# Creating the generic data contract
data_contract = {
"version": version or "",
"date": date or "",
"agreement_id": agreement_id or "",
"privacy_policy": privacy_policy or "",
"terms_of_service": terms_of_service or "",
"format": format or "",
"schema_version": schema_version or "",
"checksum": checksum or "",
"owner": owner or "",
"license": license or "",
"validity_start": validity_start or "",
"validity_end": validity_end or "",
"properties": data # Adding the given data under the "properties" field
}
return data_contract
def create_id_dict(memory_id=None, st_memory_id=None, buffer_id=None):
"""
Create a dictionary containing IDs for memory, st_memory, and buffer.
Args:
memory_id (str): The Memory ID.
st_memory_id (str): The St_memory ID.
buffer_id (str): The Buffer ID.
Returns:
dict: A dictionary containing the IDs.
"""
id_dict = {
"memoryID": memory_id or "",
"st_MemoryID": st_memory_id or "",
"bufferID": buffer_id or ""
}
return id_dict
def init_buffer(data, version, date, memory_id=None, st_memory_id=None, buffer_id=None, agreement_id=None, privacy_policy=None, terms_of_service=None, format=None, schema_version=None, checksum=None, owner=None, license=None, validity_start=None, validity_end=None, text=None, process=None):
# Create ID dictionary
id_dict = create_id_dict(memory_id, st_memory_id, buffer_id)
# Set data contract
data_contract = set_data_contract(data, version, date, agreement_id, privacy_policy, terms_of_service, format, schema_version, checksum, owner, license, validity_start, validity_end)
# Add ID dictionary to properties
data_contract["properties"]["relations"] = id_dict
# Infer schema from text and add to properties
if text:
schema = infer_schema_from_text(text)
data_contract["properties"]["schema"] = schema
if process:
data_contract["properties"]["process"] = process
return data_contract
def infer_properties_from_text(text: str):
"""Infer schema properties from text"""
prompt_ = """ You are a json index master. Create a short JSON index containing the most important data and don't write anything else: {prompt} """
complete_query = PromptTemplate(
input_variables=["prompt"],
template=prompt_,
)
chain = LLMChain(
llm=llm, prompt=complete_query, verbose=True
)
chain_result = chain.run(prompt=text).strip()
# json_data = json.dumps(chain_result)
return chain_result
#
#
# # print(infer_schema_from_text(output[0].page_content))
def load_json_or_infer_schema(file_path, document_path):
"""Load JSON schema from file or infer schema from text"""
try:
# Attempt to load the JSON file
with open(file_path, 'r') as file:
json_schema = json.load(file)
return json_schema
except FileNotFoundError:
# If the file doesn't exist, run the specified function
output = _convert_pdf_to_document(path=document_path)
json_schema = infer_schema_from_text(output[0].page_content)
return json_schema
def ai_function(prompt=None, json_schema=None):
"""AI function to convert unstructured data to structured data"""
# Here we define the user prompt and the structure of the output we desire
# prompt = output[0].page_content
prompt_msgs = [
SystemMessage(
content="You are a world class algorithm converting unstructured data into structured data."
),
HumanMessage(content="Convert unstructured data to structured data:"),
HumanMessagePromptTemplate.from_template("{input}"),
HumanMessage(content="Tips: Make sure to answer in the correct format"),
]
prompt_ = ChatPromptTemplate(messages=prompt_msgs)
chain = create_structured_output_chain(json_schema , prompt=prompt_, llm=llm, verbose=True)
output = chain.run(input = prompt, llm=llm)
yield output
# Define a base directory if you have one; this could be the directory where your script is located
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
def higher_level_thinking():
"""Higher level thinking function to calculate the sum of the price of the tickets from these documents"""
docs_data = get_from_weaviate(query="Train", path=['year'], operator='Equal', valueText='2017*')
str_docs_data = str(docs_data)
llm_math = LLMMathChain.from_llm(llm, verbose=True)
output = llm_math.run(f"Calculate the sum of the price of the tickets from these documents: {str_docs_data}")
# data_format = init_buffer(data=output, version="0.0.1", date="2021-09-01")
yield output
result_higher_level_thinking = higher_level_thinking()
def process_higher_level_thinking(result=None):
data_format = init_buffer(data=result, version="0.0.1", date="2021-09-01")
import json
data_format=json.dumps(data_format)
yield data_format
document_paths = [
os.path.join(BASE_DIR, "personal_receipts", "2017", "de", "public_transport", "3ZCCCW.pdf"),
os.path.join(BASE_DIR, "personal_receipts", "2017", "de", "public_transport", "4GBEC9.pdf")
]
def main(raw_loading, processed_loading,document_paths):
BASE_DIR = os.getcwd() # Assuming the current working directory is where the data_processing_script.py is located
def format_document_paths(base_dir, path):
# Split the input path and extract the elements
elements = path.strip("/").split("/")
# Construct the document_paths list
document_paths = [os.path.join(base_dir, *elements)]
return document_paths
document_paths_ =[format_document_paths(BASE_DIR, path) for path in document_paths][0]
print(document_paths)
if raw_loading:
for document in document_paths_:
file_path = os.path.join(BASE_DIR, "ticket_schema.json")
json_schema = load_json_or_infer_schema(file_path, document)
output = _convert_pdf_to_document(path=document)
find_data_in_store = get_from_weaviate(query="Train", path=['year'], operator='Equal', valueText='2017*')
if find_data_in_store:
output = find_data_in_store
print(output[1])
else:
load_to_weaviate(document)
pipeline = dlt.pipeline(pipeline_name="train_ticket", destination='duckdb', dataset_name='train_ticket_data')
info = pipeline.run(data=ai_function(output[0].page_content, json_schema))
print(info)
elif processed_loading:
pipeline_processed = dlt.pipeline(pipeline_name="train_ticket_processed", destination='duckdb',
dataset_name='train_ticket_processed_data')
info = pipeline_processed.run(data=higher_level_thinking())
print(info)
else:
print("Please specify either '--raw_loading' or '--processed_loading' option.")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Data Processing Script")
parser.add_argument("--raw_loading", action="store_true", help="Load raw document data and perform AI tasks")
parser.add_argument("--processed_loading", action="store_true",
help="Load processed data and run higher-level thinking AI function")
parser.add_argument("document_paths", nargs="*", help="Paths to the documents to process")
args = parser.parse_args()
main(args.raw_loading, args.processed_loading, args.document_paths)
#to run: python3 level_1_pdf_vectorstore_dlt_etl.py --raw_loading "/personal_receipts/2017/de/public_transport/3ZCCCW.pdf"
| [
"langchain.LLMChain",
"langchain.chains.openai_functions.create_structured_output_chain",
"langchain.prompts.HumanMessagePromptTemplate.from_template",
"langchain.retrievers.WeaviateHybridSearchRetriever",
"langchain.LLMMathChain.from_llm",
"langchain.schema.HumanMessage",
"langchain.schema.SystemMessage",
"langchain.prompts.ChatPromptTemplate",
"langchain.document_loaders.PyPDFLoader",
"langchain.embeddings.OpenAIEmbeddings",
"langchain.PromptTemplate"
] | [((741, 754), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (752, 754), False, 'from dotenv import load_dotenv\n'), ((848, 866), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (864, 866), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((1129, 1146), 'langchain.document_loaders.PyPDFLoader', 'PyPDFLoader', (['path'], {}), '(path)\n', (1140, 1146), False, 'from langchain.document_loaders import PyPDFLoader\n'), ((2438, 2599), 'langchain.retrievers.WeaviateHybridSearchRetriever', 'WeaviateHybridSearchRetriever', ([], {'client': 'client', 'index_name': '"""PDFloader"""', 'text_key': '"""text"""', 'attributes': '[]', 'embedding': 'embeddings', 'create_schema_if_missing': '(True)'}), "(client=client, index_name='PDFloader',\n text_key='text', attributes=[], embedding=embeddings,\n create_schema_if_missing=True)\n", (2467, 2599), False, 'from langchain.retrievers import WeaviateHybridSearchRetriever\n'), ((5296, 5356), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['prompt']", 'template': 'prompt_'}), "(input_variables=['prompt'], template=prompt_)\n", (5310, 5356), False, 'from langchain import PromptTemplate, LLMChain\n'), ((5381, 5435), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'complete_query', 'verbose': '(True)'}), '(llm=llm, prompt=complete_query, verbose=True)\n', (5389, 5435), False, 'from langchain import PromptTemplate, LLMChain\n'), ((5517, 5541), 'json.dumps', 'json.dumps', (['chain_result'], {}), '(chain_result)\n', (5527, 5541), False, 'import json\n'), ((8185, 8245), 'langchain.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['prompt']", 'template': 'prompt_'}), "(input_variables=['prompt'], template=prompt_)\n", (8199, 8245), False, 'from langchain import PromptTemplate, LLMChain\n'), ((8270, 8324), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'complete_query', 'verbose': '(True)'}), '(llm=llm, prompt=complete_query, verbose=True)\n', (8278, 8324), False, 'from langchain import PromptTemplate, LLMChain\n'), ((9693, 9733), 'langchain.prompts.ChatPromptTemplate', 'ChatPromptTemplate', ([], {'messages': 'prompt_msgs'}), '(messages=prompt_msgs)\n', (9711, 9733), False, 'from langchain.prompts import HumanMessagePromptTemplate, ChatPromptTemplate\n'), ((9746, 9832), 'langchain.chains.openai_functions.create_structured_output_chain', 'create_structured_output_chain', (['json_schema'], {'prompt': 'prompt_', 'llm': 'llm', 'verbose': '(True)'}), '(json_schema, prompt=prompt_, llm=llm,\n verbose=True)\n', (9776, 9832), False, 'from langchain.chains.openai_functions import create_structured_output_chain\n'), ((10024, 10049), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (10039, 10049), False, 'import os\n'), ((10347, 10387), 'langchain.LLMMathChain.from_llm', 'LLMMathChain.from_llm', (['llm'], {'verbose': '(True)'}), '(llm, verbose=True)\n', (10368, 10387), False, 'from langchain import OpenAI, LLMMathChain\n'), ((10815, 10838), 'json.dumps', 'json.dumps', (['data_format'], {}), '(data_format)\n', (10825, 10838), False, 'import json\n'), ((10885, 10980), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""personal_receipts"""', '"""2017"""', '"""de"""', '"""public_transport"""', '"""3ZCCCW.pdf"""'], {}), "(BASE_DIR, 'personal_receipts', '2017', 'de',\n 'public_transport', '3ZCCCW.pdf')\n", (10897, 10980), False, 'import os\n'), ((10982, 11077), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""personal_receipts"""', '"""2017"""', '"""de"""', '"""public_transport"""', '"""4GBEC9.pdf"""'], {}), "(BASE_DIR, 'personal_receipts', '2017', 'de',\n 'public_transport', '4GBEC9.pdf')\n", (10994, 11077), False, 'import os\n'), ((11151, 11162), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (11160, 11162), False, 'import os\n'), ((12901, 12962), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Data Processing Script"""'}), "(description='Data Processing Script')\n", (12924, 12962), False, 'import argparse\n'), ((1273, 1283), 'pathlib.Path', 'Path', (['path'], {}), '(path)\n', (1277, 1283), False, 'from pathlib import Path\n'), ((4976, 5008), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (4990, 5008), False, 'import os\n'), ((9321, 9438), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': '"""You are a world class algorithm converting unstructured data into structured data."""'}), "(content=\n 'You are a world class algorithm converting unstructured data into structured data.'\n )\n", (9334, 9438), False, 'from langchain.schema import Document, SystemMessage, HumanMessage\n'), ((9460, 9529), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': '"""Convert unstructured data to structured data:"""'}), "(content='Convert unstructured data to structured data:')\n", (9472, 9529), False, 'from langchain.schema import Document, SystemMessage, HumanMessage\n'), ((9539, 9590), 'langchain.prompts.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['"""{input}"""'], {}), "('{input}')\n", (9579, 9590), False, 'from langchain.prompts import HumanMessagePromptTemplate, ChatPromptTemplate\n'), ((9600, 9671), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': '"""Tips: Make sure to answer in the correct format"""'}), "(content='Tips: Make sure to answer in the correct format')\n", (9612, 9671), False, 'from langchain.schema import Document, SystemMessage, HumanMessage\n'), ((2143, 2177), 'os.environ.get', 'os.environ.get', (['"""WEAVIATE_API_KEY"""'], {}), "('WEAVIATE_API_KEY')\n", (2157, 2177), False, 'import os\n'), ((4324, 4358), 'os.environ.get', 'os.environ.get', (['"""WEAVIATE_API_KEY"""'], {}), "('WEAVIATE_API_KEY')\n", (4338, 4358), False, 'import os\n'), ((8758, 8773), 'json.load', 'json.load', (['file'], {}), '(file)\n', (8767, 8773), False, 'import json\n'), ((11476, 11509), 'os.path.join', 'os.path.join', (['base_dir', '*elements'], {}), '(base_dir, *elements)\n', (11488, 11509), False, 'import os\n'), ((11746, 11790), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""ticket_schema.json"""'], {}), "(BASE_DIR, 'ticket_schema.json')\n", (11758, 11790), False, 'import os\n'), ((12241, 12343), 'dlt.pipeline', 'dlt.pipeline', ([], {'pipeline_name': '"""train_ticket"""', 'destination': '"""duckdb"""', 'dataset_name': '"""train_ticket_data"""'}), "(pipeline_name='train_ticket', destination='duckdb',\n dataset_name='train_ticket_data')\n", (12253, 12343), False, 'import dlt\n'), ((12509, 12631), 'dlt.pipeline', 'dlt.pipeline', ([], {'pipeline_name': '"""train_ticket_processed"""', 'destination': '"""duckdb"""', 'dataset_name': '"""train_ticket_processed_data"""'}), "(pipeline_name='train_ticket_processed', destination='duckdb',\n dataset_name='train_ticket_processed_data')\n", (12521, 12631), False, 'import dlt\n'), ((1483, 1527), 'deep_translator.GoogleTranslator', 'GoogleTranslator', ([], {'source': '"""auto"""', 'target': '"""en"""'}), "(source='auto', target='en')\n", (1499, 1527), False, 'from deep_translator import GoogleTranslator\n'), ((2373, 2405), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (2387, 2405), False, 'import os\n'), ((4554, 4586), 'os.environ.get', 'os.environ.get', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (4568, 4586), False, 'import os\n'), ((1817, 1829), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (1827, 1829), False, 'import uuid\n')] |
import sys
import os
sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../')
import asyncio
from argparse import Namespace
from models.loader.args import parser
from models.loader import LoaderCheckPoint
from langchain.agents import initialize_agent, Tool
from langchain.agents import AgentType
import models.shared as shared
from langchain.chains import LLMChain
from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory
from langchain.prompts import PromptTemplate
from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
from typing import List, Set
class CustomLLMSingleActionAgent(ZeroShotAgent):
allowed_tools: List[str]
def __init__(self, *args, **kwargs):
super(CustomLLMSingleActionAgent, self).__init__(*args, **kwargs)
self.allowed_tools = kwargs['allowed_tools']
def get_allowed_tools(self) -> Set[str]:
return set(self.allowed_tools)
async def dispatch(args: Namespace):
args_dict = vars(args)
shared.loaderCheckPoint = LoaderCheckPoint(args_dict)
llm_model_ins = shared.loaderLLM()
template = """This is a conversation between a human and a bot:
{chat_history}
Write a summary of the conversation for {input}:
"""
prompt = PromptTemplate(
input_variables=["input", "chat_history"],
template=template
)
memory = ConversationBufferMemory(memory_key="chat_history")
readonlymemory = ReadOnlySharedMemory(memory=memory)
summry_chain = LLMChain(
llm=llm_model_ins,
prompt=prompt,
verbose=True,
memory=readonlymemory, # use the read-only memory to prevent the tool from modifying the memory
)
tools = [
Tool(
name="Summary",
func=summry_chain.run,
description="useful for when you summarize a conversation. The input to this tool should be a string, representing who will read this summary."
)
]
prefix = """Have a conversation with a human, answering the following questions as best you can. You have access to the following tools:"""
suffix = """Begin!
Question: {input}
{agent_scratchpad}"""
prompt = CustomLLMSingleActionAgent.create_prompt(
tools,
prefix=prefix,
suffix=suffix,
input_variables=["input", "agent_scratchpad"]
)
tool_names = [tool.name for tool in tools]
llm_chain = LLMChain(llm=llm_model_ins, prompt=prompt)
agent = CustomLLMSingleActionAgent(llm_chain=llm_chain, tools=tools, allowed_tools=tool_names)
agent_chain = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools)
agent_chain.run(input="你好")
agent_chain.run(input="你是谁?")
agent_chain.run(input="我们之前聊了什么?")
if __name__ == '__main__':
args = None
args = parser.parse_args(args=['--model-dir', '/media/checkpoint/', '--model', 'vicuna-13b-hf', '--no-remote-model', '--load-in-8bit'])
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(dispatch(args))
| [
"langchain.agents.AgentExecutor.from_agent_and_tools",
"langchain.memory.ConversationBufferMemory",
"langchain.agents.Tool",
"langchain.memory.ReadOnlySharedMemory",
"langchain.chains.LLMChain",
"langchain.prompts.PromptTemplate"
] | [((1027, 1054), 'models.loader.LoaderCheckPoint', 'LoaderCheckPoint', (['args_dict'], {}), '(args_dict)\n', (1043, 1054), False, 'from models.loader import LoaderCheckPoint\n'), ((1075, 1093), 'models.shared.loaderLLM', 'shared.loaderLLM', ([], {}), '()\n', (1091, 1093), True, 'import models.shared as shared\n'), ((1251, 1327), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['input', 'chat_history']", 'template': 'template'}), "(input_variables=['input', 'chat_history'], template=template)\n", (1265, 1327), False, 'from langchain.prompts import PromptTemplate\n'), ((1363, 1414), 'langchain.memory.ConversationBufferMemory', 'ConversationBufferMemory', ([], {'memory_key': '"""chat_history"""'}), "(memory_key='chat_history')\n", (1387, 1414), False, 'from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory\n'), ((1436, 1471), 'langchain.memory.ReadOnlySharedMemory', 'ReadOnlySharedMemory', ([], {'memory': 'memory'}), '(memory=memory)\n', (1456, 1471), False, 'from langchain.memory import ConversationBufferMemory, ReadOnlySharedMemory\n'), ((1491, 1570), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm_model_ins', 'prompt': 'prompt', 'verbose': '(True)', 'memory': 'readonlymemory'}), '(llm=llm_model_ins, prompt=prompt, verbose=True, memory=readonlymemory)\n', (1499, 1570), False, 'from langchain.chains import LLMChain\n'), ((2406, 2448), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm_model_ins', 'prompt': 'prompt'}), '(llm=llm_model_ins, prompt=prompt)\n', (2414, 2448), False, 'from langchain.chains import LLMChain\n'), ((2566, 2626), 'langchain.agents.AgentExecutor.from_agent_and_tools', 'AgentExecutor.from_agent_and_tools', ([], {'agent': 'agent', 'tools': 'tools'}), '(agent=agent, tools=tools)\n', (2600, 2626), False, 'from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n'), ((2788, 2920), 'models.loader.args.parser.parse_args', 'parser.parse_args', ([], {'args': "['--model-dir', '/media/checkpoint/', '--model', 'vicuna-13b-hf',\n '--no-remote-model', '--load-in-8bit']"}), "(args=['--model-dir', '/media/checkpoint/', '--model',\n 'vicuna-13b-hf', '--no-remote-model', '--load-in-8bit'])\n", (2805, 2920), False, 'from models.loader.args import parser\n'), ((2930, 2954), 'asyncio.new_event_loop', 'asyncio.new_event_loop', ([], {}), '()\n', (2952, 2954), False, 'import asyncio\n'), ((2959, 2987), 'asyncio.set_event_loop', 'asyncio.set_event_loop', (['loop'], {}), '(loop)\n', (2981, 2987), False, 'import asyncio\n'), ((1708, 1906), 'langchain.agents.Tool', 'Tool', ([], {'name': '"""Summary"""', 'func': 'summry_chain.run', 'description': '"""useful for when you summarize a conversation. The input to this tool should be a string, representing who will read this summary."""'}), "(name='Summary', func=summry_chain.run, description=\n 'useful for when you summarize a conversation. The input to this tool should be a string, representing who will read this summary.'\n )\n", (1712, 1906), False, 'from langchain.agents import ZeroShotAgent, Tool, AgentExecutor\n'), ((54, 79), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (69, 79), False, 'import os\n')] |
import logging
from time import sleep
from langchain.llms import OpenAI
from scrapy import Request, Spider
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from conf import (
CONNECTION_REQUEST_LLM_PROMPT,
DEFAULT_CONNECTION_MESSAGE,
MAX_PROFILES_TO_CONNECT,
MAX_PROFILES_TO_SCRAPE,
OPENAI_API_KEY,
ROLES_KEYWORDS,
SELECTIVE_SCRAPING,
SEND_CONNECTION_REQUESTS,
)
from linkedin.integrations.linkedin_api import extract_profile_from_url
from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none
from linkedin.items import LinkedinUser
from linkedin.middlewares.selenium import SeleniumSpiderMixin
logger = logging.getLogger(__name__)
SLEEP_TIME_BETWEEN_CLICKS = 1.5
roles_keywords_lowercase = [role.lower() for role in ROLES_KEYWORDS]
def remove_non_bmp_characters(text):
return "".join(c for c in text if 0x0000 <= ord(c) <= 0xFFFF)
def remove_primary_language(text):
lines = text.split("\n")
filtered_lines = [line for line in lines if "primary language" not in line.lower()]
return "\n".join(filtered_lines)
def is_your_network_is_growing_present(driver):
got_it_button = get_by_xpath_or_none(
driver,
'//button[@aria-label="Got it"]',
wait_timeout=0.5,
)
return got_it_button is not None
def is_email_verifier_present(driver):
email_verifier = get_by_xpath_or_none(
driver,
"//label[@for='email']",
wait_timeout=0.5,
)
return email_verifier is not None
def send_connection_request(driver, message):
sleep(SLEEP_TIME_BETWEEN_CLICKS)
# Click the "Add a note" button
add_note_button = get_by_xpath_or_none(
driver,
"//button[contains(@aria-label, 'note')]",
)
click(driver, add_note_button) if add_note_button else logger.warning(
"Add note button unreachable"
)
sleep(SLEEP_TIME_BETWEEN_CLICKS)
# Write the message in the textarea
message_textarea = get_by_xpath_or_none(
driver,
"//textarea[@name='message' and @id='custom-message']",
)
message_textarea.send_keys(message[:300]) if message_textarea else logger.warning(
"Textarea unreachable"
)
sleep(SLEEP_TIME_BETWEEN_CLICKS)
# Click the "Send" button
send_button = get_by_xpath_or_none(
driver,
"//button[@aria-label='Send now']",
)
click(driver, send_button) if send_button else logger.warning(
"Send button unreachable"
)
sleep(SLEEP_TIME_BETWEEN_CLICKS)
return True
def skip_connection_request(connect_button):
return not (connect_button and SEND_CONNECTION_REQUESTS)
def contains_keywords(user_profile):
headline = user_profile["headline"].lower()
return any(role in headline for role in roles_keywords_lowercase)
def skip_profile(user_profile):
return SELECTIVE_SCRAPING and not contains_keywords(user_profile)
def generate_connection_message(llm: OpenAI, user_profile):
from langchain import PromptTemplate
prompt_template = PromptTemplate.from_template(CONNECTION_REQUEST_LLM_PROMPT)
prompt = prompt_template.format(profile=user_profile)
logger.debug(f"Generate message with prompt:\n{prompt}:")
msg = llm.predict(prompt).strip()
msg = remove_primary_language(msg).strip()
msg = remove_non_bmp_characters(msg).strip()
logger.info(f"Generated Icebreaker:\n{msg}")
return msg
def extract_connect_button(user_container):
connect_button = get_by_xpath_or_none(
user_container,
".//button[contains(@aria-label, 'connect')]/span",
wait_timeout=5,
)
return (
connect_button if connect_button else logger.debug("Connect button not found")
)
def increment_index_at_end_url(response):
# incrementing the index at the end of the url
url = response.request.url
next_url_split = url.split("=")
index = int(next_url_split[-1])
next_url = "=".join(next_url_split[:-1]) + "=" + str(index + 1)
return index, next_url
def extract_user_url(user_container):
# Use this XPath to select the <a> element
link_elem = get_by_xpath_or_none(
user_container,
".//a[contains(@class, 'app-aware-link') and contains(@href, '/in/')]",
)
if not link_elem:
logger.warning("Can't extract user URL")
return None
user_url = link_elem.get_attribute("href")
logger.debug(f"Extracted user URL: {user_url}")
return user_url
def click(driver, element):
driver.execute_script("arguments[0].scrollIntoView();", element)
driver.execute_script("arguments[0].click();", element)
def press_exit(driver):
webdriver.ActionChains(driver).send_keys(Keys.ESCAPE).perform()
class SearchSpider(Spider, SeleniumSpiderMixin):
"""
Abstract class for generic search on linkedin.
"""
allowed_domains = ("linkedin.com",)
def __init__(self, start_url, driver=None, name=None, *args, **kwargs):
super().__init__(name=name, *args, **kwargs)
self.start_url = start_url
self.driver = driver or build_driver()
self.user_profile = None
self.profile_counter = 0
self.connections_sent_counter = 0
self.llm = (
OpenAI(
max_tokens=90,
model_name="text-davinci-003",
openai_api_key=OPENAI_API_KEY,
)
if SEND_CONNECTION_REQUESTS
else None
)
def wait_page_completion(self, driver):
"""
Abstract function, used to customize how the specific spider must wait for a search page completion.
"""
get_by_xpath_or_none(driver, "//*[@id='global-nav']/div", wait_timeout=5)
def parse_search_list(self, response):
continue_scrape = True
driver = self.get_driver_from_response(response)
if self.check_if_no_results_found(driver):
logger.warning("No results found. Stopping crawl.")
return
for user_container in self.iterate_containers(driver):
if is_your_network_is_growing_present(driver):
press_exit(driver)
user_profile_url = extract_user_url(user_container)
if user_profile_url is None:
continue
logger.debug(f"Found user URL:{user_profile_url}")
self.user_profile = extract_profile_from_url(
user_profile_url, driver.get_cookies()
)
if self.should_stop(response):
continue_scrape = False
break
connect_button = extract_connect_button(user_container)
if skip_profile(self.user_profile):
logger.info(f"Skipped profile: {user_profile_url}")
else:
message = (
generate_connection_message(self.llm, self.user_profile)
if OPENAI_API_KEY
else DEFAULT_CONNECTION_MESSAGE
)
self.user_profile["connection_msg"] = (
message if OPENAI_API_KEY else None
)
if skip_connection_request(connect_button):
logger.info(f"Skipped connection request: {user_profile_url}")
else:
click(driver, connect_button)
if is_email_verifier_present(driver):
press_exit(driver)
else:
conn_sent = send_connection_request(driver, message=message)
logger.info(
f"Connection request sent to {user_profile_url}\n{message}"
) if conn_sent else None
self.connections_sent_counter += 1
yield LinkedinUser(linkedinUrl=user_profile_url, **self.user_profile)
self.profile_counter += 1
if continue_scrape:
next_url = self.get_next_url(response)
yield self.create_next_request(next_url, response)
def get_driver_from_response(self, response):
return response.meta.pop("driver")
def check_if_no_results_found(self, driver):
no_result_found_xpath = (
"//div[contains(@class, 'search-reusable-search-no-results')]"
)
return (
get_by_xpath_or_none(
driver=driver, xpath=no_result_found_xpath, wait_timeout=3
)
is not None
)
def get_next_url(self, response):
index, next_url = increment_index_at_end_url(response)
return next_url
def create_next_request(self, next_url, response):
return Request(
url=next_url,
priority=-1,
callback=self.parse_search_list,
meta=response.meta,
)
def iterate_containers(self, driver):
for i in range(1, 11):
container_xpath = f"//li[contains(@class, 'result-container')][{i}]"
container_elem = get_by_xpath_or_none(
driver, container_xpath, wait_timeout=2
)
if container_elem:
logger.debug(f"Loading {i}th user")
driver.execute_script("arguments[0].scrollIntoView();", container_elem)
self.sleep()
yield container_elem
def should_stop(self, response):
max_num_profiles = self.profile_counter >= MAX_PROFILES_TO_SCRAPE
if max_num_profiles:
logger.info(
"Stopping Reached maximum number of profiles to scrape. Stopping crawl."
)
max_num_connections = self.connections_sent_counter >= MAX_PROFILES_TO_CONNECT
if max_num_connections:
logger.info(
"Stopping Reached maximum number of profiles to connect. Stopping crawl."
)
return max_num_profiles
| [
"langchain.llms.OpenAI",
"langchain.PromptTemplate.from_template"
] | [((689, 716), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (706, 716), False, 'import logging\n'), ((1186, 1271), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['driver', '"""//button[@aria-label="Got it"]"""'], {'wait_timeout': '(0.5)'}), '(driver, \'//button[@aria-label="Got it"]\', wait_timeout=0.5\n )\n', (1206, 1271), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((1397, 1468), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['driver', '"""//label[@for=\'email\']"""'], {'wait_timeout': '(0.5)'}), '(driver, "//label[@for=\'email\']", wait_timeout=0.5)\n', (1417, 1468), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((1590, 1622), 'time.sleep', 'sleep', (['SLEEP_TIME_BETWEEN_CLICKS'], {}), '(SLEEP_TIME_BETWEEN_CLICKS)\n', (1595, 1622), False, 'from time import sleep\n'), ((1682, 1753), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['driver', '"""//button[contains(@aria-label, \'note\')]"""'], {}), '(driver, "//button[contains(@aria-label, \'note\')]")\n', (1702, 1753), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((1900, 1932), 'time.sleep', 'sleep', (['SLEEP_TIME_BETWEEN_CLICKS'], {}), '(SLEEP_TIME_BETWEEN_CLICKS)\n', (1905, 1932), False, 'from time import sleep\n'), ((1997, 2085), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['driver', '"""//textarea[@name=\'message\' and @id=\'custom-message\']"""'], {}), '(driver,\n "//textarea[@name=\'message\' and @id=\'custom-message\']")\n', (2017, 2085), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((2233, 2265), 'time.sleep', 'sleep', (['SLEEP_TIME_BETWEEN_CLICKS'], {}), '(SLEEP_TIME_BETWEEN_CLICKS)\n', (2238, 2265), False, 'from time import sleep\n'), ((2315, 2379), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['driver', '"""//button[@aria-label=\'Send now\']"""'], {}), '(driver, "//button[@aria-label=\'Send now\']")\n', (2335, 2379), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((2514, 2546), 'time.sleep', 'sleep', (['SLEEP_TIME_BETWEEN_CLICKS'], {}), '(SLEEP_TIME_BETWEEN_CLICKS)\n', (2519, 2546), False, 'from time import sleep\n'), ((3058, 3117), 'langchain.PromptTemplate.from_template', 'PromptTemplate.from_template', (['CONNECTION_REQUEST_LLM_PROMPT'], {}), '(CONNECTION_REQUEST_LLM_PROMPT)\n', (3086, 3117), False, 'from langchain import PromptTemplate\n'), ((3504, 3612), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['user_container', '""".//button[contains(@aria-label, \'connect\')]/span"""'], {'wait_timeout': '(5)'}), '(user_container,\n ".//button[contains(@aria-label, \'connect\')]/span", wait_timeout=5)\n', (3524, 3612), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((4142, 4254), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['user_container', '""".//a[contains(@class, \'app-aware-link\') and contains(@href, \'/in/\')]"""'], {}), '(user_container,\n ".//a[contains(@class, \'app-aware-link\') and contains(@href, \'/in/\')]")\n', (4162, 4254), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((5656, 5729), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['driver', '"""//*[@id=\'global-nav\']/div"""'], {'wait_timeout': '(5)'}), '(driver, "//*[@id=\'global-nav\']/div", wait_timeout=5)\n', (5676, 5729), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((8691, 8783), 'scrapy.Request', 'Request', ([], {'url': 'next_url', 'priority': '(-1)', 'callback': 'self.parse_search_list', 'meta': 'response.meta'}), '(url=next_url, priority=-1, callback=self.parse_search_list, meta=\n response.meta)\n', (8698, 8783), False, 'from scrapy import Request, Spider\n'), ((5095, 5109), 'linkedin.integrations.selenium.build_driver', 'build_driver', ([], {}), '()\n', (5107, 5109), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((5251, 5339), 'langchain.llms.OpenAI', 'OpenAI', ([], {'max_tokens': '(90)', 'model_name': '"""text-davinci-003"""', 'openai_api_key': 'OPENAI_API_KEY'}), "(max_tokens=90, model_name='text-davinci-003', openai_api_key=\n OPENAI_API_KEY)\n", (5257, 5339), False, 'from langchain.llms import OpenAI\n'), ((8349, 8434), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', ([], {'driver': 'driver', 'xpath': 'no_result_found_xpath', 'wait_timeout': '(3)'}), '(driver=driver, xpath=no_result_found_xpath, wait_timeout=3\n )\n', (8369, 8434), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((9022, 9083), 'linkedin.integrations.selenium.get_by_xpath_or_none', 'get_by_xpath_or_none', (['driver', 'container_xpath'], {'wait_timeout': '(2)'}), '(driver, container_xpath, wait_timeout=2)\n', (9042, 9083), False, 'from linkedin.integrations.selenium import build_driver, get_by_xpath_or_none\n'), ((4675, 4705), 'selenium.webdriver.ActionChains', 'webdriver.ActionChains', (['driver'], {}), '(driver)\n', (4697, 4705), False, 'from selenium import webdriver\n'), ((7808, 7871), 'linkedin.items.LinkedinUser', 'LinkedinUser', ([], {'linkedinUrl': 'user_profile_url'}), '(linkedinUrl=user_profile_url, **self.user_profile)\n', (7820, 7871), False, 'from linkedin.items import LinkedinUser\n')] |
import streamlit as st
import os
from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient
from PyPDF2 import PdfReader
# Import
#import textwrap
import openai
from langchain.llms import AzureOpenAI, OpenAI
from langchain.embeddings import OpenAIEmbeddings
from llama_index.vector_stores import RedisVectorStore
from llama_index import LangchainEmbedding
from llama_index import (
GPTVectorStoreIndex,
SimpleDirectoryReader,
LLMPredictor,
PromptHelper,
ServiceContext,
StorageContext
)
import sys
import logging
logging.basicConfig(stream=sys.stdout, level=logging.INFO) # logging.DEBUG for more verbose output
logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout))
REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
REDIS_PORT = os.getenv("REDIS_PORT", "6379")
REDIS_PASSWORD = os.getenv("REDIS_PASSWORD", "")
OPENAI_API_TYPE = os.getenv("OPENAI_API_TYPE", "")
OPENAI_COMPLETIONS_ENGINE = os.getenv("OPENAI_COMPLETIONS_ENGINE", "text-davinci-003")
OPENAI_EMBEDDINGS_ENGINE = os.getenv("OPENAI_EMBEDDINGS_ENGINE", "text-embedding-ada-002")
STORAGE_CONNECTION_STRING=os.getenv("STORAGE_CONNECTION_STRING", "")
CONTAINER_NAME=os.getenv("CONTAINER_NAME", "data")
def get_embeddings():
if OPENAI_API_TYPE=="azure":
#currently Azure OpenAI embeddings require request for service limit increase to be useful
#using build-in HuggingFace instead
#from langchain.embeddings import HuggingFaceEmbeddings
#embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
from langchain.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(deployment=OPENAI_EMBEDDINGS_ENGINE, chunk_size=1 )
else:
from langchain.embeddings import OpenAIEmbeddings
# Init OpenAI Embeddings
embeddings = OpenAIEmbeddings()
return embeddings
def get_llm():
if OPENAI_API_TYPE=="azure":
openai.api_type = "azure"
openai.api_base = os.getenv("OPENAI_API_BASE")
openai.api_version = os.getenv("OPENAI_API_VERSION")
openai.api_key = os.getenv("OPENAI_API_KEY")
text_model_deployment = OPENAI_COMPLETIONS_ENGINE
from langchain.llms import AzureOpenAI
llm = AzureOpenAI(deployment_name=text_model_deployment, model_kwargs={
"api_key": openai.api_key,
"api_base": openai.api_base,
"api_type": openai.api_type,
"api_version": openai.api_version,
})
#llm_predictor = LLMPredictor(llm=llm)
else:
from langchain.llms import OpenAI
llm=OpenAI()
return llm
@st.cache_resource
def get_query_engine():
blob_service_client = BlobServiceClient.from_connection_string(STORAGE_CONNECTION_STRING)
container_client = blob_service_client.get_container_client(container=CONTAINER_NAME)
download_file_path = "/tmp/docs"
isExist = os.path.exists(download_file_path)
if not isExist:
os.makedirs(download_file_path)
# List the blobs in the container
blob_list = container_client.list_blobs()
for blob in blob_list:
print("\t" + blob.name)
if not os.path.exists( download_file_path+ "/" + blob.name):
print("\nDownloading blob to \n\t" + download_file_path+ "/" + blob.name)
with open(file=download_file_path + "/" + blob.name, mode="wb") as download_file:
download_file.write(container_client.download_blob(blob.name).readall())
else:
print("\nSkipping \n\t" + download_file_path+ "/" + blob.name)
# load documents
documents = SimpleDirectoryReader(download_file_path).load_data()
print('Document ID:', documents[0].doc_id)
from llama_index.storage.storage_context import StorageContext
vector_store = RedisVectorStore(
index_name="chevy_docs",
index_prefix="llama",
redis_url="rediss://default:{}@{}:{}".format(REDIS_PASSWORD,REDIS_HOST,REDIS_PORT),
overwrite=True
)
llm_predictor = LLMPredictor(llm=get_llm())
llm_embedding = LangchainEmbedding(get_embeddings())
service_context = ServiceContext.from_defaults(
llm_predictor=llm_predictor,
embed_model=llm_embedding,
)
storage_context = StorageContext.from_defaults(
vector_store=vector_store
)
index = GPTVectorStoreIndex.from_documents(
documents,
storage_context=storage_context,
service_context=service_context
)
return index.as_query_engine()
file = open("assets/app-info.md", "r")
st.markdown(file.read())
query_engine = get_query_engine()
user_query = st.text_input("Query:", 'What types of variants are available for the Chevrolet Colorado?')
try:
response = query_engine.query(user_query)
except Exception as e:
response = "Error: %s" % str(e)
st.markdown(str(response))
#print(str(response)) | [
"langchain.embeddings.OpenAIEmbeddings",
"langchain.llms.OpenAI",
"langchain.llms.AzureOpenAI"
] | [((558, 616), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (577, 616), False, 'import logging\n'), ((744, 780), 'os.getenv', 'os.getenv', (['"""REDIS_HOST"""', '"""localhost"""'], {}), "('REDIS_HOST', 'localhost')\n", (753, 780), False, 'import os\n'), ((794, 825), 'os.getenv', 'os.getenv', (['"""REDIS_PORT"""', '"""6379"""'], {}), "('REDIS_PORT', '6379')\n", (803, 825), False, 'import os\n'), ((843, 874), 'os.getenv', 'os.getenv', (['"""REDIS_PASSWORD"""', '""""""'], {}), "('REDIS_PASSWORD', '')\n", (852, 874), False, 'import os\n'), ((894, 926), 'os.getenv', 'os.getenv', (['"""OPENAI_API_TYPE"""', '""""""'], {}), "('OPENAI_API_TYPE', '')\n", (903, 926), False, 'import os\n'), ((955, 1013), 'os.getenv', 'os.getenv', (['"""OPENAI_COMPLETIONS_ENGINE"""', '"""text-davinci-003"""'], {}), "('OPENAI_COMPLETIONS_ENGINE', 'text-davinci-003')\n", (964, 1013), False, 'import os\n'), ((1041, 1104), 'os.getenv', 'os.getenv', (['"""OPENAI_EMBEDDINGS_ENGINE"""', '"""text-embedding-ada-002"""'], {}), "('OPENAI_EMBEDDINGS_ENGINE', 'text-embedding-ada-002')\n", (1050, 1104), False, 'import os\n'), ((1133, 1175), 'os.getenv', 'os.getenv', (['"""STORAGE_CONNECTION_STRING"""', '""""""'], {}), "('STORAGE_CONNECTION_STRING', '')\n", (1142, 1175), False, 'import os\n'), ((1191, 1226), 'os.getenv', 'os.getenv', (['"""CONTAINER_NAME"""', '"""data"""'], {}), "('CONTAINER_NAME', 'data')\n", (1200, 1226), False, 'import os\n'), ((4640, 4735), 'streamlit.text_input', 'st.text_input', (['"""Query:"""', '"""What types of variants are available for the Chevrolet Colorado?"""'], {}), "('Query:',\n 'What types of variants are available for the Chevrolet Colorado?')\n", (4653, 4735), True, 'import streamlit as st\n'), ((688, 728), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (709, 728), False, 'import logging\n'), ((2701, 2768), 'azure.storage.blob.BlobServiceClient.from_connection_string', 'BlobServiceClient.from_connection_string', (['STORAGE_CONNECTION_STRING'], {}), '(STORAGE_CONNECTION_STRING)\n', (2741, 2768), False, 'from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient\n'), ((2910, 2944), 'os.path.exists', 'os.path.exists', (['download_file_path'], {}), '(download_file_path)\n', (2924, 2944), False, 'import os\n'), ((4135, 4224), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'embed_model': 'llm_embedding'}), '(llm_predictor=llm_predictor, embed_model=\n llm_embedding)\n', (4163, 4224), False, 'from llama_index import GPTVectorStoreIndex, SimpleDirectoryReader, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n'), ((4265, 4320), 'llama_index.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (4293, 4320), False, 'from llama_index.storage.storage_context import StorageContext\n'), ((4347, 4463), 'llama_index.GPTVectorStoreIndex.from_documents', 'GPTVectorStoreIndex.from_documents', (['documents'], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(documents, storage_context=\n storage_context, service_context=service_context)\n', (4381, 4463), False, 'from llama_index import GPTVectorStoreIndex, SimpleDirectoryReader, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n'), ((657, 676), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (674, 676), False, 'import logging\n'), ((1645, 1712), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'deployment': 'OPENAI_EMBEDDINGS_ENGINE', 'chunk_size': '(1)'}), '(deployment=OPENAI_EMBEDDINGS_ENGINE, chunk_size=1)\n', (1661, 1712), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((1836, 1854), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1852, 1854), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((1987, 2015), 'os.getenv', 'os.getenv', (['"""OPENAI_API_BASE"""'], {}), "('OPENAI_API_BASE')\n", (1996, 2015), False, 'import os\n'), ((2045, 2076), 'os.getenv', 'os.getenv', (['"""OPENAI_API_VERSION"""'], {}), "('OPENAI_API_VERSION')\n", (2054, 2076), False, 'import os\n'), ((2102, 2129), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (2111, 2129), False, 'import os\n'), ((2249, 2443), 'langchain.llms.AzureOpenAI', 'AzureOpenAI', ([], {'deployment_name': 'text_model_deployment', 'model_kwargs': "{'api_key': openai.api_key, 'api_base': openai.api_base, 'api_type': openai\n .api_type, 'api_version': openai.api_version}"}), "(deployment_name=text_model_deployment, model_kwargs={'api_key':\n openai.api_key, 'api_base': openai.api_base, 'api_type': openai.\n api_type, 'api_version': openai.api_version})\n", (2260, 2443), False, 'from langchain.llms import AzureOpenAI\n'), ((2605, 2613), 'langchain.llms.OpenAI', 'OpenAI', ([], {}), '()\n', (2611, 2613), False, 'from langchain.llms import OpenAI\n'), ((2973, 3004), 'os.makedirs', 'os.makedirs', (['download_file_path'], {}), '(download_file_path)\n', (2984, 3004), False, 'import os\n'), ((3164, 3216), 'os.path.exists', 'os.path.exists', (["(download_file_path + '/' + blob.name)"], {}), "(download_file_path + '/' + blob.name)\n", (3178, 3216), False, 'import os\n'), ((3615, 3656), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['download_file_path'], {}), '(download_file_path)\n', (3636, 3656), False, 'from llama_index import GPTVectorStoreIndex, SimpleDirectoryReader, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n')] |
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage
from whenx.models.team import Team
from whenx.models.scout import Scout
from whenx.models.sentinel import Sentinel
from whenx.models.soldier import Soldier
import re
from whenx.database import db
class Captain:
def __init__(self, mission: str):
self.mission = mission
def run(self, team):
prompts = self.generate_prompts()
team = self.create_team(prompts, team)
return team
def initialize_team(self, prompts, team):
db.add(team)
db.commit()
scout = Scout(instruction=prompts["scout"], teamId=team.id)
sentinel = Sentinel(instruction=prompts["sentinel"], teamId=team.id)
soldier = Soldier(instruction=prompts["soldier"], teamId=team.id)
db.add(scout)
db.add(sentinel)
db.add(soldier)
db.commit()
return team
def generate_prompts(self):
system = """You are the captain of a team of scouts, sentinels, and soldiers.
You generate instructions for your team to follow based on a mission.
Scouts are responsible for gathering information from the internet.
Sentinels are responsible for monitoring the observations of scouts for changes.
Soldiers are responsible for writing reports.
Instruction examples:
Mission: When apple relseases a new product.
Scout: What is the new apple product? return the answer.
Sentinel: Was a new product released? Reply with (Yes/No) and the name of the product.
Soldier: Write a report about it.
"""
prompt = f"""
Complete the instructions for the scouts, sentinels, and soldiers. One per line.
Mission:{self.mission}
"""
model = ChatOpenAI(model="gpt-4", temperature=0)
messages = [
SystemMessage(
content=system
),
HumanMessage(content=prompt),
]
response = model(messages)
response = self.parse_response(response.content)
return response
def parse_response(self, response):
lines = re.split(r'\n+', response.strip())
# Extract the relevant information from the lines
prompts = {}
prompts["scout"] = lines[0].split(": ")[1]
prompts["sentinel"] = lines[1].split(": ")[1]
prompts["soldier"] = lines[2].split(": ")[1]
return prompts
| [
"langchain.schema.SystemMessage",
"langchain.schema.HumanMessage",
"langchain.chat_models.ChatOpenAI"
] | [((575, 587), 'whenx.database.db.add', 'db.add', (['team'], {}), '(team)\n', (581, 587), False, 'from whenx.database import db\n'), ((596, 607), 'whenx.database.db.commit', 'db.commit', ([], {}), '()\n', (605, 607), False, 'from whenx.database import db\n'), ((624, 675), 'whenx.models.scout.Scout', 'Scout', ([], {'instruction': "prompts['scout']", 'teamId': 'team.id'}), "(instruction=prompts['scout'], teamId=team.id)\n", (629, 675), False, 'from whenx.models.scout import Scout\n'), ((695, 752), 'whenx.models.sentinel.Sentinel', 'Sentinel', ([], {'instruction': "prompts['sentinel']", 'teamId': 'team.id'}), "(instruction=prompts['sentinel'], teamId=team.id)\n", (703, 752), False, 'from whenx.models.sentinel import Sentinel\n'), ((771, 826), 'whenx.models.soldier.Soldier', 'Soldier', ([], {'instruction': "prompts['soldier']", 'teamId': 'team.id'}), "(instruction=prompts['soldier'], teamId=team.id)\n", (778, 826), False, 'from whenx.models.soldier import Soldier\n'), ((835, 848), 'whenx.database.db.add', 'db.add', (['scout'], {}), '(scout)\n', (841, 848), False, 'from whenx.database import db\n'), ((857, 873), 'whenx.database.db.add', 'db.add', (['sentinel'], {}), '(sentinel)\n', (863, 873), False, 'from whenx.database import db\n'), ((882, 897), 'whenx.database.db.add', 'db.add', (['soldier'], {}), '(soldier)\n', (888, 897), False, 'from whenx.database import db\n'), ((906, 917), 'whenx.database.db.commit', 'db.commit', ([], {}), '()\n', (915, 917), False, 'from whenx.database import db\n'), ((1719, 1759), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'model': '"""gpt-4"""', 'temperature': '(0)'}), "(model='gpt-4', temperature=0)\n", (1729, 1759), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1793, 1822), 'langchain.schema.SystemMessage', 'SystemMessage', ([], {'content': 'system'}), '(content=system)\n', (1806, 1822), False, 'from langchain.schema import HumanMessage, SystemMessage\n'), ((1866, 1894), 'langchain.schema.HumanMessage', 'HumanMessage', ([], {'content': 'prompt'}), '(content=prompt)\n', (1878, 1894), False, 'from langchain.schema import HumanMessage, SystemMessage\n')] |
import json
import re
from langchain.chains import RetrievalQA
from utils.functions import find_nth, remove_extra_heading, add_json_characters, Timeout
from langchain import LLMChain
from langchain.chat_models import ChatOpenAI
def section_schemas(heading, keyword, format_instructions, retriever, prompt):
chat = ChatOpenAI(
temperature=0,
model_name='gpt-3.5-turbo-16k-0613'
)
llm = LLMChain(llm=chat,
prompt=prompt)
if "Introduction" in heading:
return 'none'
elif "introduction" in heading:
return 'none'
try:
with Timeout(60):
qa = RetrievalQA.from_chain_type(llm=chat, chain_type="stuff", retriever=retriever)
print("<----- closest")
print(qa.run(heading))
closest = qa.run(heading)
print("<----- closest end")
except Timeout.Timeout:
print("<---- excepting out of qa")
return "nothing"
if len(closest)<350:
return 'none'
temp = """
Don't repeat anything you've already said. Output in html format with subheadings.
Do not write anything about Artificial Intelligence. If anything is about artificial intelligence remove it.
Make sure to write as a blog writer NOT as the manufacturer. Don't start the intro with 'Yes'.
Remember to have the closing quotation marks and closing curly bracket for the JSON.
Remember - DO NOT add any titles, subtitles or intro before the blog section.
Only add in subheadings (h3) where applicable to break up the text. Only add h3 heading every 150 to 250 words.
Put the subheadings in html 'h3' tags and the content in 'p' tags.
Use ordered and unordered lists where applicable.
Write 8, 60 word paragraphs for my blog section with subheadings for my article about "{keyword}".
Use the context below to create the blog section.
There should be at least 6-9 paragraph 60 word paragraphs.
Use this context (real article summaries) to create the intro.
Context: {context}
Format the output as JSON with the following keys:
blog_section
{format_instructions}
Final Checks:
Don't repeat anything you've already said.
Are there 1 or 2 subheadings? If not, add them.
Do not say 'Sure!'
Are any of the paragraphs longer than 80 words? If so, break them up into smaller paragraphs.
Is the entire thing under 350 words? If so, lengthen it.
Is there a closing quotation mark for the JSON content? If not, add one.
Make sure to include the opening and closing brackets of the JSON.
Section:
"""
messages = temp.format(
format_instructions=format_instructions,
keyword=keyword,
heading=heading,
context=closest,
)
output_dict = llm.run(input=messages)
print("<-- output dict start for "+heading)
print(output_dict)
print(heading+r"\n\n" in output_dict)
print("<-- output dict end")
output_dict = output_dict.replace("\\'","'")
output_dict = output_dict.replace('\\"',"'")
output_dict = remove_extra_heading(output_dict, heading)
result = re.findall(r'{([^{]*?)}', str(output_dict))
if len(result)>0:
try:
t_res = result[0].strip().replace('“',"'")
t_res = t_res.replace('"',"'")
nth=find_nth(t_res, "'",3)
nth_text = t_res[nth+1:]
res_2 = add_json_characters(nth_text)
except:
print("res2 second")
pass
else:
stripped_output = output_dict.replace("{","")
stripped_output = stripped_output.strip()
if stripped_output.startswith('"blog_section":'):
t_res = stripped_output.replace('"',"'")
t_res = t_res.replace('“',"'")
nth=find_nth(t_res, "'",3)
nth_text = t_res[nth+1:]
res_2 = add_json_characters(nth_text)
else:
test_res = '{"blog_section": "'+stripped_output.replace('"',"'")
period_index = test_res.rfind(".") + 1
res_2 = test_res[:period_index]+'</p>"}'
if "I apologize" not in str(res_2):
print("is not in string")
try:
new_response = json.loads(str(res_2), strict=False)
new_response = new_response['blog_section']
except:
new_response = res_2
else:
new_response = res_2
print("<---section start")
print("section for "+heading)
print(new_response)
print("<---section end")
return new_response | [
"langchain.LLMChain",
"langchain.chains.RetrievalQA.from_chain_type",
"langchain.chat_models.ChatOpenAI"
] | [((325, 387), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo-16k-0613"""'}), "(temperature=0, model_name='gpt-3.5-turbo-16k-0613')\n", (335, 387), False, 'from langchain.chat_models import ChatOpenAI\n'), ((433, 466), 'langchain.LLMChain', 'LLMChain', ([], {'llm': 'chat', 'prompt': 'prompt'}), '(llm=chat, prompt=prompt)\n', (441, 466), False, 'from langchain import LLMChain\n'), ((3113, 3155), 'utils.functions.remove_extra_heading', 'remove_extra_heading', (['output_dict', 'heading'], {}), '(output_dict, heading)\n', (3133, 3155), False, 'from utils.functions import find_nth, remove_extra_heading, add_json_characters, Timeout\n'), ((618, 629), 'utils.functions.Timeout', 'Timeout', (['(60)'], {}), '(60)\n', (625, 629), False, 'from utils.functions import find_nth, remove_extra_heading, add_json_characters, Timeout\n'), ((648, 726), 'langchain.chains.RetrievalQA.from_chain_type', 'RetrievalQA.from_chain_type', ([], {'llm': 'chat', 'chain_type': '"""stuff"""', 'retriever': 'retriever'}), "(llm=chat, chain_type='stuff', retriever=retriever)\n", (675, 726), False, 'from langchain.chains import RetrievalQA\n'), ((3363, 3386), 'utils.functions.find_nth', 'find_nth', (['t_res', '"""\'"""', '(3)'], {}), '(t_res, "\'", 3)\n', (3371, 3386), False, 'from utils.functions import find_nth, remove_extra_heading, add_json_characters, Timeout\n'), ((3443, 3472), 'utils.functions.add_json_characters', 'add_json_characters', (['nth_text'], {}), '(nth_text)\n', (3462, 3472), False, 'from utils.functions import find_nth, remove_extra_heading, add_json_characters, Timeout\n'), ((3825, 3848), 'utils.functions.find_nth', 'find_nth', (['t_res', '"""\'"""', '(3)'], {}), '(t_res, "\'", 3)\n', (3833, 3848), False, 'from utils.functions import find_nth, remove_extra_heading, add_json_characters, Timeout\n'), ((3905, 3934), 'utils.functions.add_json_characters', 'add_json_characters', (['nth_text'], {}), '(nth_text)\n', (3924, 3934), False, 'from utils.functions import find_nth, remove_extra_heading, add_json_characters, Timeout\n')] |
"""Experiment with different models."""
from __future__ import annotations
from typing import List, Optional, Sequence
from langchain_core.language_models.llms import BaseLLM
from langchain_core.prompts.prompt import PromptTemplate
from langchain_core.utils.input import get_color_mapping, print_text
from langchain.chains.base import Chain
from langchain.chains.llm import LLMChain
class ModelLaboratory:
"""Experiment with different models."""
def __init__(self, chains: Sequence[Chain], names: Optional[List[str]] = None):
"""Initialize with chains to experiment with.
Args:
chains: list of chains to experiment with.
"""
for chain in chains:
if not isinstance(chain, Chain):
raise ValueError(
"ModelLaboratory should now be initialized with Chains. "
"If you want to initialize with LLMs, use the `from_llms` method "
"instead (`ModelLaboratory.from_llms(...)`)"
)
if len(chain.input_keys) != 1:
raise ValueError(
"Currently only support chains with one input variable, "
f"got {chain.input_keys}"
)
if len(chain.output_keys) != 1:
raise ValueError(
"Currently only support chains with one output variable, "
f"got {chain.output_keys}"
)
if names is not None:
if len(names) != len(chains):
raise ValueError("Length of chains does not match length of names.")
self.chains = chains
chain_range = [str(i) for i in range(len(self.chains))]
self.chain_colors = get_color_mapping(chain_range)
self.names = names
@classmethod
def from_llms(
cls, llms: List[BaseLLM], prompt: Optional[PromptTemplate] = None
) -> ModelLaboratory:
"""Initialize with LLMs to experiment with and optional prompt.
Args:
llms: list of LLMs to experiment with
prompt: Optional prompt to use to prompt the LLMs. Defaults to None.
If a prompt was provided, it should only have one input variable.
"""
if prompt is None:
prompt = PromptTemplate(input_variables=["_input"], template="{_input}")
chains = [LLMChain(llm=llm, prompt=prompt) for llm in llms]
names = [str(llm) for llm in llms]
return cls(chains, names=names)
def compare(self, text: str) -> None:
"""Compare model outputs on an input text.
If a prompt was provided with starting the laboratory, then this text will be
fed into the prompt. If no prompt was provided, then the input text is the
entire prompt.
Args:
text: input text to run all models on.
"""
print(f"\033[1mInput:\033[0m\n{text}\n") # noqa: T201
for i, chain in enumerate(self.chains):
if self.names is not None:
name = self.names[i]
else:
name = str(chain)
print_text(name, end="\n")
output = chain.run(text)
print_text(output, color=self.chain_colors[str(i)], end="\n\n")
| [
"langchain_core.utils.input.print_text",
"langchain_core.utils.input.get_color_mapping",
"langchain_core.prompts.prompt.PromptTemplate",
"langchain.chains.llm.LLMChain"
] | [((1752, 1782), 'langchain_core.utils.input.get_color_mapping', 'get_color_mapping', (['chain_range'], {}), '(chain_range)\n', (1769, 1782), False, 'from langchain_core.utils.input import get_color_mapping, print_text\n'), ((2307, 2370), 'langchain_core.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['_input']", 'template': '"""{_input}"""'}), "(input_variables=['_input'], template='{_input}')\n", (2321, 2370), False, 'from langchain_core.prompts.prompt import PromptTemplate\n'), ((2389, 2421), 'langchain.chains.llm.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt)\n', (2397, 2421), False, 'from langchain.chains.llm import LLMChain\n'), ((3138, 3164), 'langchain_core.utils.input.print_text', 'print_text', (['name'], {'end': '"""\n"""'}), "(name, end='\\n')\n", (3148, 3164), False, 'from langchain_core.utils.input import get_color_mapping, print_text\n')] |
from typing import Any, List, Optional, Sequence, Tuple
from langchain_core._api import deprecated
from langchain_core.agents import AgentAction
from langchain_core.callbacks import BaseCallbackManager
from langchain_core.language_models import BaseLanguageModel
from langchain_core.prompts import BasePromptTemplate
from langchain_core.prompts.chat import (
ChatPromptTemplate,
HumanMessagePromptTemplate,
SystemMessagePromptTemplate,
)
from langchain_core.pydantic_v1 import Field
from langchain_core.tools import BaseTool
from langchain.agents.agent import Agent, AgentOutputParser
from langchain.agents.chat.output_parser import ChatOutputParser
from langchain.agents.chat.prompt import (
FORMAT_INSTRUCTIONS,
HUMAN_MESSAGE,
SYSTEM_MESSAGE_PREFIX,
SYSTEM_MESSAGE_SUFFIX,
)
from langchain.agents.utils import validate_tools_single_input
from langchain.chains.llm import LLMChain
@deprecated("0.1.0", alternative="create_react_agent", removal="0.2.0")
class ChatAgent(Agent):
"""Chat Agent."""
output_parser: AgentOutputParser = Field(default_factory=ChatOutputParser)
"""Output parser for the agent."""
@property
def observation_prefix(self) -> str:
"""Prefix to append the observation with."""
return "Observation: "
@property
def llm_prefix(self) -> str:
"""Prefix to append the llm call with."""
return "Thought:"
def _construct_scratchpad(
self, intermediate_steps: List[Tuple[AgentAction, str]]
) -> str:
agent_scratchpad = super()._construct_scratchpad(intermediate_steps)
if not isinstance(agent_scratchpad, str):
raise ValueError("agent_scratchpad should be of type string.")
if agent_scratchpad:
return (
f"This was your previous work "
f"(but I haven't seen any of it! I only see what "
f"you return as final answer):\n{agent_scratchpad}"
)
else:
return agent_scratchpad
@classmethod
def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
return ChatOutputParser()
@classmethod
def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
super()._validate_tools(tools)
validate_tools_single_input(class_name=cls.__name__, tools=tools)
@property
def _stop(self) -> List[str]:
return ["Observation:"]
@classmethod
def create_prompt(
cls,
tools: Sequence[BaseTool],
system_message_prefix: str = SYSTEM_MESSAGE_PREFIX,
system_message_suffix: str = SYSTEM_MESSAGE_SUFFIX,
human_message: str = HUMAN_MESSAGE,
format_instructions: str = FORMAT_INSTRUCTIONS,
input_variables: Optional[List[str]] = None,
) -> BasePromptTemplate:
tool_strings = "\n".join([f"{tool.name}: {tool.description}" for tool in tools])
tool_names = ", ".join([tool.name for tool in tools])
format_instructions = format_instructions.format(tool_names=tool_names)
template = "\n\n".join(
[
system_message_prefix,
tool_strings,
format_instructions,
system_message_suffix,
]
)
messages = [
SystemMessagePromptTemplate.from_template(template),
HumanMessagePromptTemplate.from_template(human_message),
]
if input_variables is None:
input_variables = ["input", "agent_scratchpad"]
return ChatPromptTemplate(input_variables=input_variables, messages=messages) # type: ignore[arg-type]
@classmethod
def from_llm_and_tools(
cls,
llm: BaseLanguageModel,
tools: Sequence[BaseTool],
callback_manager: Optional[BaseCallbackManager] = None,
output_parser: Optional[AgentOutputParser] = None,
system_message_prefix: str = SYSTEM_MESSAGE_PREFIX,
system_message_suffix: str = SYSTEM_MESSAGE_SUFFIX,
human_message: str = HUMAN_MESSAGE,
format_instructions: str = FORMAT_INSTRUCTIONS,
input_variables: Optional[List[str]] = None,
**kwargs: Any,
) -> Agent:
"""Construct an agent from an LLM and tools."""
cls._validate_tools(tools)
prompt = cls.create_prompt(
tools,
system_message_prefix=system_message_prefix,
system_message_suffix=system_message_suffix,
human_message=human_message,
format_instructions=format_instructions,
input_variables=input_variables,
)
llm_chain = LLMChain(
llm=llm,
prompt=prompt,
callback_manager=callback_manager,
)
tool_names = [tool.name for tool in tools]
_output_parser = output_parser or cls._get_default_output_parser()
return cls(
llm_chain=llm_chain,
allowed_tools=tool_names,
output_parser=_output_parser,
**kwargs,
)
@property
def _agent_type(self) -> str:
raise ValueError
| [
"langchain_core.prompts.chat.SystemMessagePromptTemplate.from_template",
"langchain.chains.llm.LLMChain",
"langchain.agents.utils.validate_tools_single_input",
"langchain_core.pydantic_v1.Field",
"langchain_core.prompts.chat.ChatPromptTemplate",
"langchain_core.prompts.chat.HumanMessagePromptTemplate.from_template",
"langchain_core._api.deprecated",
"langchain.agents.chat.output_parser.ChatOutputParser"
] | [((915, 985), 'langchain_core._api.deprecated', 'deprecated', (['"""0.1.0"""'], {'alternative': '"""create_react_agent"""', 'removal': '"""0.2.0"""'}), "('0.1.0', alternative='create_react_agent', removal='0.2.0')\n", (925, 985), False, 'from langchain_core._api import deprecated\n'), ((1072, 1111), 'langchain_core.pydantic_v1.Field', 'Field', ([], {'default_factory': 'ChatOutputParser'}), '(default_factory=ChatOutputParser)\n', (1077, 1111), False, 'from langchain_core.pydantic_v1 import Field\n'), ((2134, 2152), 'langchain.agents.chat.output_parser.ChatOutputParser', 'ChatOutputParser', ([], {}), '()\n', (2150, 2152), False, 'from langchain.agents.chat.output_parser import ChatOutputParser\n'), ((2283, 2348), 'langchain.agents.utils.validate_tools_single_input', 'validate_tools_single_input', ([], {'class_name': 'cls.__name__', 'tools': 'tools'}), '(class_name=cls.__name__, tools=tools)\n', (2310, 2348), False, 'from langchain.agents.utils import validate_tools_single_input\n'), ((3543, 3613), 'langchain_core.prompts.chat.ChatPromptTemplate', 'ChatPromptTemplate', ([], {'input_variables': 'input_variables', 'messages': 'messages'}), '(input_variables=input_variables, messages=messages)\n', (3561, 3613), False, 'from langchain_core.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate\n'), ((4630, 4697), 'langchain.chains.llm.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt', 'callback_manager': 'callback_manager'}), '(llm=llm, prompt=prompt, callback_manager=callback_manager)\n', (4638, 4697), False, 'from langchain.chains.llm import LLMChain\n'), ((3300, 3351), 'langchain_core.prompts.chat.SystemMessagePromptTemplate.from_template', 'SystemMessagePromptTemplate.from_template', (['template'], {}), '(template)\n', (3341, 3351), False, 'from langchain_core.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate\n'), ((3365, 3420), 'langchain_core.prompts.chat.HumanMessagePromptTemplate.from_template', 'HumanMessagePromptTemplate.from_template', (['human_message'], {}), '(human_message)\n', (3405, 3420), False, 'from langchain_core.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate\n')] |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 2023
# SPDX-License-Identifier: Apache-2.0
from typing import Any, Dict, List, Optional
from langchain.agents import tool
from langchain.chains.base import Chain
from langchain.chains import LLMChain
from langchain import PromptTemplate
from langchain.callbacks.manager import (
AsyncCallbackManagerForChainRun,
CallbackManagerForChainRun,
)
import chainlit as cl
from chainlit.context import context
from chainlit import run_sync
from tabulate import tabulate
from ..llm import get_bedrock_text, get_processed_prompt_template
from .graph import GraphChain
def get_tool_metadata():
return {
"name": "3dview",
"description": "Useful to teleport in 3D viewer to the equipment the user is interested in. \
Input to this tool should be the entityId of the equipment. \
Output is a string to confirm whether the view is found or not.",
}
@tool
def run(input: str) -> str:
"""Identify the location of the object user is asking about."""
point_camera_to_entity(input)
return 'Found it!'
def point_camera_to_entity(entityId):
run_sync(context.session.emit('view', entityId))
ENTITY_EXTRACTION_PROMPT = """
Your job is to identify the entity user is asking about based on the user question.
Use the following format:
Question: the input question from the user
Entity: the phrase about the entity in the original question
Only output the entity phrase, do not repeat the question.
Here are some examples:
Question: teleport me to the cookie line in alarm state
Entity: the cookie line in alarm state
Question: show me the freezer tunnel
Entity: the freezer tunnel
Question: show me the conveyer belt
Entity: the conveyer belt
Now begin!
Question: {question}
Entity:
"""
class EntityExtractorChain(Chain):
"""Chain to find the entity in the question."""
llm_chain: LLMChain
@property
def input_keys(self) -> List[str]:
return ['question']
@property
def output_keys(self) -> List[str]:
return ['entity']
@classmethod
def create(cls, **kwargs):
llm = get_bedrock_text()
prompt = PromptTemplate(
template=get_processed_prompt_template(ENTITY_EXTRACTION_PROMPT),
input_variables=["question"],
)
llm_chain = LLMChain(
llm=llm,
prompt=prompt,
**kwargs)
return cls(llm_chain=llm_chain)
def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
callbacks = _run_manager.get_child()
output = self.llm_chain.run(callbacks=callbacks, **inputs)
return {
'entity': output
}
async def _acall(
self,
inputs: Dict[str, Any],
run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
callbacks = _run_manager.get_child()
output = await self.llm_chain.arun(callbacks=callbacks, **inputs)
return {
'entity': output
}
class ViewChain(Chain):
"""Chain that manipulates 3D viewer."""
entity_extractor: EntityExtractorChain
entity_lookup: GraphChain
@property
def input_keys(self) -> List[str]:
return ['question']
@property
def output_keys(self) -> List[str]:
return ['text', 'selected_entity']
@classmethod
def create(cls, **kwargs):
entity_extractor = EntityExtractorChain.create(**kwargs)
entity_lookup = GraphChain.create(**kwargs)
return cls(entity_extractor=entity_extractor, entity_lookup=entity_lookup, **kwargs)
def pick_entity(self, entities):
if entities.shape[0] > 1:
headers = ['No', 'Name', 'Id']
rows = [[i + 1, row.entityName, row.entityId] for i, row in entities.items()]
entity_table = tabulate(rows, headers=headers, tablefmt="pipe")
run_sync(cl.Message(content="I've found these matching entities:\n\n" + entity_table).send())
res = run_sync(cl.AskUserMessage(content="Which one do you mean?").send())
if res is not None:
# TODO: use a LLMChain to parse the user input
idx = int(res['content']) - 1
entityId = entities.iloc[idx].entityId
else:
entityId = None
else:
entityId = entities.iloc[0].entityId
return entityId
async def apick_entity(self, entities):
if entities.shape[0] > 1:
headers = ['No', 'Name', 'Id']
rows = [[i + 1, row.entityName, row.entityId] for i, row in entities.items()]
entity_table = tabulate(rows, headers=headers, tablefmt="pipe")
await cl.Message(content="I've found these matching entities:\n\n" + entity_table).send()
res = await cl.AskUserMessage(content="Which one do you mean?").send()
if res is not None:
# TODO: use a LLMChain to parse the user input
idx = int(res['content']) - 1
entityId = entities.iloc[idx].entityId
else:
entityId = None
else:
entityId = entities.iloc[0].entityId
return entityId
def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
callbacks = _run_manager.get_child()
entity = self.entity_extractor.run(callbacks=callbacks, **inputs)
df = self.entity_lookup.run(
callbacks,
{
"question": "Find all entities matching the description: " + entity,
"format_output": False
})
# TODO: handle the column detection better
if df.shape[0] < 1 or df.columns[0] != 'e':
return {
'text': "I didn't find any result.",
'selected_entity': ''
}
entities = df[df.columns[0]]
entityId = self.pick_entity(entities)
if entityId is None:
return {
'text': "I didn't find any result.",
'selected_entity': ''
}
point_camera_to_entity(entityId)
return {
'text': f"I've pointed you to the {entityId} in the 3D Viewer.",
'selected_entity': entityId
}
async def _acall(
self,
inputs: Dict[str, Any],
run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
) -> Dict[str, Any]:
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
callbacks = _run_manager.get_child()
entity = await self.entity_extractor.arun(callbacks=callbacks, **inputs)
df = await self.entity_lookup.arun(
**{
"question": "Find all entities matching the description: " + entity,
"format_output": False
})
# TODO: handle the column detection better
if df.shape[0] < 1 or df.columns[0] != 'e':
return {
'text': "I didn't find any result.",
'selected_entity': ''
}
entities = df[df.columns[0]]
entityId = await self.apick_entity(entities)
if entityId is None:
return {
'text': "I didn't find any result.",
'selected_entity': ''
}
point_camera_to_entity(entityId)
return {
'text': f"I've pointed you to the {entityId} in the 3D Viewer.",
'selected_entity': entityId
}
| [
"langchain.chains.LLMChain",
"langchain.callbacks.manager.CallbackManagerForChainRun.get_noop_manager"
] | [((1178, 1216), 'chainlit.context.context.session.emit', 'context.session.emit', (['"""view"""', 'entityId'], {}), "('view', entityId)\n", (1198, 1216), False, 'from chainlit.context import context\n'), ((2370, 2412), 'langchain.chains.LLMChain', 'LLMChain', ([], {'llm': 'llm', 'prompt': 'prompt'}), '(llm=llm, prompt=prompt, **kwargs)\n', (2378, 2412), False, 'from langchain.chains import LLMChain\n'), ((2681, 2726), 'langchain.callbacks.manager.CallbackManagerForChainRun.get_noop_manager', 'CallbackManagerForChainRun.get_noop_manager', ([], {}), '()\n', (2724, 2726), False, 'from langchain.callbacks.manager import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun\n'), ((3098, 3143), 'langchain.callbacks.manager.CallbackManagerForChainRun.get_noop_manager', 'CallbackManagerForChainRun.get_noop_manager', ([], {}), '()\n', (3141, 3143), False, 'from langchain.callbacks.manager import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun\n'), ((4150, 4198), 'tabulate.tabulate', 'tabulate', (['rows'], {'headers': 'headers', 'tablefmt': '"""pipe"""'}), "(rows, headers=headers, tablefmt='pipe')\n", (4158, 4198), False, 'from tabulate import tabulate\n'), ((5033, 5081), 'tabulate.tabulate', 'tabulate', (['rows'], {'headers': 'headers', 'tablefmt': '"""pipe"""'}), "(rows, headers=headers, tablefmt='pipe')\n", (5041, 5081), False, 'from tabulate import tabulate\n'), ((5864, 5909), 'langchain.callbacks.manager.CallbackManagerForChainRun.get_noop_manager', 'CallbackManagerForChainRun.get_noop_manager', ([], {}), '()\n', (5907, 5909), False, 'from langchain.callbacks.manager import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun\n'), ((7168, 7213), 'langchain.callbacks.manager.CallbackManagerForChainRun.get_noop_manager', 'CallbackManagerForChainRun.get_noop_manager', ([], {}), '()\n', (7211, 7213), False, 'from langchain.callbacks.manager import AsyncCallbackManagerForChainRun, CallbackManagerForChainRun\n'), ((4233, 4309), 'chainlit.Message', 'cl.Message', ([], {'content': '("I\'ve found these matching entities:\\n\\n" + entity_table)'}), '(content="I\'ve found these matching entities:\\n\\n" + entity_table)\n', (4243, 4309), True, 'import chainlit as cl\n'), ((4358, 4409), 'chainlit.AskUserMessage', 'cl.AskUserMessage', ([], {'content': '"""Which one do you mean?"""'}), "(content='Which one do you mean?')\n", (4375, 4409), True, 'import chainlit as cl\n'), ((5113, 5189), 'chainlit.Message', 'cl.Message', ([], {'content': '("I\'ve found these matching entities:\\n\\n" + entity_table)'}), '(content="I\'ve found these matching entities:\\n\\n" + entity_table)\n', (5123, 5189), True, 'import chainlit as cl\n'), ((5234, 5285), 'chainlit.AskUserMessage', 'cl.AskUserMessage', ([], {'content': '"""Which one do you mean?"""'}), "(content='Which one do you mean?')\n", (5251, 5285), True, 'import chainlit as cl\n')] |
from langchain.retrievers import AmazonKendraRetriever
from langchain.chains import RetrievalQA
from langchain import OpenAI
from langchain.prompts import PromptTemplate
from langchain import SagemakerEndpoint
from langchain.llms.sagemaker_endpoint import LLMContentHandler
import json
import os
def build_chain():
region = os.environ["AWS_REGION"]
kendra_index_id = os.environ["KENDRA_INDEX_ID"]
endpoint_name = os.environ["FALCON_40B_ENDPOINT"]
inference_component_name = os.environ["INFERENCE_COMPONENT_NAME"]
class ContentHandler(LLMContentHandler):
content_type = "application/json"
accepts = "application/json"
def transform_input(self, prompt: str, model_kwargs: dict) -> bytes:
input_str = json.dumps({"inputs": prompt, "parameters": model_kwargs})
return input_str.encode('utf-8')
def transform_output(self, output: bytes) -> str:
response_json = json.loads(output.read().decode("utf-8"))
print(response_json)
return response_json[0]["generated_text"]
content_handler = ContentHandler()
if 'inference_component_name' in locals():
llm=SagemakerEndpoint(
endpoint_name=endpoint_name,
region_name=region,
model_kwargs={"max_new_tokens": 1500, "top_p": 0.8,"temperature":0.6},
endpoint_kwargs={"CustomAttributes":"accept_eula=true",
"InferenceComponentName":inference_component_name},
content_handler=content_handler,
)
else :
llm=SagemakerEndpoint(
endpoint_name=endpoint_name,
region_name=region,
model_kwargs={"max_new_tokens": 1500, "top_p": 0.8,"temperature":0.6},
content_handler=content_handler,
)
retriever = AmazonKendraRetriever(index_id=kendra_index_id,region_name=region)
prompt_template = """
The following is a friendly conversation between a human and an AI.
The AI is talkative and provides lots of specific details from its context.
If the AI does not know the answer to a question, it truthfully says it
does not know.
{context}
Instruction: Based on the above documents, provide a detailed answer for, {question} Answer "don't know"
if not present in the document.
Solution:"""
PROMPT = PromptTemplate(
template=prompt_template, input_variables=["context", "question"]
)
chain_type_kwargs = {"prompt": PROMPT}
qa = RetrievalQA.from_chain_type(
llm,
chain_type="stuff",
retriever=retriever,
chain_type_kwargs=chain_type_kwargs,
return_source_documents=True
)
return qa
def run_chain(chain, prompt: str, history=[]):
result = chain(prompt)
# To make it compatible with chat samples
return {
"answer": result['result'],
"source_documents": result['source_documents']
}
if __name__ == "__main__":
chain = build_chain()
result = run_chain(chain, "What's SageMaker?")
print(result['answer'])
if 'source_documents' in result:
print('Sources:')
for d in result['source_documents']:
print(d.metadata['source'])
| [
"langchain.SagemakerEndpoint",
"langchain.retrievers.AmazonKendraRetriever",
"langchain.prompts.PromptTemplate",
"langchain.chains.RetrievalQA.from_chain_type"
] | [((1839, 1906), 'langchain.retrievers.AmazonKendraRetriever', 'AmazonKendraRetriever', ([], {'index_id': 'kendra_index_id', 'region_name': 'region'}), '(index_id=kendra_index_id, region_name=region)\n', (1860, 1906), False, 'from langchain.retrievers import AmazonKendraRetriever\n'), ((2373, 2458), 'langchain.prompts.PromptTemplate', 'PromptTemplate', ([], {'template': 'prompt_template', 'input_variables': "['context', 'question']"}), "(template=prompt_template, input_variables=['context',\n 'question'])\n", (2387, 2458), False, 'from langchain.prompts import PromptTemplate\n'), ((2521, 2665), 'langchain.chains.RetrievalQA.from_chain_type', 'RetrievalQA.from_chain_type', (['llm'], {'chain_type': '"""stuff"""', 'retriever': 'retriever', 'chain_type_kwargs': 'chain_type_kwargs', 'return_source_documents': '(True)'}), "(llm, chain_type='stuff', retriever=retriever,\n chain_type_kwargs=chain_type_kwargs, return_source_documents=True)\n", (2548, 2665), False, 'from langchain.chains import RetrievalQA\n'), ((1186, 1485), 'langchain.SagemakerEndpoint', 'SagemakerEndpoint', ([], {'endpoint_name': 'endpoint_name', 'region_name': 'region', 'model_kwargs': "{'max_new_tokens': 1500, 'top_p': 0.8, 'temperature': 0.6}", 'endpoint_kwargs': "{'CustomAttributes': 'accept_eula=true', 'InferenceComponentName':\n inference_component_name}", 'content_handler': 'content_handler'}), "(endpoint_name=endpoint_name, region_name=region,\n model_kwargs={'max_new_tokens': 1500, 'top_p': 0.8, 'temperature': 0.6},\n endpoint_kwargs={'CustomAttributes': 'accept_eula=true',\n 'InferenceComponentName': inference_component_name}, content_handler=\n content_handler)\n", (1203, 1485), False, 'from langchain import SagemakerEndpoint\n'), ((1590, 1770), 'langchain.SagemakerEndpoint', 'SagemakerEndpoint', ([], {'endpoint_name': 'endpoint_name', 'region_name': 'region', 'model_kwargs': "{'max_new_tokens': 1500, 'top_p': 0.8, 'temperature': 0.6}", 'content_handler': 'content_handler'}), "(endpoint_name=endpoint_name, region_name=region,\n model_kwargs={'max_new_tokens': 1500, 'top_p': 0.8, 'temperature': 0.6},\n content_handler=content_handler)\n", (1607, 1770), False, 'from langchain import SagemakerEndpoint\n'), ((758, 816), 'json.dumps', 'json.dumps', (["{'inputs': prompt, 'parameters': model_kwargs}"], {}), "({'inputs': prompt, 'parameters': model_kwargs})\n", (768, 816), False, 'import json\n')] |
from typing import List, Optional
from langchain.docstore.document import Document
from langchain.document_loaders.base import BaseLoader
from langchain.utilities.arxiv import ArxivAPIWrapper
class ArxivLoader(BaseLoader):
"""Load a query result from `Arxiv`.
The loader converts the original PDF format into the text.
"""
def __init__(
self,
query: str,
load_max_docs: Optional[int] = 100,
load_all_available_meta: Optional[bool] = False,
):
self.query = query
"""The query to be passed to the arxiv.org API."""
self.load_max_docs = load_max_docs
"""The maximum number of documents to load."""
self.load_all_available_meta = load_all_available_meta
"""Whether to load all available metadata."""
def load(self) -> List[Document]:
arxiv_client = ArxivAPIWrapper(
load_max_docs=self.load_max_docs,
load_all_available_meta=self.load_all_available_meta,
)
docs = arxiv_client.load(self.query)
return docs
| [
"langchain.utilities.arxiv.ArxivAPIWrapper"
] | [((863, 971), 'langchain.utilities.arxiv.ArxivAPIWrapper', 'ArxivAPIWrapper', ([], {'load_max_docs': 'self.load_max_docs', 'load_all_available_meta': 'self.load_all_available_meta'}), '(load_max_docs=self.load_max_docs, load_all_available_meta=\n self.load_all_available_meta)\n', (878, 971), False, 'from langchain.utilities.arxiv import ArxivAPIWrapper\n')] |
# flake8: noqa
from langchain_core.prompts.prompt import PromptTemplate
API_URL_PROMPT_TEMPLATE = """You are given the below API Documentation:
{api_docs}
Using this documentation, generate the full API url to call for answering the user question.
You should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
Question:{question}
API url:"""
API_URL_PROMPT = PromptTemplate(
input_variables=[
"api_docs",
"question",
],
template=API_URL_PROMPT_TEMPLATE,
)
API_RESPONSE_PROMPT_TEMPLATE = (
API_URL_PROMPT_TEMPLATE
+ """ {api_url}
Here is the response from the API:
{api_response}
Summarize this response to answer the original question.
Summary:"""
)
API_RESPONSE_PROMPT = PromptTemplate(
input_variables=["api_docs", "question", "api_url", "api_response"],
template=API_RESPONSE_PROMPT_TEMPLATE,
)
| [
"langchain_core.prompts.prompt.PromptTemplate"
] | [((542, 637), 'langchain_core.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['api_docs', 'question']", 'template': 'API_URL_PROMPT_TEMPLATE'}), "(input_variables=['api_docs', 'question'], template=\n API_URL_PROMPT_TEMPLATE)\n", (556, 637), False, 'from langchain_core.prompts.prompt import PromptTemplate\n'), ((897, 1023), 'langchain_core.prompts.prompt.PromptTemplate', 'PromptTemplate', ([], {'input_variables': "['api_docs', 'question', 'api_url', 'api_response']", 'template': 'API_RESPONSE_PROMPT_TEMPLATE'}), "(input_variables=['api_docs', 'question', 'api_url',\n 'api_response'], template=API_RESPONSE_PROMPT_TEMPLATE)\n", (911, 1023), False, 'from langchain_core.prompts.prompt import PromptTemplate\n')] |