Datasets:

mole-code

/

llama_index-data

like 0

#!/usr/bin/env python3 from dataclasses import dataclass, field from typing import cast from loguru import logger from llama_index.core import Document, VectorStoreIndex, Settings from llama_index.core.query_engine import CitationQueryEngine import nest_asyncio from uglychain import Model, Retriever, StorageRetriever from uglychain.storage import Storage, SQLiteStorage from uglychain.llm.llama_index import LlamaIndexLLM import sys import logging logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) nest_asyncio.apply() Settings.llm = LlamaIndexLLM(model=Model.GPT3_TURBO) @dataclass class GithubIndex: filename: str = "data/github/github.db" model: Model = Model.DEFAULT summarizer_db: Storage = field(init=False) retriever: StorageRetriever = field(init=False) def __post_init__(self): self.summarizer_db = SQLiteStorage(self.filename, "ReadmeSummarizer", 30) self.retriever = Retriever.LlamaIndex.getStorage( persist_dir="./data/github/repos" ) if self._need_update: self._update() def search(self, query: str): index = cast(VectorStoreIndex, self.retriever.index) # type: ignore query_engine = CitationQueryEngine.from_args(index, similarity_top_k=5) # query_engine = index.as_query_engine(llm=LlamaIndexLLM(Model.GPT3_TURBO), similarity_top_k=8) # type: ignore return query_engine.query(query) # self.retriever.get(query, "refine") @property def _need_update(self): return False def _update(self): doc_chunks = [] data = self.summarizer_db.load(condition="timestamp = date('now','localtime')") for key, value in data.items(): doc = Document(text=value, doc_id=key) doc_chunks.append(doc) index = cast(VectorStoreIndex, self.retriever.index) # type: ignore logger.info("refresh_ref_docs") index.refresh_ref_docs(doc_chunks) self.retriever.storage.save(index) logger.info("refresh_ref_docs done") if __name__ == "__main__": index = GithubIndex() result = index.search("给我介绍几个关于使用大模型自动写代码的项目吧！") # logger.debug(result.source_nodes) logger.info(result)

[((454, 512), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (473, 512), False, 'import logging\n'), ((587, 607), 'nest_asyncio.apply', 'nest_asyncio.apply', ([], {}), '()\n', (605, 607), False, 'import nest_asyncio\n'), ((623, 660), 'uglychain.llm.llama_index.LlamaIndexLLM', 'LlamaIndexLLM', ([], {'model': 'Model.GPT3_TURBO'}), '(model=Model.GPT3_TURBO)\n', (636, 660), False, 'from uglychain.llm.llama_index import LlamaIndexLLM\n'), ((544, 584), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (565, 584), False, 'import logging\n'), ((799, 816), 'dataclasses.field', 'field', ([], {'init': '(False)'}), '(init=False)\n', (804, 816), False, 'from dataclasses import dataclass, field\n'), ((851, 868), 'dataclasses.field', 'field', ([], {'init': '(False)'}), '(init=False)\n', (856, 868), False, 'from dataclasses import dataclass, field\n'), ((2276, 2295), 'loguru.logger.info', 'logger.info', (['result'], {}), '(result)\n', (2287, 2295), False, 'from loguru import logger\n'), ((513, 532), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (530, 532), False, 'import logging\n'), ((928, 980), 'uglychain.storage.SQLiteStorage', 'SQLiteStorage', (['self.filename', '"""ReadmeSummarizer"""', '(30)'], {}), "(self.filename, 'ReadmeSummarizer', 30)\n", (941, 980), False, 'from uglychain.storage import Storage, SQLiteStorage\n'), ((1006, 1072), 'uglychain.Retriever.LlamaIndex.getStorage', 'Retriever.LlamaIndex.getStorage', ([], {'persist_dir': '"""./data/github/repos"""'}), "(persist_dir='./data/github/repos')\n", (1037, 1072), False, 'from uglychain import Model, Retriever, StorageRetriever\n'), ((1203, 1247), 'typing.cast', 'cast', (['VectorStoreIndex', 'self.retriever.index'], {}), '(VectorStoreIndex, self.retriever.index)\n', (1207, 1247), False, 'from typing import cast\n'), ((1287, 1343), 'llama_index.core.query_engine.CitationQueryEngine.from_args', 'CitationQueryEngine.from_args', (['index'], {'similarity_top_k': '(5)'}), '(index, similarity_top_k=5)\n', (1316, 1343), False, 'from llama_index.core.query_engine import CitationQueryEngine\n'), ((1892, 1936), 'typing.cast', 'cast', (['VectorStoreIndex', 'self.retriever.index'], {}), '(VectorStoreIndex, self.retriever.index)\n', (1896, 1936), False, 'from typing import cast\n'), ((1961, 1992), 'loguru.logger.info', 'logger.info', (['"""refresh_ref_docs"""'], {}), "('refresh_ref_docs')\n", (1972, 1992), False, 'from loguru import logger\n'), ((2087, 2123), 'loguru.logger.info', 'logger.info', (['"""refresh_ref_docs done"""'], {}), "('refresh_ref_docs done')\n", (2098, 2123), False, 'from loguru import logger\n'), ((1808, 1840), 'llama_index.core.Document', 'Document', ([], {'text': 'value', 'doc_id': 'key'}), '(text=value, doc_id=key)\n', (1816, 1840), False, 'from llama_index.core import Document, VectorStoreIndex, Settings\n')]

from llama_index.core import SimpleDirectoryReader from llama_index.core.node_parser import SentenceSplitter from llama_index.extractors.entity import EntityExtractor reader = SimpleDirectoryReader('files') documents = reader.load_data() parser = SentenceSplitter(include_prev_next_rel=True) nodes = parser.get_nodes_from_documents(documents) entity_extractor = EntityExtractor( label_entities = True, device = "cpu" ) metadata_list = entity_extractor.extract(nodes) print(metadata_list)

[((177, 207), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""files"""'], {}), "('files')\n", (198, 207), False, 'from llama_index.core import SimpleDirectoryReader\n'), ((248, 292), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {'include_prev_next_rel': '(True)'}), '(include_prev_next_rel=True)\n', (264, 292), False, 'from llama_index.core.node_parser import SentenceSplitter\n'), ((364, 414), 'llama_index.extractors.entity.EntityExtractor', 'EntityExtractor', ([], {'label_entities': '(True)', 'device': '"""cpu"""'}), "(label_entities=True, device='cpu')\n", (379, 414), False, 'from llama_index.extractors.entity import EntityExtractor\n')]

from llama_index.llms.llama_cpp import LlamaCPP from llama_index.llms.llama_cpp.llama_utils import ( messages_to_prompt, completion_to_prompt, ) from llama_index.llms.openai import OpenAI from core.manager import settings MODEL = "openai" # LLM selection if MODEL == "openai": print("USE OPENAI") # Use OpenAI model system_prompt = """If the user is greeting then respond by saying, "Hello, how may we help you ?" """ llm = OpenAI(model="gpt-4-turbo-preview", api_key=settings.OPENAI_KEY, system_prompt=system_prompt) else: # Default to Llama print("USE LLAMA") # model_url: str = "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGUF/resolve/main/llama-2-13b-chat.Q4_0.gguf" model_path: str = "core/models/llama-2-13b-chat.Q2_K.gguf" # TODO: Save the model automatically the first time # Check if model is already downloaded # if not os.path.exists(model_path): # print("Model not found. Downloading...") # response = requests.get(model_url) # with open(model_path, "wb") as f: # f.write(response.content) # print("Model downloaded and saved.") # else: # print("Model found.") llm = LlamaCPP( # model_url=model_url, model_path=model_path, temperature=0.1, max_new_tokens=256, context_window=3900, model_kwargs={"n_gpu_layers": 2}, # set GPU layers to 1 if you have one verbose=True, messages_to_prompt=messages_to_prompt, # providing additional parameters completion_to_prompt=completion_to_prompt, # providing additional parameters ) if __name__ == "__main__": print("LLM")

[((470, 567), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4-turbo-preview"""', 'api_key': 'settings.OPENAI_KEY', 'system_prompt': 'system_prompt'}), "(model='gpt-4-turbo-preview', api_key=settings.OPENAI_KEY,\n system_prompt=system_prompt)\n", (476, 567), False, 'from llama_index.llms.openai import OpenAI\n'), ((1219, 1451), 'llama_index.llms.llama_cpp.LlamaCPP', 'LlamaCPP', ([], {'model_path': 'model_path', 'temperature': '(0.1)', 'max_new_tokens': '(256)', 'context_window': '(3900)', 'model_kwargs': "{'n_gpu_layers': 2}", 'verbose': '(True)', 'messages_to_prompt': 'messages_to_prompt', 'completion_to_prompt': 'completion_to_prompt'}), "(model_path=model_path, temperature=0.1, max_new_tokens=256,\n context_window=3900, model_kwargs={'n_gpu_layers': 2}, verbose=True,\n messages_to_prompt=messages_to_prompt, completion_to_prompt=\n completion_to_prompt)\n", (1227, 1451), False, 'from llama_index.llms.llama_cpp import LlamaCPP\n')]

from llama_index import SimpleDirectoryReader,VectorStoreIndex , load_index_from_storage from llama_index.storage.storage_context import StorageContext from dotenv import load_dotenv import logging import sys load_dotenv() # enable INFO level logging logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) async def load_index(directory_path : str = r'data'): documents = SimpleDirectoryReader(directory_path, filename_as_id=True).load_data() print(f"loaded documents with {len(documents)} pages") try: # Rebuild storage context storage_context = StorageContext.from_defaults(persist_dir="./storage") # Try to load the index from storage index = load_index_from_storage(storage_context) logging.info("Index loaded from storage.") except FileNotFoundError: logging.info("Index not found. Creating a new one...") index = VectorStoreIndex.from_documents(documents) # Persist index to disk index.storage_context.persist() logging.info("New index created and persisted to storage.") return index async def update_index(directory_path : str = r'data'): try: documents = SimpleDirectoryReader(directory_path, filename_as_id=True).load_data() except FileNotFoundError: logging.error("Invalid document directory path.") return None try: # Rebuild storage context storage_context = StorageContext.from_defaults(persist_dir="./storage") # Try to load the index from storage index = load_index_from_storage(storage_context) logging.info("Existing index loaded from storage.") refreshed_docs = index.refresh_ref_docs(documents, update_kwargs={"delete_kwargs": {"delete_from_docstore": True}}) # index.update_ref_doc() print(refreshed_docs) print('Number of newly inserted/refreshed docs: ', sum(refreshed_docs)) index.storage_context.persist() logging.info("Index refreshed and persisted to storage.") return refreshed_docs except FileNotFoundError: # Run refresh_ref_docs function to check for document updates logging.error("Index is not created yet.") return None

[((212, 225), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (223, 225), False, 'from dotenv import load_dotenv\n'), ((255, 313), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (274, 313), False, 'import logging\n'), ((345, 385), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (366, 385), False, 'import logging\n'), ((314, 333), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (331, 333), False, 'import logging\n'), ((658, 711), 'llama_index.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""./storage"""'}), "(persist_dir='./storage')\n", (686, 711), False, 'from llama_index.storage.storage_context import StorageContext\n'), ((773, 813), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (796, 813), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, load_index_from_storage\n'), ((822, 864), 'logging.info', 'logging.info', (['"""Index loaded from storage."""'], {}), "('Index loaded from storage.')\n", (834, 864), False, 'import logging\n'), ((1510, 1563), 'llama_index.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""./storage"""'}), "(persist_dir='./storage')\n", (1538, 1563), False, 'from llama_index.storage.storage_context import StorageContext\n'), ((1625, 1665), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (1648, 1665), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, load_index_from_storage\n'), ((1674, 1725), 'logging.info', 'logging.info', (['"""Existing index loaded from storage."""'], {}), "('Existing index loaded from storage.')\n", (1686, 1725), False, 'import logging\n'), ((2042, 2099), 'logging.info', 'logging.info', (['"""Index refreshed and persisted to storage."""'], {}), "('Index refreshed and persisted to storage.')\n", (2054, 2099), False, 'import logging\n'), ((459, 517), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['directory_path'], {'filename_as_id': '(True)'}), '(directory_path, filename_as_id=True)\n', (480, 517), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, load_index_from_storage\n'), ((904, 958), 'logging.info', 'logging.info', (['"""Index not found. Creating a new one..."""'], {}), "('Index not found. Creating a new one...')\n", (916, 958), False, 'import logging\n'), ((975, 1017), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (1006, 1017), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, load_index_from_storage\n'), ((1098, 1157), 'logging.info', 'logging.info', (['"""New index created and persisted to storage."""'], {}), "('New index created and persisted to storage.')\n", (1110, 1157), False, 'import logging\n'), ((1371, 1420), 'logging.error', 'logging.error', (['"""Invalid document directory path."""'], {}), "('Invalid document directory path.')\n", (1384, 1420), False, 'import logging\n'), ((2244, 2286), 'logging.error', 'logging.error', (['"""Index is not created yet."""'], {}), "('Index is not created yet.')\n", (2257, 2286), False, 'import logging\n'), ((1262, 1320), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['directory_path'], {'filename_as_id': '(True)'}), '(directory_path, filename_as_id=True)\n', (1283, 1320), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, load_index_from_storage\n')]

import asyncio from typing import Any, Optional, Sequence from llama_index.evaluation import CorrectnessEvaluator, EvaluationResult from wandbot.evaluation.eval.utils import ( make_eval_template, safe_parse_eval_response, ) SYSTEM_TEMPLATE = """You are a Weight & Biases support expert tasked with evaluating the relevancy of answers to questions asked by users to a technical support chatbot. You are given the following information: - a user query, - a reference answer - a generated answer. Your job is to judge the relevance the generated answer to the user query. - Consider whether the answer addresses all aspects of the question and aligns with the user's intent and provides appropriate and on-topic response. - Measure the generated answer on its sensibleness, meaning it needs to make sense in context and be specific i.e. it is comprehensive without being too vague. - Compare the generated answer to the reference answer for its relevancy, sensibleness and specificity. - Output a score and a decision that represents a holistic evaluation of the generated answer. - You must return your response only in the below mentioned format. Do not return answers in any other format. Follow these guidelines for scoring: - Your score has to be between 1 and 3, where 1 is the worst and 3 is the best. - If the generated answer is not relevant to the user query, you should give a score of 1. - If the generated answer is relevant but contains mistakes or lacks specificity, you should give a score of 2. - If the generated answer is relevant and comprehensive, you should give a score of 3. Output your final verdict by strictly following JSON format: {{ "reason": <<Provide a brief explanation for your decision here>>, "score": <<Provide a score as per the above guidelines>>, "decision": <<Provide your final decision here, either 'relevant', or 'irrelevant'>> }} Example Response 1: {{ "reason": "The generated answer is relevant and provides a similar level of detail as the reference answer. It also provides information that is relevant to the user's query.", "score": 3, "decision": "relevant" }} Example Response 2: {{ "reason": "The generated answer deviates significantly from the reference answer, and is not directly answering the user's query", "score": 1, "decision": "irrelevant" }} Example Response 3: {{ "reason": "The generated answer is relevant and provides a similar level of detail as the reference answer. However, it introduces variations in the code example that are not mentioned in the documentation. This could potentially confuse users if the method is not part of the documented API. "score": 2, "decision": "irrelevant" }} """ USER_TEMPLATE = """ ## User Query {query} ## Reference Answer {reference_answer} ## Generated Answer {generated_answer} """ RELEVANCY_EVAL_TEMPLATE = make_eval_template(SYSTEM_TEMPLATE, USER_TEMPLATE) class WandbRelevancyEvaluator(CorrectnessEvaluator): async def aevaluate( self, query: Optional[str] = None, response: Optional[str] = None, contexts: Optional[Sequence[str]] = None, reference: Optional[str] = None, sleep_time_in_seconds: int = 0, **kwargs: Any, ) -> EvaluationResult: await asyncio.sleep(sleep_time_in_seconds) if query is None or response is None or reference is None: print(query, response, reference, flush=True) raise ValueError("query, response, and reference must be provided") eval_response = await self._service_context.llm.apredict( prompt=self._eval_template, query=query, generated_answer=response, reference_answer=reference, ) passing, reasoning, score = safe_parse_eval_response( eval_response, "relevant" ) return EvaluationResult( query=query, response=response, passing=passing, score=score, feedback=reasoning, )

[((2886, 2936), 'wandbot.evaluation.eval.utils.make_eval_template', 'make_eval_template', (['SYSTEM_TEMPLATE', 'USER_TEMPLATE'], {}), '(SYSTEM_TEMPLATE, USER_TEMPLATE)\n', (2904, 2936), False, 'from wandbot.evaluation.eval.utils import make_eval_template, safe_parse_eval_response\n'), ((3804, 3855), 'wandbot.evaluation.eval.utils.safe_parse_eval_response', 'safe_parse_eval_response', (['eval_response', '"""relevant"""'], {}), "(eval_response, 'relevant')\n", (3828, 3855), False, 'from wandbot.evaluation.eval.utils import make_eval_template, safe_parse_eval_response\n'), ((3894, 3997), 'llama_index.evaluation.EvaluationResult', 'EvaluationResult', ([], {'query': 'query', 'response': 'response', 'passing': 'passing', 'score': 'score', 'feedback': 'reasoning'}), '(query=query, response=response, passing=passing, score=\n score, feedback=reasoning)\n', (3910, 3997), False, 'from llama_index.evaluation import CorrectnessEvaluator, EvaluationResult\n'), ((3303, 3339), 'asyncio.sleep', 'asyncio.sleep', (['sleep_time_in_seconds'], {}), '(sleep_time_in_seconds)\n', (3316, 3339), False, 'import asyncio\n')]

from typing import List from fastapi import APIRouter, Depends, HTTPException, status from llama_index.chat_engine.types import BaseChatEngine from llama_index.llms.base import ChatMessage from llama_index.llms.types import MessageRole from pydantic import BaseModel from app.engine.index import get_chat_engine chat_router = r = APIRouter() class _Message(BaseModel): role: MessageRole content: str context: List[str] | None = None class _ChatData(BaseModel): messages: List[_Message] class _Result(BaseModel): result: _Message @r.post("") async def chat( data: _ChatData, chat_engine: BaseChatEngine = Depends(get_chat_engine), ) -> _Result: # check preconditions and get last message if len(data.messages) == 0: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="No messages provided", ) lastMessage = data.messages.pop() if lastMessage.role != MessageRole.USER: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Last message must be from user", ) # convert messages coming from the request to type ChatMessage messages = [ ChatMessage( role=m.role, content=m.content, ) for m in data.messages ] # query chat engine response = await chat_engine.achat(lastMessage.content, messages) return _Result( result=_Message( role=MessageRole.ASSISTANT, content=response.response, context=[x.text for x in response.source_nodes] ) )

[((332, 343), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (341, 343), False, 'from fastapi import APIRouter, Depends, HTTPException, status\n'), ((647, 671), 'fastapi.Depends', 'Depends', (['get_chat_engine'], {}), '(get_chat_engine)\n', (654, 671), False, 'from fastapi import APIRouter, Depends, HTTPException, status\n'), ((780, 870), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': 'status.HTTP_400_BAD_REQUEST', 'detail': '"""No messages provided"""'}), "(status_code=status.HTTP_400_BAD_REQUEST, detail=\n 'No messages provided')\n", (793, 870), False, 'from fastapi import APIRouter, Depends, HTTPException, status\n'), ((998, 1098), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': 'status.HTTP_400_BAD_REQUEST', 'detail': '"""Last message must be from user"""'}), "(status_code=status.HTTP_400_BAD_REQUEST, detail=\n 'Last message must be from user')\n", (1011, 1098), False, 'from fastapi import APIRouter, Depends, HTTPException, status\n'), ((1221, 1264), 'llama_index.llms.base.ChatMessage', 'ChatMessage', ([], {'role': 'm.role', 'content': 'm.content'}), '(role=m.role, content=m.content)\n', (1232, 1264), False, 'from llama_index.llms.base import ChatMessage\n')]

from pymongo import MongoClient from llama_index.storage.docstore.mongodb import MongoDocumentStore from llama_index.storage.docstore.mongodb.base import MongoDBKVStore import os import streamlit as st DEFAULT_DB_NAME: str = "aegis-athena-data" @st.cache_resource def get_client() -> MongoClient: return MongoClient( host=os.getenv("MONGODB_HOST"), port=int(os.getenv("MONGODB_PORT")), ) def as_docstore(client: MongoClient, db_name: str = DEFAULT_DB_NAME) -> MongoDocumentStore: return MongoDocumentStore( mongo_kvstore=MongoDBKVStore( mongo_client=client, db_name=db_name, ), )

[((338, 363), 'os.getenv', 'os.getenv', (['"""MONGODB_HOST"""'], {}), "('MONGODB_HOST')\n", (347, 363), False, 'import os\n'), ((563, 615), 'llama_index.storage.docstore.mongodb.base.MongoDBKVStore', 'MongoDBKVStore', ([], {'mongo_client': 'client', 'db_name': 'db_name'}), '(mongo_client=client, db_name=db_name)\n', (577, 615), False, 'from llama_index.storage.docstore.mongodb.base import MongoDBKVStore\n'), ((382, 407), 'os.getenv', 'os.getenv', (['"""MONGODB_PORT"""'], {}), "('MONGODB_PORT')\n", (391, 407), False, 'import os\n')]

import os from llama_index import LLMPredictor, VectorStoreIndex, SimpleDirectoryReader, ServiceContext, LangchainEmbedding from langchain.embeddings import OpenAIEmbeddings from langchain.llms import AzureOpenAI import openai import logging import sys #llamaindex logs logging.basicConfig(stream=sys.stdout, level=logging.INFO) # logging.DEBUG for more verbose output logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) #Enable to show openai logs #openai.log='debug' #Based on your settings, see version, base, key in your Azure AI portal api_type = "azure" api_version = "2023-03-15-preview" api_base = os.getenv("AZURE_API_BASE") api_key = os.getenv("AZURE_API_KEY") chat_deployment = "gpt35" embedding_deployment= "text-embedding-ada-002" # Chat model llm = AzureOpenAI(deployment_name=chat_deployment, openai_api_base=api_base, openai_api_key=api_key, model_kwargs={ "api_type": api_type, "api_version": api_version, }) llm_predictor = LLMPredictor(llm=llm) # Embedding model embedding_llm = LangchainEmbedding( OpenAIEmbeddings( model=embedding_deployment, deployment=embedding_deployment, openai_api_key=api_key, openai_api_base=api_base, openai_api_type=api_type, openai_api_version=api_version, ), embed_batch_size=1 ) #load docs documents = SimpleDirectoryReader('local-data').load_data() service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, embed_model=embedding_llm) index = VectorStoreIndex.from_documents(documents, service_context=service_context) index.storage_context.persist(persist_dir="local-index-azure") print("Saved embeddings")

[((271, 329), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (290, 329), False, 'import logging\n'), ((630, 657), 'os.getenv', 'os.getenv', (['"""AZURE_API_BASE"""'], {}), "('AZURE_API_BASE')\n", (639, 657), False, 'import os\n'), ((668, 694), 'os.getenv', 'os.getenv', (['"""AZURE_API_KEY"""'], {}), "('AZURE_API_KEY')\n", (677, 694), False, 'import os\n'), ((788, 955), 'langchain.llms.AzureOpenAI', 'AzureOpenAI', ([], {'deployment_name': 'chat_deployment', 'openai_api_base': 'api_base', 'openai_api_key': 'api_key', 'model_kwargs': "{'api_type': api_type, 'api_version': api_version}"}), "(deployment_name=chat_deployment, openai_api_base=api_base,\n openai_api_key=api_key, model_kwargs={'api_type': api_type,\n 'api_version': api_version})\n", (799, 955), False, 'from langchain.llms import AzureOpenAI\n'), ((975, 996), 'llama_index.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (987, 996), False, 'from llama_index import LLMPredictor, VectorStoreIndex, SimpleDirectoryReader, ServiceContext, LangchainEmbedding\n'), ((1414, 1503), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'embed_model': 'embedding_llm'}), '(llm_predictor=llm_predictor, embed_model=\n embedding_llm)\n', (1442, 1503), False, 'from llama_index import LLMPredictor, VectorStoreIndex, SimpleDirectoryReader, ServiceContext, LangchainEmbedding\n'), ((1508, 1583), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (1539, 1583), False, 'from llama_index import LLMPredictor, VectorStoreIndex, SimpleDirectoryReader, ServiceContext, LangchainEmbedding\n'), ((401, 441), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (422, 441), False, 'import logging\n'), ((1056, 1250), 'langchain.embeddings.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {'model': 'embedding_deployment', 'deployment': 'embedding_deployment', 'openai_api_key': 'api_key', 'openai_api_base': 'api_base', 'openai_api_type': 'api_type', 'openai_api_version': 'api_version'}), '(model=embedding_deployment, deployment=\n embedding_deployment, openai_api_key=api_key, openai_api_base=api_base,\n openai_api_type=api_type, openai_api_version=api_version)\n', (1072, 1250), False, 'from langchain.embeddings import OpenAIEmbeddings\n'), ((370, 389), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (387, 389), False, 'import logging\n'), ((1347, 1382), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""local-data"""'], {}), "('local-data')\n", (1368, 1382), False, 'from llama_index import LLMPredictor, VectorStoreIndex, SimpleDirectoryReader, ServiceContext, LangchainEmbedding\n')]

import time import os import streamlit as st import openai import logging import sys import llama_index from qdrant_client import QdrantClient from llama_index import VectorStoreIndex, ServiceContext from llama_index.llms import OpenAI from llama_index import SimpleDirectoryReader from llama_index.storage.storage_context import StorageContext from llama_index.vector_stores.qdrant import QdrantVectorStore from llama_index import set_global_service_context from llama_index.embeddings import VoyageEmbedding from qdrant_client.models import Distance, VectorParams version = "1.0.2" st.set_page_config(page_title=f"Courier v{version}", page_icon="🌎", layout="centered", initial_sidebar_state="auto", menu_items=None) st.title(f"Courier v{version}") # Set up logging and tracing via Arize Phoenix logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) # Use Voyager Lite Embeddings model_name = "voyage-lite-01-instruct" voyage_api_key = os.environ.get("VOYAGE_API_KEY", "") embed_model = VoyageEmbedding( model_name=model_name, voyage_api_key=voyage_api_key ) # Update Custom QA Template with Gaia Information if "messages" not in st.session_state.keys(): # Initialize the chat messages history st.session_state.messages = [ {"role": "assistant", "content": "Hello, my name is Courier. I'm an Generative AI Assistant designed to help Proctor Academy students. Ask me anything about the Proctor Handbook or any current Proctor Academy staff."} ] openai.api_key = "" @st.cache_resource(show_spinner=False) def load_data(): with st.spinner(text=f"Loading Courier v{version} ..."): docs = SimpleDirectoryReader(input_dir="./data", recursive=True).load_data() qdrant_client = QdrantClient( url="https://02aec354-4932-4062-9e00-422eacb506fc.us-east4-0.gcp.cloud.qdrant.io", api_key="", ) qdrant_client.create_collection(collection_name="courierv52",vectors_config=VectorParams(size=1024, distance=Distance.EUCLID),) service_context = ServiceContext.from_defaults(embed_model=embed_model,llm=OpenAI(model="gpt-4", max_tokens=1500, temperature=0.5, system_prompt="Keep your answers technical and based on facts and do not hallucinate in responses. In addition, make sure all responses look natural, no Answer: or Query: in the response. Always attempt to query database.")) set_global_service_context(service_context) vector_store = QdrantVectorStore(client=qdrant_client, collection_name="courierv52") storage_context = StorageContext.from_defaults(vector_store=vector_store) index = VectorStoreIndex.from_documents( docs, storage_context=storage_context, service_context=service_context, ) return index index = load_data() if "chat_engine" not in st.session_state.keys(): # Initialize the chat engine st.session_state.chat_engine = index.as_chat_engine(streaming=True,chat_mode="condense_question",max_tokens=1500,verbose=True) if prompt := st.chat_input("Your question"): # Prompt for user input and save to chat history st.session_state.messages.append({"role": "user", "content": prompt}) for message in st.session_state.messages: # Display the prior chat messages with st.chat_message(message["role"]): st.write(message["content"]) # If last message is not from assistant, generate a new response if st.session_state.messages[-1]["role"] != "assistant": with st.chat_message("assistant"): res_box = st.empty() # Placeholder for the response text with st.spinner("Thinking..."): response = st.session_state.chat_engine.stream_chat(prompt) full_response = "" for token in response.response_gen: full_response += "".join(token) res_box.write(full_response) message = {"role": "assistant", "content": response.response} st.session_state.messages.append(message)

[((585, 723), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': 'f"""Courier v{version}"""', 'page_icon': '"""🌎"""', 'layout': '"""centered"""', 'initial_sidebar_state': '"""auto"""', 'menu_items': 'None'}), "(page_title=f'Courier v{version}', page_icon='🌎', layout=\n 'centered', initial_sidebar_state='auto', menu_items=None)\n", (603, 723), True, 'import streamlit as st\n'), ((719, 750), 'streamlit.title', 'st.title', (['f"""Courier v{version}"""'], {}), "(f'Courier v{version}')\n", (727, 750), True, 'import streamlit as st\n'), ((799, 857), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (818, 857), False, 'import logging\n'), ((1019, 1055), 'os.environ.get', 'os.environ.get', (['"""VOYAGE_API_KEY"""', '""""""'], {}), "('VOYAGE_API_KEY', '')\n", (1033, 1055), False, 'import os\n'), ((1071, 1140), 'llama_index.embeddings.VoyageEmbedding', 'VoyageEmbedding', ([], {'model_name': 'model_name', 'voyage_api_key': 'voyage_api_key'}), '(model_name=model_name, voyage_api_key=voyage_api_key)\n', (1086, 1140), False, 'from llama_index.embeddings import VoyageEmbedding\n'), ((1573, 1610), 'streamlit.cache_resource', 'st.cache_resource', ([], {'show_spinner': '(False)'}), '(show_spinner=False)\n', (1590, 1610), True, 'import streamlit as st\n'), ((889, 929), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (910, 929), False, 'import logging\n'), ((1220, 1243), 'streamlit.session_state.keys', 'st.session_state.keys', ([], {}), '()\n', (1241, 1243), True, 'import streamlit as st\n'), ((2878, 2901), 'streamlit.session_state.keys', 'st.session_state.keys', ([], {}), '()\n', (2899, 2901), True, 'import streamlit as st\n'), ((3077, 3107), 'streamlit.chat_input', 'st.chat_input', (['"""Your question"""'], {}), "('Your question')\n", (3090, 3107), True, 'import streamlit as st\n'), ((3162, 3231), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (3194, 3231), True, 'import streamlit as st\n'), ((858, 877), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (875, 877), False, 'import logging\n'), ((1637, 1687), 'streamlit.spinner', 'st.spinner', ([], {'text': 'f"""Loading Courier v{version} ..."""'}), "(text=f'Loading Courier v{version} ...')\n", (1647, 1687), True, 'import streamlit as st\n'), ((1798, 1915), 'qdrant_client.QdrantClient', 'QdrantClient', ([], {'url': '"""https://02aec354-4932-4062-9e00-422eacb506fc.us-east4-0.gcp.cloud.qdrant.io"""', 'api_key': '""""""'}), "(url=\n 'https://02aec354-4932-4062-9e00-422eacb506fc.us-east4-0.gcp.cloud.qdrant.io'\n , api_key='')\n", (1810, 1915), False, 'from qdrant_client import QdrantClient\n'), ((2449, 2492), 'llama_index.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (2475, 2492), False, 'from llama_index import set_global_service_context\n'), ((2516, 2585), 'llama_index.vector_stores.qdrant.QdrantVectorStore', 'QdrantVectorStore', ([], {'client': 'qdrant_client', 'collection_name': '"""courierv52"""'}), "(client=qdrant_client, collection_name='courierv52')\n", (2533, 2585), False, 'from llama_index.vector_stores.qdrant import QdrantVectorStore\n'), ((2612, 2667), 'llama_index.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (2640, 2667), False, 'from llama_index.storage.storage_context import StorageContext\n'), ((2684, 2791), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['docs'], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(docs, storage_context=storage_context,\n service_context=service_context)\n', (2715, 2791), False, 'from llama_index import VectorStoreIndex, ServiceContext\n'), ((3318, 3350), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (3333, 3350), True, 'import streamlit as st\n'), ((3360, 3388), 'streamlit.write', 'st.write', (["message['content']"], {}), "(message['content'])\n", (3368, 3388), True, 'import streamlit as st\n'), ((3525, 3553), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (3540, 3553), True, 'import streamlit as st\n'), ((3577, 3587), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (3585, 3587), True, 'import streamlit as st\n'), ((3642, 3667), 'streamlit.spinner', 'st.spinner', (['"""Thinking..."""'], {}), "('Thinking...')\n", (3652, 3667), True, 'import streamlit as st\n'), ((3696, 3744), 'streamlit.session_state.chat_engine.stream_chat', 'st.session_state.chat_engine.stream_chat', (['prompt'], {}), '(prompt)\n', (3736, 3744), True, 'import streamlit as st\n'), ((4027, 4068), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (['message'], {}), '(message)\n', (4059, 4068), True, 'import streamlit as st\n'), ((1704, 1761), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': '"""./data"""', 'recursive': '(True)'}), "(input_dir='./data', recursive=True)\n", (1725, 1761), False, 'from llama_index import SimpleDirectoryReader\n'), ((2025, 2074), 'qdrant_client.models.VectorParams', 'VectorParams', ([], {'size': '(1024)', 'distance': 'Distance.EUCLID'}), '(size=1024, distance=Distance.EUCLID)\n', (2037, 2074), False, 'from qdrant_client.models import Distance, VectorParams\n'), ((2160, 2449), 'llama_index.llms.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4"""', 'max_tokens': '(1500)', 'temperature': '(0.5)', 'system_prompt': '"""Keep your answers technical and based on facts and do not hallucinate in responses. In addition, make sure all responses look natural, no Answer: or Query: in the response. Always attempt to query database."""'}), "(model='gpt-4', max_tokens=1500, temperature=0.5, system_prompt=\n 'Keep your answers technical and based on facts and do not hallucinate in responses. In addition, make sure all responses look natural, no Answer: or Query: in the response. Always attempt to query database.'\n )\n", (2166, 2449), False, 'from llama_index.llms import OpenAI\n')]

from langchain.embeddings.huggingface import HuggingFaceEmbeddings from llama_index.embeddings import LangchainEmbedding from llama_index import ServiceContext from llama_index import VectorStoreIndex from llama_index.storage.storage_context import StorageContext from llama_index.vector_stores import ChromaVectorStore from jinja2 import Template import requests from decouple import config import torch from chromadatabase import load_collection import nltk from maps_scraper import * import pandas as pd from time import sleep from context import * import pyshorteners as ps nltk.download('stopwords') from nltk.corpus import stopwords spanish_stop_words = stopwords.words('spanish') device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print(f"PyTorch está utilizando el dispositivo: {device}") HUGGINGFACE_TOKEN=config('HUGGINGFACE_TOKEN') def zephyr_instruct_template(messages, add_generation_prompt=True): # Definir la plantilla Jinja template_str = "{% for message in messages %}" template_str += "{% if message['role'] == 'user' %}" template_str += "<|user|>{{ message['content'] }}</s>\n" template_str += "{% elif message['role'] == 'assistant' %}" template_str += "<|assistant|>{{ message['content'] }}</s>\n" template_str += "{% elif message['role'] == 'system' %}" template_str += "<|system|>{{ message['content'] }}</s>\n" template_str += "{% else %}" template_str += "<|unknown|>{{ message['content'] }}</s>\n" template_str += "{% endif %}" template_str += "{% endfor %}" template_str += "{% if add_generation_prompt %}" template_str += "<|assistant|>\n" template_str += "{% endif %}" # Crear un objeto de plantilla con la cadena de plantilla template = Template(template_str) # Renderizar la plantilla con los mensajes proporcionados return template.render(messages=messages, add_generation_prompt=add_generation_prompt) # Aquí hacemos la llamada el modelo def generate_answer(prompt: str, max_new_tokens: int = 768, ) -> None: try: # Tu clave API de Hugging Face api_key = config('HUGGINGFACE_TOKEN') # URL de la API de Hugging Face para la generación de texto api_url = "https://api-inference.huggingface.co/models/HuggingFaceH4/zephyr-7b-beta" # Cabeceras para la solicitud headers = {"Authorization": f"Bearer {api_key}"} # Datos para enviar en la solicitud POST # Sobre los parámetros: https://huggingface.co/docs/transformers/main_classes/text_generation data = { "inputs": prompt, "parameters": { "max_new_tokens": max_new_tokens, "temperature": 0.7, "top_k": 50, "top_p": 0.95 } } # Realizamos la solicitud POST response = requests.post(api_url, headers=headers, json=data) # Extraer respuesta respuesta = response.json()[0]["generated_text"][len(prompt):] return respuesta except Exception as e: print(f"An error occurred: {e}") # Esta función prepara el prompt en estilo QA def prepare_prompt(query_str: str, nodes: list, user_info: str = None): TEXT_QA_PROMPT_TMPL = ( "La información del usuario es la siguiente:\n" "---------------------\n" "{user_info_str}\n" "---------------------\n" "La información de contexto es la siguiente:\n" "---------------------\n" "{context_str}\n" "---------------------\n" "RESPONDE EN ESPAÑOL. Dada la información de contexto anterior, y sin utilizar conocimiento previo, responde en español la siguiente consulta. En caso de que tu respuesta sea una receta envíala con título, ingredientes, procedimiento. No debes agregar recetas de otros libros ni material adicional. En caso de que la receta pedida no se encuentre en el material provisto debes aclararlo y no enviar receta.\n" "Pregunta: {query_str}\n" "Respuesta: " ) # Construimos el contexto de la pregunta context_str = '' for node in nodes: page_label = node.metadata["page_label"] file_path = node.metadata["file_path"] context_str += f"\npage_label: {page_label}\n" context_str += f"file_path: {file_path}\n\n" context_str += f"{node.text}\n" messages = [ { "role": "system", "content": "Eres un asistente de cocina útil que siempre responde con respuestas veraces, útiles y basadas en hechos.", }, {"role": "user", "content": TEXT_QA_PROMPT_TMPL.format(context_str=context_str, query_str=query_str, user_info_str=user_info)}, ] final_prompt = zephyr_instruct_template(messages) return final_prompt def load_model(): print('Cargando modelo de embeddings...') embed_model = LangchainEmbedding(HuggingFaceEmbeddings( model_name='sentence-transformers/paraphrase-multilingual-mpnet-base-v2', model_kwargs={'device': 'cuda'}, encode_kwargs={'normalize_embeddings': True} ) ) print('Indexando documentos...') chroma_collection = load_collection() # set up ChromaVectorStore and load in data vector_store = ChromaVectorStore(chroma_collection=chroma_collection) storage_context = StorageContext.from_defaults(vector_store=vector_store) service_context = ServiceContext.from_defaults(embed_model=embed_model, llm=None) index = VectorStoreIndex.from_vector_store( vector_store, storage_context=storage_context, service_context=service_context, show_progress=True ) retriever = index.as_retriever(similarity_top_k=2) return retriever def clas(query_str: str, clasificador, vectorizer, retriever, user_id: int = 0): os.chdir(os.path.dirname(os.path.abspath(__file__))) vectorized_query = vectorizer.transform([query_str]) prediction = clasificador.predict(vectorized_query) if prediction[0] == 1: context = generate_context(user_id) answer = get_answer(retriever, query_str, context) os.chdir(os.path.dirname(os.path.abspath(__file__))) return answer else: resultados=[] places, keywords, locations = extract_entities(query_str) obtain_places(places[0], " ".join(keywords), locations[0], query_str) # Seleccionar los primeros 5 restaurantes df = pd.read_csv(os.path.dirname(os.path.abspath(__file__))+"/tabular_data/" + query_str.replace(" ","") + ".csv") primeros_5 = df.head(5) # Generar el resultado escrito for index, restaurante in primeros_5.iterrows(): resultado_escrito = "" resultado_escrito += f"Restaurante: {restaurante['name']}\n" resultado_escrito += f"Enlace: {ps.Shortener().tinyurl.short(restaurante['link'])}\n" resultado_escrito += f"Calificación: {restaurante['rating']}\n" resultado_escrito += f"Dirección: {restaurante['address']}\n\n" resultados.append(resultado_escrito) os.chdir(os.path.dirname(os.path.abspath(__file__))) return resultados def get_answer(retriever, query_str:str, context: str = None): os.chdir(os.path.dirname(os.path.abspath(__file__))) nodes = retriever.retrieve(query_str) final_prompt = prepare_prompt(query_str, nodes, context) return generate_answer(final_prompt)

[((579, 605), 'nltk.download', 'nltk.download', (['"""stopwords"""'], {}), "('stopwords')\n", (592, 605), False, 'import nltk\n'), ((662, 688), 'nltk.corpus.stopwords.words', 'stopwords.words', (['"""spanish"""'], {}), "('spanish')\n", (677, 688), False, 'from nltk.corpus import stopwords\n'), ((838, 865), 'decouple.config', 'config', (['"""HUGGINGFACE_TOKEN"""'], {}), "('HUGGINGFACE_TOKEN')\n", (844, 865), False, 'from decouple import config\n'), ((1760, 1782), 'jinja2.Template', 'Template', (['template_str'], {}), '(template_str)\n', (1768, 1782), False, 'from jinja2 import Template\n'), ((5108, 5125), 'chromadatabase.load_collection', 'load_collection', ([], {}), '()\n', (5123, 5125), False, 'from chromadatabase import load_collection\n'), ((5194, 5248), 'llama_index.vector_stores.ChromaVectorStore', 'ChromaVectorStore', ([], {'chroma_collection': 'chroma_collection'}), '(chroma_collection=chroma_collection)\n', (5211, 5248), False, 'from llama_index.vector_stores import ChromaVectorStore\n'), ((5271, 5326), 'llama_index.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (5299, 5326), False, 'from llama_index.storage.storage_context import StorageContext\n'), ((5349, 5412), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'embed_model': 'embed_model', 'llm': 'None'}), '(embed_model=embed_model, llm=None)\n', (5377, 5412), False, 'from llama_index import ServiceContext\n'), ((5425, 5564), 'llama_index.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', (['vector_store'], {'storage_context': 'storage_context', 'service_context': 'service_context', 'show_progress': '(True)'}), '(vector_store, storage_context=\n storage_context, service_context=service_context, show_progress=True)\n', (5459, 5564), False, 'from llama_index import VectorStoreIndex\n'), ((722, 747), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (745, 747), False, 'import torch\n'), ((2112, 2139), 'decouple.config', 'config', (['"""HUGGINGFACE_TOKEN"""'], {}), "('HUGGINGFACE_TOKEN')\n", (2118, 2139), False, 'from decouple import config\n'), ((2853, 2903), 'requests.post', 'requests.post', (['api_url'], {'headers': 'headers', 'json': 'data'}), '(api_url, headers=headers, json=data)\n', (2866, 2903), False, 'import requests\n'), ((4836, 5023), 'langchain.embeddings.huggingface.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""sentence-transformers/paraphrase-multilingual-mpnet-base-v2"""', 'model_kwargs': "{'device': 'cuda'}", 'encode_kwargs': "{'normalize_embeddings': True}"}), "(model_name=\n 'sentence-transformers/paraphrase-multilingual-mpnet-base-v2',\n model_kwargs={'device': 'cuda'}, encode_kwargs={'normalize_embeddings':\n True})\n", (4857, 5023), False, 'from langchain.embeddings.huggingface import HuggingFaceEmbeddings\n'), ((6757, 6771), 'pyshorteners.Shortener', 'ps.Shortener', ([], {}), '()\n', (6769, 6771), True, 'import pyshorteners as ps\n')]

#! coding: utf-8 import os from dataclasses import dataclass from typing import List, Dict, Optional from llama_index import ServiceContext, get_response_synthesizer, VectorStoreIndex, StorageContext, \ load_indices_from_storage, TreeIndex from llama_index.indices.base import BaseIndex from llama_index.indices.postprocessor import LLMRerank from llama_index.indices.tree.base import TreeRetrieverMode from llama_index.query_engine import RetrieverQueryEngine from llama_index.response_synthesizers import ResponseMode, BaseSynthesizer from common.config import index_dir from common.prompt import CH_CHOICE_SELECT_PROMPT, CH_TREE_SUMMARIZE_PROMPT from query_todo.retrievers import MultiRetriever def load_index(title: str, service_context: ServiceContext = None) -> List[BaseIndex]: storage_context = StorageContext.from_defaults(persist_dir=os.path.join(index_dir, title)) return load_indices_from_storage( storage_context=storage_context, service_context=service_context, ) def load_indices(service_context: ServiceContext) -> Dict[str, List[BaseIndex]]: indices: Dict[str, List[BaseIndex]] = {} for title in os.listdir(index_dir): indices[title] = load_index(title, service_context) return indices def create_response_synthesizer(service_context: ServiceContext = None) -> BaseSynthesizer: # TODO # https://docs.llamaindex.ai/en/stable/module_guides/querying/response_synthesizers/root.html#get-started raise NotImplementedError @dataclass class DocumentQueryEngineFactory: indices: List[BaseIndex] summary: Optional[str] = "" def first_index(self): return self.indices[0] def create_retrievers(self): # TODO # 基于indices 创建多个retriever # https://docs.llamaindex.ai/en/stable/understanding/querying/querying.html#customizing-the-stages-of-querying raise NotImplementedError def doc_store(self): return self.indices[0].docstore def create_query_engine(self, service_context: ServiceContext) -> RetrieverQueryEngine: # TODO # 结合 retriever, llm_rerank, response_synthesizer 创建一个完整的query engine # https://docs.llamaindex.ai/en/stable/understanding/querying/querying.html raise NotImplementedError

[((899, 995), 'llama_index.load_indices_from_storage', 'load_indices_from_storage', ([], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(storage_context=storage_context, service_context=\n service_context)\n', (924, 995), False, 'from llama_index import ServiceContext, get_response_synthesizer, VectorStoreIndex, StorageContext, load_indices_from_storage, TreeIndex\n'), ((1159, 1180), 'os.listdir', 'os.listdir', (['index_dir'], {}), '(index_dir)\n', (1169, 1180), False, 'import os\n'), ((856, 886), 'os.path.join', 'os.path.join', (['index_dir', 'title'], {}), '(index_dir, title)\n', (868, 886), False, 'import os\n')]

import logging import glob from pathlib import Path from llama_index import ( SimpleDirectoryReader, download_loader ) class DataReader: __LOGGER_NAME = "data_reader" __SIMPLE_SUPPORTED_EXTENSIONS = [".csv", ".docx", ".epub", ".hwp", ".ipynb", ".jpeg", ".mbox", ".md", ".mp3", ".pdf", ".png", ".pptm", ".pptx"] __JSON_READER_LOADER = "JSONReader" __WIKIPEDIA_READER_LOADER = "WikipediaReader" def __init__(self, data_dir): # Set logger self.logger = logging.getLogger(self.__LOGGER_NAME) # Data directory and files to load self.data_dir = data_dir def load(self): """ Loads the documents from all the given directories. :return: List of llama-index documents """ documents = [] if self.data_dir is not None: loaders = [ self.__load_simple, self.__load_json, self.__load_wiki ] self.logger.info(f"Loading documents from {self.data_dir} directory ...") for load in loaders: documents.extend(load()) self.logger.info(f"Loaded {len(documents)} documents") else: self.logger.info("No data directory specified, skipping loading documents") return documents def __load_simple(self): """ Loads the documents from the given data directory only for supported file types. The best file reader will be automatically selected from the given file extensions. Docs: https://docs.llamaindex.ai/en/stable/module_guides/loading/simpledirectoryreader.html#supported-file-types :return: List of llama-index documents """ self.logger.debug(f"Loading simple documents ...") documents = SimpleDirectoryReader( input_dir=self.data_dir, required_exts=self.__SIMPLE_SUPPORTED_EXTENSIONS ).load_data() self.logger.debug(f"Loaded {len(documents)} documents") return documents def __load_json(self): """ Loads the JSON documents from the given data directory. :return: List of llama-index documents """ json_files = self.__get_all_files_with_ext("json") JSONReader = download_loader(self.__JSON_READER_LOADER) loader = JSONReader() self.logger.debug(f"Loading JSON documents ...") documents = [] for json_file in json_files: documents.extend(loader.load_data(Path(json_file), is_jsonl=False)) self.logger.debug(f"Loaded {len(documents)} JSON documents") return documents def __load_wiki(self): """ Loads the wikipedia pages from the given data directory. :return: List of llama-index documents """ wiki_files = self.__get_all_files_with_ext("wikipedia") wiki_pages = [] for wiki_file in wiki_files: wiki_pages.extend(self.__get_pages(wiki_file)) WikipediaReader = download_loader(self.__WIKIPEDIA_READER_LOADER) loader = WikipediaReader() self.logger.debug(f"Loading Wikipedia pages ...") documents = loader.load_data(pages=wiki_pages) self.logger.debug(f"Loaded {len(documents)} Wikipedia documents") return documents def __get_all_files_with_ext(self, file_ext): """ Gets all the files with the given extension from the data directory. :param file_ext: The file extension to search for :return: List of file paths """ return glob.glob(f"{self.data_dir}/*.{file_ext}") @staticmethod def __get_pages(file_path): """ Reads the pages/links/documents from the given file path. :param file_path: The path to the file containing the pages :return: List of pages """ with open(file_path, "r") as f: links = f.readlines() return links

[((498, 535), 'logging.getLogger', 'logging.getLogger', (['self.__LOGGER_NAME'], {}), '(self.__LOGGER_NAME)\n', (515, 535), False, 'import logging\n'), ((2288, 2330), 'llama_index.download_loader', 'download_loader', (['self.__JSON_READER_LOADER'], {}), '(self.__JSON_READER_LOADER)\n', (2303, 2330), False, 'from llama_index import SimpleDirectoryReader, download_loader\n'), ((3031, 3078), 'llama_index.download_loader', 'download_loader', (['self.__WIKIPEDIA_READER_LOADER'], {}), '(self.__WIKIPEDIA_READER_LOADER)\n', (3046, 3078), False, 'from llama_index import SimpleDirectoryReader, download_loader\n'), ((3591, 3633), 'glob.glob', 'glob.glob', (['f"""{self.data_dir}/*.{file_ext}"""'], {}), "(f'{self.data_dir}/*.{file_ext}')\n", (3600, 3633), False, 'import glob\n'), ((1809, 1910), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': 'self.data_dir', 'required_exts': 'self.__SIMPLE_SUPPORTED_EXTENSIONS'}), '(input_dir=self.data_dir, required_exts=self.\n __SIMPLE_SUPPORTED_EXTENSIONS)\n', (1830, 1910), False, 'from llama_index import SimpleDirectoryReader, download_loader\n'), ((2525, 2540), 'pathlib.Path', 'Path', (['json_file'], {}), '(json_file)\n', (2529, 2540), False, 'from pathlib import Path\n')]

from typing import List from llama_index.core import Document from llama_index.core.readers.json import JSONReader def get_content_from_json_file(json_file_path: str, source_type: str, is_jsonl: bool = False) -> List[Document]: # https://docs.llamaindex.ai/en/stable/api_reference/readers.html loader = JSONReader(is_jsonl=is_jsonl, levels_back=0, collapse_length=1000) docs = loader.load_data(json_file_path) for doc in docs: doc.metadata["source_id"] = json_file_path doc.metadata["source_type"] = source_type return docs #, extra_info={"source_id": json_file_path})

[((312, 378), 'llama_index.core.readers.json.JSONReader', 'JSONReader', ([], {'is_jsonl': 'is_jsonl', 'levels_back': '(0)', 'collapse_length': '(1000)'}), '(is_jsonl=is_jsonl, levels_back=0, collapse_length=1000)\n', (322, 378), False, 'from llama_index.core.readers.json import JSONReader\n')]

from llama_index import VectorStoreIndex, SimpleDirectoryReader, LLMPredictor, set_global_service_context, ServiceContext from llama_index.llms import LlamaCPP llm = LlamaCPP(model_path="./models/llama-2-13b-chat.Q4_0.gguf") llm_predictor = LLMPredictor(llm=llm) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor) set_global_service_context(service_context=service_context) documents = SimpleDirectoryReader('data').load_data() index = VectorStoreIndex.from_documents(documents, show_progress=True) query_engine = index.as_query_engine() response = query_engine.query("¿Qué tal es la carrera de Administración de Empresas?") print(response) response = query_engine.query("¿Qué tal es la carrera de Comercio Exterior?") print(response) index.storage_context.persist("./storage")

[((167, 225), 'llama_index.llms.LlamaCPP', 'LlamaCPP', ([], {'model_path': '"""./models/llama-2-13b-chat.Q4_0.gguf"""'}), "(model_path='./models/llama-2-13b-chat.Q4_0.gguf')\n", (175, 225), False, 'from llama_index.llms import LlamaCPP\n'), ((242, 263), 'llama_index.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (254, 263), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, LLMPredictor, set_global_service_context, ServiceContext\n'), ((283, 340), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor'}), '(llm_predictor=llm_predictor)\n', (311, 340), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, LLMPredictor, set_global_service_context, ServiceContext\n'), ((342, 401), 'llama_index.set_global_service_context', 'set_global_service_context', ([], {'service_context': 'service_context'}), '(service_context=service_context)\n', (368, 401), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, LLMPredictor, set_global_service_context, ServiceContext\n'), ((466, 528), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'show_progress': '(True)'}), '(documents, show_progress=True)\n', (497, 528), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, LLMPredictor, set_global_service_context, ServiceContext\n'), ((415, 444), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""data"""'], {}), "('data')\n", (436, 444), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, LLMPredictor, set_global_service_context, ServiceContext\n')]

import os from llama_index import ServiceContext, ComposableGraph, TreeIndex, VectorStoreIndex, get_response_synthesizer, \ StorageContext, load_indices_from_storage from llama_index.response_synthesizers import ResponseMode from common.config import index_dir from common.llm import create_llm from common.prompt import CH_QUERY_PROMPT, CH_TREE_SUMMARIZE_PROMPT from common.utils import find_typed service_context = ServiceContext.from_defaults(llm=create_llm()) titles = ["北京市", "上海市"] summaries = [] indices = [] for city in titles: storage_context = StorageContext.from_defaults(persist_dir=os.path.join(index_dir, city)) city_indices = load_indices_from_storage( storage_context=storage_context, service_context=service_context, ) summary = f""" 此内容包含关于{city}的维基百科文章。 如果您需要查找有关{city}的具体事实，请使用此索引。" 如果您想分析多个城市，请不要使用此索引。 """ index = find_typed(city_indices, VectorStoreIndex) indices.append(index) summaries.append(summary) graph = ComposableGraph.from_indices( TreeIndex, indices, summaries) query_engine = graph.as_query_engine( response_synthesizer=get_response_synthesizer( response_mode=ResponseMode.TREE_SUMMARIZE, summary_template=CH_TREE_SUMMARIZE_PROMPT, service_context=service_context, ), service_context=service_context, query_template=CH_QUERY_PROMPT, ) print(query_engine.query("北京气候如何")) print(query_engine.query("深圳在中国什么位置"))

[((1018, 1077), 'llama_index.ComposableGraph.from_indices', 'ComposableGraph.from_indices', (['TreeIndex', 'indices', 'summaries'], {}), '(TreeIndex, indices, summaries)\n', (1046, 1077), False, 'from llama_index import ServiceContext, ComposableGraph, TreeIndex, VectorStoreIndex, get_response_synthesizer, StorageContext, load_indices_from_storage\n'), ((656, 752), 'llama_index.load_indices_from_storage', 'load_indices_from_storage', ([], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(storage_context=storage_context, service_context=\n service_context)\n', (681, 752), False, 'from llama_index import ServiceContext, ComposableGraph, TreeIndex, VectorStoreIndex, get_response_synthesizer, StorageContext, load_indices_from_storage\n'), ((911, 953), 'common.utils.find_typed', 'find_typed', (['city_indices', 'VectorStoreIndex'], {}), '(city_indices, VectorStoreIndex)\n', (921, 953), False, 'from common.utils import find_typed\n'), ((457, 469), 'common.llm.create_llm', 'create_llm', ([], {}), '()\n', (467, 469), False, 'from common.llm import create_llm\n'), ((1154, 1301), 'llama_index.get_response_synthesizer', 'get_response_synthesizer', ([], {'response_mode': 'ResponseMode.TREE_SUMMARIZE', 'summary_template': 'CH_TREE_SUMMARIZE_PROMPT', 'service_context': 'service_context'}), '(response_mode=ResponseMode.TREE_SUMMARIZE,\n summary_template=CH_TREE_SUMMARIZE_PROMPT, service_context=service_context)\n', (1178, 1301), False, 'from llama_index import ServiceContext, ComposableGraph, TreeIndex, VectorStoreIndex, get_response_synthesizer, StorageContext, load_indices_from_storage\n'), ((606, 635), 'os.path.join', 'os.path.join', (['index_dir', 'city'], {}), '(index_dir, city)\n', (618, 635), False, 'import os\n')]

import json import logging from typing import Any, Callable, Dict, List, Mapping, Optional, cast from llama_index.schema import BaseNode from llama_index.vector_stores.types import ( MetadataFilters, VectorStore, VectorStoreQuery, VectorStoreQueryResult, ) from llama_index.schema import ( BaseNode, ImageNode, IndexNode, NodeRelationship, RelatedNodeInfo, TextNode, ) from llama_index.vector_stores.utils import node_to_metadata_dict from byzerllm.utils.client import ByzerLLM from byzerllm.utils.retrieval import ByzerRetrieval from byzerllm.apps.llama_index.simple_retrieval import SimpleRetrieval logger = logging.getLogger(__name__) def _build_metadata_filter_fn( metadata_lookup_fn: Callable[[str], Mapping[str, Any]], metadata_filters: Optional[MetadataFilters] = None, ) -> Callable[[str], bool]: """Build metadata filter function.""" filter_list = metadata_filters.legacy_filters() if metadata_filters else [] if not filter_list: return lambda _: True def filter_fn(node_id: str) -> bool: metadata = metadata_lookup_fn(node_id) for filter_ in filter_list: metadata_value = metadata.get(filter_.key, None) if metadata_value is None: return False elif isinstance(metadata_value, list): if filter_.value not in metadata_value: return False elif isinstance(metadata_value, (int, float, str, bool)): if metadata_value != filter_.value: return False return True return filter_fn def metadata_dict_to_node(metadata: dict, text: Optional[str] = None) -> BaseNode: """Common logic for loading Node data from metadata dict.""" node_json = metadata.get("_node_content", None) node_type = metadata.get("_node_type", None) if node_json is None: raise ValueError("Node content not found in metadata dict.") node: BaseNode if node_type == IndexNode.class_name(): node = IndexNode.parse_raw(node_json) elif node_type == ImageNode.class_name(): node = ImageNode.parse_raw(node_json) else: node = TextNode.parse_raw(node_json) if text is not None: node.set_content(text) return node class ByzerAIVectorStore(VectorStore): stores_text: bool = True def __init__( self, llm:ByzerLLM, retrieval:ByzerRetrieval, chunk_collection: Optional[str] = "default", **kwargs: Any, ) -> None: self._llm = llm self._retrieval = SimpleRetrieval(llm=llm, retrieval=retrieval,chunk_collection=chunk_collection,**kwargs) @property def client(self) -> None: """Get client.""" return def get(self, text_id: str) -> List[float]: """Get embedding.""" v = self._retrieval.get_chunk_by_id(text_id) if len(v) == 0: return [] return v[0]["chunk_vector"] def add( self, nodes: List[BaseNode], **add_kwargs: Any, ) -> List[str]: """Add nodes to index.""" v = [] count = 0 for node in nodes: metadata = node_to_metadata_dict( node, remove_text=True, flat_metadata=False ) metadata.pop("_node_content", None) m = { "chunk_id": node.node_id, "ref_doc_id": node.ref_doc_id, "metadata": node.metadata, "chunk_embedding": node.get_embedding(), "chunk_content": node.get_content(), "owner":"" } v.append(m) self._retrieval.save_chunks(v) self._retrieval.commit_chunk() return [node.node_id for node in nodes] def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None: """ Delete nodes using with ref_doc_id. Args: ref_doc_id (str): The doc_id of the document to delete. """ chunks = self._retrieval.get_chunks_by_docid(ref_doc_id) self._retrieval.delete_by_ids([chunk["_id"] for chunk in chunks]) self._retrieval.commit_chunk() def query( self, query: VectorStoreQuery, **kwargs: Any, ) -> VectorStoreQueryResult: """Get nodes for response.""" query_embedding = cast(List[float], query.query_embedding) chunks = self._retrieval.search_content_chunks(owner="default", query_str=query.query_str, query_embedding=query_embedding, doc_ids=query.node_ids, limit=100, return_json=False) chunks_map = {} for chunk in chunks: chunk["metadata"] = json.loads(chunk["json_data"]) chunks_map[chunk["_id"]] = chunk["metadata"] query_filter_fn = _build_metadata_filter_fn( lambda node_id: chunks_map[node_id], query.filters ) top_similarities = [] top_ids = [] counter = query.similarity_top_k nodes = [] for chunk in chunks: if query_filter_fn(chunk["_id"]): if counter <= 0: break top_similarities.append(chunk["_score"]) top_ids.append(chunk["_id"]) try: node = metadata_dict_to_node({"_node_content": chunk["metadata"]}) node.text = chunk["chunk"] except Exception: # TODO: Legacy support for old metadata format node = TextNode( text=chunk["raw_chunk"], id_=chunk["_id"], embedding=None, metadata=chunk["metadata"], relationships={ NodeRelationship.SOURCE: RelatedNodeInfo(node_id=chunk["doc_id"]) }, ) nodes.append(node) counter -= 1 return VectorStoreQueryResult(nodes = nodes ,similarities=top_similarities, ids=top_ids)

[((660, 687), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (677, 687), False, 'import logging\n'), ((2017, 2039), 'llama_index.schema.IndexNode.class_name', 'IndexNode.class_name', ([], {}), '()\n', (2037, 2039), False, 'from llama_index.schema import BaseNode, ImageNode, IndexNode, NodeRelationship, RelatedNodeInfo, TextNode\n'), ((2056, 2086), 'llama_index.schema.IndexNode.parse_raw', 'IndexNode.parse_raw', (['node_json'], {}), '(node_json)\n', (2075, 2086), False, 'from llama_index.schema import BaseNode, ImageNode, IndexNode, NodeRelationship, RelatedNodeInfo, TextNode\n'), ((2682, 2777), 'byzerllm.apps.llama_index.simple_retrieval.SimpleRetrieval', 'SimpleRetrieval', ([], {'llm': 'llm', 'retrieval': 'retrieval', 'chunk_collection': 'chunk_collection'}), '(llm=llm, retrieval=retrieval, chunk_collection=\n chunk_collection, **kwargs)\n', (2697, 2777), False, 'from byzerllm.apps.llama_index.simple_retrieval import SimpleRetrieval\n'), ((4646, 4686), 'typing.cast', 'cast', (['List[float]', 'query.query_embedding'], {}), '(List[float], query.query_embedding)\n', (4650, 4686), False, 'from typing import Any, Callable, Dict, List, Mapping, Optional, cast\n'), ((6630, 6709), 'llama_index.vector_stores.types.VectorStoreQueryResult', 'VectorStoreQueryResult', ([], {'nodes': 'nodes', 'similarities': 'top_similarities', 'ids': 'top_ids'}), '(nodes=nodes, similarities=top_similarities, ids=top_ids)\n', (6652, 6709), False, 'from llama_index.vector_stores.types import MetadataFilters, VectorStore, VectorStoreQuery, VectorStoreQueryResult\n'), ((2109, 2131), 'llama_index.schema.ImageNode.class_name', 'ImageNode.class_name', ([], {}), '()\n', (2129, 2131), False, 'from llama_index.schema import BaseNode, ImageNode, IndexNode, NodeRelationship, RelatedNodeInfo, TextNode\n'), ((2148, 2178), 'llama_index.schema.ImageNode.parse_raw', 'ImageNode.parse_raw', (['node_json'], {}), '(node_json)\n', (2167, 2178), False, 'from llama_index.schema import BaseNode, ImageNode, IndexNode, NodeRelationship, RelatedNodeInfo, TextNode\n'), ((2204, 2233), 'llama_index.schema.TextNode.parse_raw', 'TextNode.parse_raw', (['node_json'], {}), '(node_json)\n', (2222, 2233), False, 'from llama_index.schema import BaseNode, ImageNode, IndexNode, NodeRelationship, RelatedNodeInfo, TextNode\n'), ((3352, 3418), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)', 'flat_metadata': '(False)'}), '(node, remove_text=True, flat_metadata=False)\n', (3373, 3418), False, 'from llama_index.vector_stores.utils import node_to_metadata_dict\n'), ((5243, 5273), 'json.loads', 'json.loads', (["chunk['json_data']"], {}), "(chunk['json_data'])\n", (5253, 5273), False, 'import json\n'), ((6444, 6484), 'llama_index.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': "chunk['doc_id']"}), "(node_id=chunk['doc_id'])\n", (6459, 6484), False, 'from llama_index.schema import BaseNode, ImageNode, IndexNode, NodeRelationship, RelatedNodeInfo, TextNode\n')]

#!/usr/bin/env python3 # -*- coding utf-8 -*- import openai import yaml from langchain.chat_models import ChatOpenAI from langchain.text_splitter import SpacyTextSplitter from llama_index import GPTListIndex, LLMPredictor, ServiceContext, SimpleDirectoryReader from llama_index.node_parser import SimpleNodeParser ''' llama_index对于文章进行小结 本例中，相当于对文本分段，按树状结构逐步向上进行总结 使用spaCy分词模型 python -m spacy download zh_core_web_sm ''' def get_api_key(): with open("config.yaml", "r", encoding="utf-8") as yaml_file: yaml_data = yaml.safe_load(yaml_file) openai.api_key = yaml_data["openai"]["api_key"] if __name__ == '__main__': get_api_key() # 配置LLM llm_predictor = LLMPredictor(llm=ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo", max_tokens=1024)) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor) # 分词模型，最长2048个token text_splitter = SpacyTextSplitter(pipeline="zh_core_web_sm", chunk_size = 2048) parser = SimpleNodeParser(text_splitter=text_splitter) # 加载目录中的语料 documents = SimpleDirectoryReader('./data/mr_fujino').load_data() # 获取语料中的nodes nodes = parser.get_nodes_from_documents(documents) # 最简单的索引结构GPTListIndex list_index = GPTListIndex(nodes=nodes, service_context=service_context) # 树状模型进行总结 response = list_index.query("下面鲁迅先生以第一人称‘我’写的内容，请你用中文总结一下:", response_mode="tree_summarize") print(response)

[((803, 860), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor'}), '(llm_predictor=llm_predictor)\n', (831, 860), False, 'from llama_index import GPTListIndex, LLMPredictor, ServiceContext, SimpleDirectoryReader\n'), ((906, 967), 'langchain.text_splitter.SpacyTextSplitter', 'SpacyTextSplitter', ([], {'pipeline': '"""zh_core_web_sm"""', 'chunk_size': '(2048)'}), "(pipeline='zh_core_web_sm', chunk_size=2048)\n", (923, 967), False, 'from langchain.text_splitter import SpacyTextSplitter\n'), ((983, 1028), 'llama_index.node_parser.SimpleNodeParser', 'SimpleNodeParser', ([], {'text_splitter': 'text_splitter'}), '(text_splitter=text_splitter)\n', (999, 1028), False, 'from llama_index.node_parser import SimpleNodeParser\n'), ((1234, 1292), 'llama_index.GPTListIndex', 'GPTListIndex', ([], {'nodes': 'nodes', 'service_context': 'service_context'}), '(nodes=nodes, service_context=service_context)\n', (1246, 1292), False, 'from llama_index import GPTListIndex, LLMPredictor, ServiceContext, SimpleDirectoryReader\n'), ((530, 555), 'yaml.safe_load', 'yaml.safe_load', (['yaml_file'], {}), '(yaml_file)\n', (544, 555), False, 'import yaml\n'), ((709, 779), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo"""', 'max_tokens': '(1024)'}), "(temperature=0, model_name='gpt-3.5-turbo', max_tokens=1024)\n", (719, 779), False, 'from langchain.chat_models import ChatOpenAI\n'), ((1061, 1102), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""./data/mr_fujino"""'], {}), "('./data/mr_fujino')\n", (1082, 1102), False, 'from llama_index import GPTListIndex, LLMPredictor, ServiceContext, SimpleDirectoryReader\n')]

from dotenv import load_dotenv import os from llama_index import SimpleDirectoryReader from llama_index import node_parser from llama_index.llms import OpenAI from llama_index.embeddings.openai import OpenAIEmbedding from llama_index import ( download_loader, ServiceContext, VectorStoreIndex, StorageContext, ) from llama_index.vector_stores import PineconeVectorStore from llama_index.node_parser import SimpleNodeParser import pinecone load_dotenv() pinecone.init( api_key=os.environ["PINEECONE_API_KEY"], Environment=["PINECONE_ENVIRONMENT"] ) if __name__ == "__main__": print("Goining to ingest pinecone documentation") # this will remove the html tag and only clean data will be availabe UnstructuredReader = download_loader("UnstructuredReader") dir_reader = SimpleDirectoryReader( input_dir="./llamaindex-docs", file_extractor={".htm1": UnstructuredReader()} ) documents = dir_reader.load_data() node_parser = SimpleNodeParser.from_defaults(chunk_size=200, chunk_overlap=20) # nodes = node_parser.get_nodes_from_documents(documents=documents) llm = OpenAI(model="gpt-3.5 turbo", temperature=0) embed_model = OpenAIEmbedding(model="text-embedding-ada-002", embed_batch_size=100) service_context = ServiceContext.from_defaults( llm=llm, embed_model=embed_model, node_parser=node_parser ) # pinecone index name index_name = "documentation-helper" pinecone_index = pinecone.index(index_name=index_name) vector_store = PineconeVectorStore(pinecone_index=pinecone_index) Storage_Context = StorageContext.from_defaults(vector_store=vector_store) index = VectorStoreIndex.from_documents( documents=documents, service_context=service_context, storage_context=Storage_Context, show_progress=True, ) print("finish ingesting...")

[((456, 469), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (467, 469), False, 'from dotenv import load_dotenv\n'), ((470, 567), 'pinecone.init', 'pinecone.init', ([], {'api_key': "os.environ['PINEECONE_API_KEY']", 'Environment': "['PINECONE_ENVIRONMENT']"}), "(api_key=os.environ['PINEECONE_API_KEY'], Environment=[\n 'PINECONE_ENVIRONMENT'])\n", (483, 567), False, 'import pinecone\n'), ((748, 785), 'llama_index.download_loader', 'download_loader', (['"""UnstructuredReader"""'], {}), "('UnstructuredReader')\n", (763, 785), False, 'from llama_index import download_loader, ServiceContext, VectorStoreIndex, StorageContext\n'), ((976, 1040), 'llama_index.node_parser.SimpleNodeParser.from_defaults', 'SimpleNodeParser.from_defaults', ([], {'chunk_size': '(200)', 'chunk_overlap': '(20)'}), '(chunk_size=200, chunk_overlap=20)\n', (1006, 1040), False, 'from llama_index.node_parser import SimpleNodeParser\n'), ((1125, 1169), 'llama_index.llms.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5 turbo"""', 'temperature': '(0)'}), "(model='gpt-3.5 turbo', temperature=0)\n", (1131, 1169), False, 'from llama_index.llms import OpenAI\n'), ((1188, 1257), 'llama_index.embeddings.openai.OpenAIEmbedding', 'OpenAIEmbedding', ([], {'model': '"""text-embedding-ada-002"""', 'embed_batch_size': '(100)'}), "(model='text-embedding-ada-002', embed_batch_size=100)\n", (1203, 1257), False, 'from llama_index.embeddings.openai import OpenAIEmbedding\n'), ((1280, 1372), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': 'embed_model', 'node_parser': 'node_parser'}), '(llm=llm, embed_model=embed_model, node_parser=\n node_parser)\n', (1308, 1372), False, 'from llama_index import download_loader, ServiceContext, VectorStoreIndex, StorageContext\n'), ((1470, 1507), 'pinecone.index', 'pinecone.index', ([], {'index_name': 'index_name'}), '(index_name=index_name)\n', (1484, 1507), False, 'import pinecone\n'), ((1527, 1577), 'llama_index.vector_stores.PineconeVectorStore', 'PineconeVectorStore', ([], {'pinecone_index': 'pinecone_index'}), '(pinecone_index=pinecone_index)\n', (1546, 1577), False, 'from llama_index.vector_stores import PineconeVectorStore\n'), ((1600, 1655), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (1628, 1655), False, 'from llama_index import download_loader, ServiceContext, VectorStoreIndex, StorageContext\n'), ((1669, 1812), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', ([], {'documents': 'documents', 'service_context': 'service_context', 'storage_context': 'Storage_Context', 'show_progress': '(True)'}), '(documents=documents, service_context=\n service_context, storage_context=Storage_Context, show_progress=True)\n', (1700, 1812), False, 'from llama_index import download_loader, ServiceContext, VectorStoreIndex, StorageContext\n')]

from typing import Any, Dict, List, Optional, Sequence, Tuple from llama_index.core.base.response.schema import RESPONSE_TYPE, Response from llama_index.core.callbacks.base import CallbackManager from llama_index.core.callbacks.schema import CBEventType, EventPayload from llama_index.core.indices.multi_modal import MultiModalVectorIndexRetriever from llama_index.core.indices.query.base import BaseQueryEngine from llama_index.core.indices.query.schema import QueryBundle, QueryType from llama_index.core.multi_modal_llms.base import MultiModalLLM from llama_index.core.postprocessor.types import BaseNodePostprocessor from llama_index.core.prompts import BasePromptTemplate from llama_index.core.prompts.default_prompts import DEFAULT_TEXT_QA_PROMPT from llama_index.core.query_engine.citation_query_engine import CITATION_QA_TEMPLATE from llama_index.core.prompts import PromptTemplate from llama_index.core.prompts.mixin import PromptMixinType from llama_index.core.schema import ImageNode, NodeWithScore from mm_retriever import MultiModalQdrantRetriever # rewrite CITATION_QA_TEMPLATE TEXT_QA_TEMPLATE = PromptTemplate( "Please provide an answer based solely on the provided sources. " "When referencing information from a source, " "cite the appropriate source(s) using their corresponding numbers. " "Every answer should include at least one source citation. " "Only cite a source when you are explicitly referencing it. " "If none of the sources are helpful, you should indicate that. " "Below are several numbered sources of information:" "\n------\n" "{context_str}" "\n------\n" "Query: {query_str}\n" "Answer: " ) IMAGE_QA_TEMPLATE = PromptTemplate( "<image>\n" "Caption: {context_str}" "\n------\n" "You are a smart agent who can answer questions based on external information. " "Above is an annotated image you retrieved. Please provide an answer to the query based solely on the image and caption. " "If the image is not helpful, you should indicate that. \n" "Query: {query_str}\n" "Note: Don't include expressions like \"This image appears to be XXX\" in your answer.\n" "Answer: " ) ANSWER_INTEGRATION_TEMPLATE = PromptTemplate( "With the following sources related to your question from my knowledge base: \n" "\n"+"-"*50+"\n" "Paragraphs:\n\n" "{context_str}\n" "\nImages:\n" "{image_context_str}\n" "\n"+"-"*50+"\n" "Here is my answer:\n" "\n{text_context_response}\n{image_context_response}" ) # def _get_image_and_text_nodes( # nodes: List[NodeWithScore], # ) -> Tuple[List[NodeWithScore], List[NodeWithScore]]: # image_nodes = [] # text_nodes = [] # for res_node in nodes: # if isinstance(res_node.node, ImageNode): # image_nodes.append(res_node) # else: # text_nodes.append(res_node) # return image_nodes, text_nodes class CustomMultiModalQueryEngine(BaseQueryEngine): """Simple Multi Modal Retriever query engine. Assumes that retrieved text context fits within context window of LLM, along with images. Args: retriever (MultiModalVectorIndexRetriever): A retriever object. multi_modal_llm (Optional[MultiModalLLM]): MultiModalLLM Models. text_qa_template (Optional[BasePromptTemplate]): Text QA Prompt Template. image_qa_template (Optional[BasePromptTemplate]): Image QA Prompt Template. node_postprocessors (Optional[List[BaseNodePostprocessor]]): Node Postprocessors. callback_manager (Optional[CallbackManager]): A callback manager. """ def __init__( self, retriever: MultiModalQdrantRetriever, multi_modal_llm: MultiModalLLM, text_qa_template: Optional[BasePromptTemplate] = None, image_qa_template: Optional[BasePromptTemplate] = None, answer_integration_template: Optional[BasePromptTemplate] = None, node_postprocessors: Optional[List[BaseNodePostprocessor]] = None, callback_manager: Optional[CallbackManager] = None, **kwargs: Any, ) -> None: self._retriever = retriever self._multi_modal_llm = multi_modal_llm self._text_qa_template = text_qa_template or CITATION_QA_TEMPLATE self._image_qa_template = image_qa_template or IMAGE_QA_TEMPLATE self._answer_integration_template = answer_integration_template or ANSWER_INTEGRATION_TEMPLATE self._node_postprocessors = node_postprocessors or [] callback_manager = callback_manager or CallbackManager([]) for node_postprocessor in self._node_postprocessors: node_postprocessor.callback_manager = callback_manager super().__init__(callback_manager) def _get_prompts(self) -> Dict[str, Any]: """Get prompts.""" return {"text_qa_template": self._text_qa_template} def _get_prompt_modules(self) -> PromptMixinType: """Get prompt sub-modules.""" return {} def _apply_node_postprocessors( self, nodes: List[NodeWithScore], query_bundle: QueryBundle ) -> List[NodeWithScore]: for node_postprocessor in self._node_postprocessors: nodes = node_postprocessor.postprocess_nodes( nodes, query_bundle=query_bundle ) return nodes def retrieve(self, query_bundle: QueryBundle, text_query_mode: str = "hybrid", image_query_mode: str = "default", metadata_filters = None) -> Dict[str, List[NodeWithScore]]: text_retrieval_result = self._retriever.retrieve_text_nodes(query_bundle, text_query_mode, metadata_filters) image_retrieval_result = self._retriever.retrieve_image_nodes(query_bundle, image_query_mode, metadata_filters) reranked_text_nodes = self._retriever.rerank_text_nodes(query_bundle, text_retrieval_result) reranked_image_nodes = self._retriever.rerank_image_nodes(query_bundle, image_retrieval_result) retrieval_results = { "text_nodes": self._apply_node_postprocessors(reranked_text_nodes, query_bundle=query_bundle), "image_nodes": self._apply_node_postprocessors(reranked_image_nodes, query_bundle=query_bundle), } return retrieval_results # async def aretrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]: # nodes = await self._retriever.aretrieve(query_bundle) # return self._apply_node_postprocessors(nodes, query_bundle=query_bundle) def synthesize( self, query_bundle: QueryBundle, #nodes: List[NodeWithScore], retrieval_results: Dict[str, List[NodeWithScore]], additional_source_nodes: Optional[Sequence[NodeWithScore]] = None, ) -> RESPONSE_TYPE: #image_nodes, text_nodes = _get_image_and_text_nodes(nodes) image_nodes, text_nodes = retrieval_results["image_nodes"], retrieval_results["text_nodes"] #TODO: format prompt with (text context), (image + caption of image) context_str = "\n\n".join([f"Source {text_nodes.index(r)+1}:\n" + r.get_content() for r in text_nodes]) fmt_prompt = self._text_qa_template.format( context_str=context_str, query_str=query_bundle.query_str, ) image_context_str = "\n\n".join([r.get_content() for r in image_nodes]) image_query_fmt_prompt = self._image_qa_template.format(context_str=image_context_str, query_str=query_bundle.query_str) text_context_messages = [ { "role": "user", "content":[ {"type":"text", "text":fmt_prompt} ] } ] ## Generate response when the mllm(llava) is under llamacpp framework ##TODO: handle multiple image input image_url = f"data:image/png;base64,{image_nodes[0].node.image.decode('utf-8')}" image_context_messages = [ { "role": "user", "content": [ {"type": "image_url", "image_url": {"url": image_url}}, {"type": "text", "text": image_query_fmt_prompt} ] } ] text_context_response = self._multi_modal_llm.chat( messages=text_context_messages, ) image_context_response = self._multi_modal_llm.chat( messages=image_context_messages, ) ## Generate response when the mllm(llava) is under ollama framework # text_context_response = self._multi_modal_llm.complete( # prompt=fmt_prompt, # images=[], # ) # image_context_response = self._multi_modal_llm.complete( # prompt=image_query_fmt_prompt, # images=[image_node.node.image for image_node in image_nodes], # ) #TODO: transform encoded base64 image to image object in GUI synthesized_response = self._answer_integration_template.format( context_str=context_str, image_context_str= "\n\n".join(["<image>"+ str(r.node.image) + '</image>\n' + r.node.get_content() for r in image_nodes]), text_context_response=text_context_response.text.replace("\n"," ").strip(), image_context_response=i_q_response.text.replace("\n"," ").strip(), ) return Response( response=str(synthesized_response), source_nodes=text_nodes+image_nodes, metadata={ "query_str": query_bundle.query_str, "model_config": self._multi_modal_llm.metadata, }, ) # async def asynthesize( # self, # query_bundle: QueryBundle, # nodes: List[NodeWithScore], # additional_source_nodes: Optional[Sequence[NodeWithScore]] = None, # ) -> RESPONSE_TYPE: # image_nodes, text_nodes = _get_image_and_text_nodes(nodes) # context_str = "\n\n".join([r.get_content() for r in text_nodes]) # fmt_prompt = self._text_qa_template.format( # context_str=context_str, query_str=query_bundle.query_str # ) # llm_response = await self._multi_modal_llm.acomplete( # prompt=fmt_prompt, # image_documents=image_nodes, # ) # return Response( # response=str(llm_response), # source_nodes=nodes, # metadata={"text_nodes": text_nodes, "image_nodes": image_nodes}, # ) async def asynthesize( self, query_bundle: QueryBundle, nodes: List[NodeWithScore], additional_source_nodes: Optional[Sequence[NodeWithScore]] = None, ) -> RESPONSE_TYPE: raise NotImplementedError("Async synthesize not implemented yet") def _query(self, query_bundle: QueryBundle) -> RESPONSE_TYPE: """Answer a query.""" with self.callback_manager.event( CBEventType.QUERY, payload={EventPayload.QUERY_STR: query_bundle.query_str} ) as query_event: with self.callback_manager.event( CBEventType.RETRIEVE, payload={EventPayload.QUERY_STR: query_bundle.query_str}, ) as retrieve_event: retrieval_results = self.retrieve(query_bundle) retrieve_event.on_end( payload={EventPayload.NODES: retrieval_results}, ) response = self.synthesize( query_bundle, retrieval_results=retrieval_results, ) query_event.on_end(payload={EventPayload.RESPONSE: response}) return response async def _aquery(self, query_bundle: QueryBundle) -> RESPONSE_TYPE: raise NotImplementedError("Async query not implemented yet") # async def _aquery(self, query_bundle: QueryBundle) -> RESPONSE_TYPE: # """Answer a query.""" # with self.callback_manager.event( # CBEventType.QUERY, payload={EventPayload.QUERY_STR: query_bundle.query_str} # ) as query_event: # with self.callback_manager.event( # CBEventType.RETRIEVE, # payload={EventPayload.QUERY_STR: query_bundle.query_str}, # ) as retrieve_event: # nodes = await self.aretrieve(query_bundle) # retrieve_event.on_end( # payload={EventPayload.NODES: nodes}, # ) # response = await self.asynthesize( # query_bundle, # nodes=nodes, # ) # query_event.on_end(payload={EventPayload.RESPONSE: response}) # return response @property def retriever(self) -> MultiModalVectorIndexRetriever: """Get the retriever object.""" return self._retriever

[((1114, 1604), 'llama_index.core.prompts.PromptTemplate', 'PromptTemplate', (['"""Please provide an answer based solely on the provided sources. When referencing information from a source, cite the appropriate source(s) using their corresponding numbers. Every answer should include at least one source citation. Only cite a source when you are explicitly referencing it. If none of the sources are helpful, you should indicate that. Below are several numbered sources of information:\n------\n{context_str}\n------\nQuery: {query_str}\nAnswer: """'], {}), '(\n """Please provide an answer based solely on the provided sources. When referencing information from a source, cite the appropriate source(s) using their corresponding numbers. Every answer should include at least one source citation. Only cite a source when you are explicitly referencing it. If none of the sources are helpful, you should indicate that. Below are several numbered sources of information:\n------\n{context_str}\n------\nQuery: {query_str}\nAnswer: """\n )\n', (1128, 1604), False, 'from llama_index.core.prompts import PromptTemplate\n'), ((1700, 2135), 'llama_index.core.prompts.PromptTemplate', 'PromptTemplate', (['"""<image>\nCaption: {context_str}\n------\nYou are a smart agent who can answer questions based on external information. Above is an annotated image you retrieved. Please provide an answer to the query based solely on the image and caption. If the image is not helpful, you should indicate that. \nQuery: {query_str}\nNote: Don\'t include expressions like "This image appears to be XXX" in your answer.\nAnswer: """'], {}), '(\n """<image>\nCaption: {context_str}\n------\nYou are a smart agent who can answer questions based on external information. Above is an annotated image you retrieved. Please provide an answer to the query based solely on the image and caption. If the image is not helpful, you should indicate that. \nQuery: {query_str}\nNote: Don\'t include expressions like "This image appears to be XXX" in your answer.\nAnswer: """\n )\n', (1714, 2135), False, 'from llama_index.core.prompts import PromptTemplate\n'), ((2223, 2517), 'llama_index.core.prompts.PromptTemplate', 'PromptTemplate', (['(\n \'With the following sources related to your question from my knowledge base: \\n\\n\'\n + \'-\' * 50 +\n """\nParagraphs:\n\n{context_str}\n\nImages:\n{image_context_str}\n\n""" + \'-\' *\n 50 +\n """\nHere is my answer:\n\n{text_context_response}\n{image_context_response}"""\n )'], {}), '(\n """With the following sources related to your question from my knowledge base: \n\n"""\n + \'-\' * 50 +\n """\nParagraphs:\n\n{context_str}\n\nImages:\n{image_context_str}\n\n""" + \'-\' *\n 50 +\n """\nHere is my answer:\n\n{text_context_response}\n{image_context_response}"""\n )\n', (2237, 2517), False, 'from llama_index.core.prompts import PromptTemplate\n'), ((4563, 4582), 'llama_index.core.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (4578, 4582), False, 'from llama_index.core.callbacks.base import CallbackManager\n')]

import asyncio import os import tempfile import traceback from datetime import datetime, date from functools import partial from pathlib import Path import discord import aiohttp import openai import tiktoken from langchain.chat_models import ChatOpenAI from llama_index import ( QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer, ) from llama_index.callbacks import CallbackManager, TokenCountingHandler from llama_index.composability import QASummaryQueryEngineBuilder from llama_index.retrievers import VectorIndexRetriever from llama_index.query_engine import RetrieverQueryEngine, MultiStepQueryEngine from llama_index.indices.query.query_transform import StepDecomposeQueryTransform from llama_index.prompts.chat_prompts import CHAT_REFINE_PROMPT from llama_index.readers.web import DEFAULT_WEBSITE_EXTRACTOR from langchain import OpenAI from models.openai_model import Models from services.environment_service import EnvService MAX_SEARCH_PRICE = EnvService.get_max_search_price() class Search: def __init__(self, gpt_model, usage_service): self.model = gpt_model self.usage_service = usage_service self.google_search_api_key = EnvService.get_google_search_api_key() self.google_search_engine_id = EnvService.get_google_search_engine_id() self.loop = asyncio.get_running_loop() self.qaprompt = QuestionAnswerPrompt( "You are formulating the response to a search query given the search prompt and the context. Context information is below. The text '<|endofstatement|>' is used to separate chat entries and make it easier for you to understand the context\n" "---------------------\n" "{context_str}" "\n---------------------\n" "Never say '<|endofstatement|>'\n" "Given the context information and not prior knowledge, " "answer the question, say that you were unable to answer the question if there is not sufficient context to formulate a decisive answer. If the prior knowledge/context was sufficient, simply repeat it. The search query was: {query_str}\n" ) self.openai_key = os.getenv("OPENAI_TOKEN") self.EMBED_CUTOFF = 2000 def add_search_index(self, index, user_id, query): # Create a folder called "indexes/{USER_ID}" if it doesn't exist already Path(f"{EnvService.save_path()}/indexes/{user_id}_search").mkdir( parents=True, exist_ok=True ) # Save the index to file under the user id file = f"{date.today().month}_{date.today().day}_{query[:20]}" index.storage_context.persist( persist_dir=EnvService.save_path() / "indexes" / f"{str(user_id)}_search" / f"{file}" ) def build_search_started_embed(self): embed = discord.Embed( title="Searching the web...", description="Refining google search query...", color=discord.Color.blurple(), ) embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png") return embed def build_search_refined_embed(self, refined_query): embed = discord.Embed( title="Searching the web...", description="Refined query:\n" + f"`{refined_query}`" + "\nRetrieving links from google...", color=discord.Color.blurple(), ) embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png") return embed def build_search_links_retrieved_embed(self, refined_query): embed = discord.Embed( title="Searching the web...", description="Refined query:\n" + f"`{refined_query}`" "\nRetrieving webpages...", color=discord.Color.blurple(), ) embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png") return embed def build_search_determining_price_embed(self, refined_query): embed = discord.Embed( title="Searching the web...", description="Refined query:\n" + f"`{refined_query}`" "\nPre-determining index price...", color=discord.Color.blurple(), ) embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png") return embed def build_search_webpages_retrieved_embed(self, refined_query): embed = discord.Embed( title="Searching the web...", description="Refined query:\n" + f"`{refined_query}`" "\nIndexing...", color=discord.Color.blurple(), ) embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png") return embed def build_search_indexed_embed(self, refined_query): embed = discord.Embed( title="Searching the web...", description="Refined query:\n" + f"`{refined_query}`" "\nThinking about your question...", color=discord.Color.blurple(), ) embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png") return embed def build_search_final_embed(self, refined_query, price): embed = discord.Embed( title="Searching the web...", description="Refined query:\n" + f"`{refined_query}`" "\nDone!\n||The total price was $" + price + "||", color=discord.Color.blurple(), ) embed.set_thumbnail(url="https://i.imgur.com/txHhNzL.png") return embed def index_webpage(self, url) -> list[Document]: documents = BeautifulSoupWebReader( website_extractor=DEFAULT_WEBSITE_EXTRACTOR ).load_data(urls=[url]) return documents async def index_pdf(self, url) -> list[Document]: # Download the PDF at the url and save it to a tempfile async with aiohttp.ClientSession() as session: async with session.get(url) as response: if response.status == 200: data = await response.read() f = tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) f.write(data) f.close() else: raise ValueError("Could not download PDF") # Get the file path of this tempfile.NamedTemporaryFile # Save this temp file to an actual file that we can put into something else to read it documents = SimpleDirectoryReader(input_files=[f.name]).load_data() for document in documents: document.extra_info = {"URL": url} # Delete the temporary file return documents async def get_links(self, query, search_scope=2): """Search the web for a query""" async with aiohttp.ClientSession() as session: async with session.get( f"https://www.googleapis.com/customsearch/v1?key={self.google_search_api_key}&cx={self.google_search_engine_id}&q={query}" ) as response: if response.status == 200: data = await response.json() # Return a list of the top 2 links return ( [item["link"] for item in data["items"][:search_scope]], [item["link"] for item in data["items"]], ) else: raise ValueError( "Error while retrieving links, the response returned " + str(response.status) + " with the message " + str(await response.text()) ) async def try_edit(self, message, embed): try: await message.edit(embed=embed) except Exception: traceback.print_exc() pass async def try_delete(self, message): try: await message.delete() except Exception: traceback.print_exc() pass async def search( self, ctx: discord.ApplicationContext, query, user_api_key, search_scope, nodes, deep, response_mode, model, multistep=False, redo=None, ): DEFAULT_SEARCH_NODES = 1 if not user_api_key: os.environ["OPENAI_API_KEY"] = self.openai_key else: os.environ["OPENAI_API_KEY"] = user_api_key openai.api_key = os.environ["OPENAI_API_KEY"] # Initialize the search cost price = 0 if ctx: in_progress_message = ( await ctx.respond(embed=self.build_search_started_embed()) if not redo else await ctx.channel.send(embed=self.build_search_started_embed()) ) try: llm_predictor_presearch = OpenAI( max_tokens=50, temperature=0.4, presence_penalty=0.65, model_name="text-davinci-003", ) # Refine a query to send to google custom search API prompt = f"You are to be given a search query for google. Change the query such that putting it into the Google Custom Search API will return the most relevant websites to assist in answering the original query. If the original query is inferring knowledge about the current day, insert the current day into the refined prompt. If the original query is inferring knowledge about the current month, insert the current month and year into the refined prompt. If the original query is inferring knowledge about the current year, insert the current year into the refined prompt. Generally, if the original query is inferring knowledge about something that happened recently, insert the current month into the refined query. Avoid inserting a day, month, or year for queries that purely ask about facts and about things that don't have much time-relevance. The current date is {str(datetime.now().date())}. Do not insert the current date if not neccessary. Respond with only the refined query for the original query. Don’t use punctuation or quotation marks.\n\nExamples:\n---\nOriginal Query: ‘Who is Harald Baldr?’\nRefined Query: ‘Harald Baldr biography’\n---\nOriginal Query: ‘What happened today with the Ohio train derailment?’\nRefined Query: ‘Ohio train derailment details {str(datetime.now().date())}’\n---\nOriginal Query: ‘Is copper in drinking water bad for you?’\nRefined Query: ‘copper in drinking water adverse effects’\n---\nOriginal Query: What's the current time in Mississauga?\nRefined Query: current time Mississauga\nNow, refine the user input query.\nOriginal Query: {query}\nRefined Query:" query_refined = await llm_predictor_presearch.agenerate( prompts=[prompt], ) query_refined_text = query_refined.generations[0][0].text await self.usage_service.update_usage( query_refined.llm_output.get("token_usage").get("total_tokens"), "davinci", ) price += await self.usage_service.get_price( query_refined.llm_output.get("token_usage").get("total_tokens"), "davinci", ) except Exception as e: traceback.print_exc() query_refined_text = query if ctx: await self.try_edit( in_progress_message, self.build_search_refined_embed(query_refined_text) ) # Get the links for the query links, all_links = await self.get_links( query_refined_text, search_scope=search_scope ) if ctx: await self.try_edit( in_progress_message, self.build_search_links_retrieved_embed(query_refined_text), ) if all_links is None: raise ValueError("The Google Search API returned an error.") # For each link, crawl the page and get all the text that's not HTML garbage. # Concatenate all the text for a given website into one string and save it into an array: documents = [] for link in links: # First, attempt a connection with a timeout of 3 seconds to the link, if the timeout occurs, don't # continue to the document loading. pdf = False try: async with aiohttp.ClientSession() as session: async with session.get(link, timeout=1) as response: # Add another entry to links from all_links if the link is not already in it to compensate for the failed request if response.status not in [200, 203, 202, 204]: for link2 in all_links: if link2 not in links: links.append(link2) break continue # Follow redirects elif response.status in [301, 302, 303, 307, 308]: try: links.append(response.url) continue except: continue else: # Detect if the link is a PDF, if it is, we load it differently if response.headers["Content-Type"] == "application/pdf": pdf = True except: try: # Try to add a link from all_links, this is kind of messy. for link2 in all_links: if link2 not in links: links.append(link2) break except: pass continue try: if not pdf: document = await self.loop.run_in_executor( None, partial(self.index_webpage, link) ) else: document = await self.index_pdf(link) [documents.append(doc) for doc in document] except Exception as e: traceback.print_exc() if ctx: await self.try_edit( in_progress_message, self.build_search_webpages_retrieved_embed(query_refined_text), ) embedding_model = OpenAIEmbedding() llm_predictor = LLMPredictor(llm=ChatOpenAI(temperature=0, model_name=model)) token_counter = TokenCountingHandler( tokenizer=tiktoken.encoding_for_model(model).encode, verbose=False ) callback_manager = CallbackManager([token_counter]) service_context = ServiceContext.from_defaults( llm_predictor=llm_predictor, embed_model=embedding_model, callback_manager=callback_manager, ) # Check price token_counter_mock = TokenCountingHandler( tokenizer=tiktoken.encoding_for_model(model).encode, verbose=False ) callback_manager_mock = CallbackManager([token_counter_mock]) embed_model_mock = MockEmbedding(embed_dim=1536) service_context_mock = ServiceContext.from_defaults( embed_model=embed_model_mock, callback_manager=callback_manager_mock ) self.loop.run_in_executor( None, partial( GPTVectorStoreIndex.from_documents, documents, service_context=service_context_mock, ), ) total_usage_price = await self.usage_service.get_price( token_counter_mock.total_embedding_token_count, "embedding" ) if total_usage_price > 1.00: raise ValueError( "Doing this search would be prohibitively expensive. Please try a narrower search scope." ) if not deep: index = await self.loop.run_in_executor( None, partial( GPTVectorStoreIndex.from_documents, documents, service_context=service_context, use_async=True, ), ) # save the index to disk if not a redo if not redo: self.add_search_index( index, ctx.user.id if isinstance(ctx, discord.ApplicationContext) else ctx.author.id, query, ) else: if ctx: await self.try_edit( in_progress_message, self.build_search_determining_price_embed(query_refined_text), ) graph_builder = QASummaryQueryEngineBuilder(service_context=service_context) index = await self.loop.run_in_executor( None, partial( graph_builder.build_from_documents, documents, ), ) if ctx: await self.try_edit( in_progress_message, self.build_search_indexed_embed(query_refined_text) ) ######################################## if not deep: step_decompose_transform = StepDecomposeQueryTransform( service_context.llm_predictor ) retriever = VectorIndexRetriever( index=index, similarity_top_k=nodes or DEFAULT_SEARCH_NODES, ) response_synthesizer = get_response_synthesizer( response_mode=response_mode, use_async=True, refine_template=CHAT_REFINE_PROMPT, text_qa_template=self.qaprompt, service_context=service_context, ) query_engine = RetrieverQueryEngine( retriever=retriever, response_synthesizer=response_synthesizer ) multistep_query_engine = MultiStepQueryEngine( query_engine=query_engine, query_transform=step_decompose_transform, index_summary="Provides information about everything you need to know about this topic, use this to answer the question.", ) if multistep: response = await self.loop.run_in_executor( None, partial(multistep_query_engine.query, query), ) else: response = await self.loop.run_in_executor( None, partial(query_engine.query, query), ) else: query_configs = [ { "index_struct_type": "simple_dict", "query_mode": "default", "query_kwargs": {"similarity_top_k": 1}, }, { "index_struct_type": "list", "query_mode": "default", "query_kwargs": { "response_mode": "tree_summarize", "use_async": True, "verbose": True, }, }, { "index_struct_type": "tree", "query_mode": "default", "query_kwargs": { "verbose": True, "use_async": True, "child_branch_factor": 2, }, }, ] response = await self.loop.run_in_executor( None, partial( index.query, query, ), ) await self.usage_service.update_usage( token_counter.total_llm_token_count, await self.usage_service.get_cost_name(model), ) await self.usage_service.update_usage( token_counter.total_embedding_token_count, "embedding" ) price += await self.usage_service.get_price( token_counter.total_llm_token_count, await self.usage_service.get_cost_name(model), ) + await self.usage_service.get_price( token_counter.total_embedding_token_count, "embedding" ) if ctx: await self.try_edit( in_progress_message, self.build_search_final_embed(query_refined_text, str(round(price, 6))), ) return response, query_refined_text

[((1135, 1168), 'services.environment_service.EnvService.get_max_search_price', 'EnvService.get_max_search_price', ([], {}), '()\n', (1166, 1168), False, 'from services.environment_service import EnvService\n'), ((1346, 1384), 'services.environment_service.EnvService.get_google_search_api_key', 'EnvService.get_google_search_api_key', ([], {}), '()\n', (1382, 1384), False, 'from services.environment_service import EnvService\n'), ((1424, 1464), 'services.environment_service.EnvService.get_google_search_engine_id', 'EnvService.get_google_search_engine_id', ([], {}), '()\n', (1462, 1464), False, 'from services.environment_service import EnvService\n'), ((1485, 1511), 'asyncio.get_running_loop', 'asyncio.get_running_loop', ([], {}), '()\n', (1509, 1511), False, 'import asyncio\n'), ((1536, 2191), 'llama_index.QuestionAnswerPrompt', 'QuestionAnswerPrompt', (['"""You are formulating the response to a search query given the search prompt and the context. Context information is below. The text \'<|endofstatement|>\' is used to separate chat entries and make it easier for you to understand the context\n---------------------\n{context_str}\n---------------------\nNever say \'<|endofstatement|>\'\nGiven the context information and not prior knowledge, answer the question, say that you were unable to answer the question if there is not sufficient context to formulate a decisive answer. If the prior knowledge/context was sufficient, simply repeat it. The search query was: {query_str}\n"""'], {}), '(\n """You are formulating the response to a search query given the search prompt and the context. Context information is below. The text \'<|endofstatement|>\' is used to separate chat entries and make it easier for you to understand the context\n---------------------\n{context_str}\n---------------------\nNever say \'<|endofstatement|>\'\nGiven the context information and not prior knowledge, answer the question, say that you were unable to answer the question if there is not sufficient context to formulate a decisive answer. If the prior knowledge/context was sufficient, simply repeat it. The search query was: {query_str}\n"""\n )\n', (1556, 2191), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((2322, 2347), 'os.getenv', 'os.getenv', (['"""OPENAI_TOKEN"""'], {}), "('OPENAI_TOKEN')\n", (2331, 2347), False, 'import os\n'), ((14651, 14668), 'llama_index.OpenAIEmbedding', 'OpenAIEmbedding', ([], {}), '()\n', (14666, 14668), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((14920, 14952), 'llama_index.callbacks.CallbackManager', 'CallbackManager', (['[token_counter]'], {}), '([token_counter])\n', (14935, 14952), False, 'from llama_index.callbacks import CallbackManager, TokenCountingHandler\n'), ((14980, 15106), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'embed_model': 'embedding_model', 'callback_manager': 'callback_manager'}), '(llm_predictor=llm_predictor, embed_model=\n embedding_model, callback_manager=callback_manager)\n', (15008, 15106), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((15344, 15381), 'llama_index.callbacks.CallbackManager', 'CallbackManager', (['[token_counter_mock]'], {}), '([token_counter_mock])\n', (15359, 15381), False, 'from llama_index.callbacks import CallbackManager, TokenCountingHandler\n'), ((15409, 15438), 'llama_index.MockEmbedding', 'MockEmbedding', ([], {'embed_dim': '(1536)'}), '(embed_dim=1536)\n', (15422, 15438), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((15470, 15573), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'embed_model': 'embed_model_mock', 'callback_manager': 'callback_manager_mock'}), '(embed_model=embed_model_mock, callback_manager\n =callback_manager_mock)\n', (15498, 15573), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((5959, 5982), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {}), '()\n', (5980, 5982), False, 'import aiohttp\n'), ((6864, 6887), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {}), '()\n', (6885, 6887), False, 'import aiohttp\n'), ((8966, 9063), 'langchain.OpenAI', 'OpenAI', ([], {'max_tokens': '(50)', 'temperature': '(0.4)', 'presence_penalty': '(0.65)', 'model_name': '"""text-davinci-003"""'}), "(max_tokens=50, temperature=0.4, presence_penalty=0.65, model_name=\n 'text-davinci-003')\n", (8972, 9063), False, 'from langchain import OpenAI\n'), ((15656, 15753), 'functools.partial', 'partial', (['GPTVectorStoreIndex.from_documents', 'documents'], {'service_context': 'service_context_mock'}), '(GPTVectorStoreIndex.from_documents, documents, service_context=\n service_context_mock)\n', (15663, 15753), False, 'from functools import partial\n'), ((17056, 17116), 'llama_index.composability.QASummaryQueryEngineBuilder', 'QASummaryQueryEngineBuilder', ([], {'service_context': 'service_context'}), '(service_context=service_context)\n', (17083, 17116), False, 'from llama_index.composability import QASummaryQueryEngineBuilder\n'), ((17602, 17660), 'llama_index.indices.query.query_transform.StepDecomposeQueryTransform', 'StepDecomposeQueryTransform', (['service_context.llm_predictor'], {}), '(service_context.llm_predictor)\n', (17629, 17660), False, 'from llama_index.indices.query.query_transform import StepDecomposeQueryTransform\n'), ((17716, 17801), 'llama_index.retrievers.VectorIndexRetriever', 'VectorIndexRetriever', ([], {'index': 'index', 'similarity_top_k': '(nodes or DEFAULT_SEARCH_NODES)'}), '(index=index, similarity_top_k=nodes or\n DEFAULT_SEARCH_NODES)\n', (17736, 17801), False, 'from llama_index.retrievers import VectorIndexRetriever\n'), ((17881, 18059), 'llama_index.get_response_synthesizer', 'get_response_synthesizer', ([], {'response_mode': 'response_mode', 'use_async': '(True)', 'refine_template': 'CHAT_REFINE_PROMPT', 'text_qa_template': 'self.qaprompt', 'service_context': 'service_context'}), '(response_mode=response_mode, use_async=True,\n refine_template=CHAT_REFINE_PROMPT, text_qa_template=self.qaprompt,\n service_context=service_context)\n', (17905, 18059), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((18175, 18264), 'llama_index.query_engine.RetrieverQueryEngine', 'RetrieverQueryEngine', ([], {'retriever': 'retriever', 'response_synthesizer': 'response_synthesizer'}), '(retriever=retriever, response_synthesizer=\n response_synthesizer)\n', (18195, 18264), False, 'from llama_index.query_engine import RetrieverQueryEngine, MultiStepQueryEngine\n'), ((18327, 18554), 'llama_index.query_engine.MultiStepQueryEngine', 'MultiStepQueryEngine', ([], {'query_engine': 'query_engine', 'query_transform': 'step_decompose_transform', 'index_summary': '"""Provides information about everything you need to know about this topic, use this to answer the question."""'}), "(query_engine=query_engine, query_transform=\n step_decompose_transform, index_summary=\n 'Provides information about everything you need to know about this topic, use this to answer the question.'\n )\n", (18347, 18554), False, 'from llama_index.query_engine import RetrieverQueryEngine, MultiStepQueryEngine\n'), ((3141, 3164), 'discord.Color.blurple', 'discord.Color.blurple', ([], {}), '()\n', (3162, 3164), False, 'import discord\n'), ((3542, 3565), 'discord.Color.blurple', 'discord.Color.blurple', ([], {}), '()\n', (3563, 3565), False, 'import discord\n'), ((3928, 3951), 'discord.Color.blurple', 'discord.Color.blurple', ([], {}), '()\n', (3949, 3951), False, 'import discord\n'), ((4325, 4348), 'discord.Color.blurple', 'discord.Color.blurple', ([], {}), '()\n', (4346, 4348), False, 'import discord\n'), ((4692, 4715), 'discord.Color.blurple', 'discord.Color.blurple', ([], {}), '()\n', (4713, 4715), False, 'import discord\n'), ((5080, 5103), 'discord.Color.blurple', 'discord.Color.blurple', ([], {}), '()\n', (5101, 5103), False, 'import discord\n'), ((5487, 5510), 'discord.Color.blurple', 'discord.Color.blurple', ([], {}), '()\n', (5508, 5510), False, 'import discord\n'), ((5684, 5751), 'llama_index.BeautifulSoupWebReader', 'BeautifulSoupWebReader', ([], {'website_extractor': 'DEFAULT_WEBSITE_EXTRACTOR'}), '(website_extractor=DEFAULT_WEBSITE_EXTRACTOR)\n', (5706, 5751), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((6549, 6592), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_files': '[f.name]'}), '(input_files=[f.name])\n', (6570, 6592), False, 'from llama_index import QuestionAnswerPrompt, GPTVectorStoreIndex, BeautifulSoupWebReader, Document, LLMPredictor, OpenAIEmbedding, SimpleDirectoryReader, MockEmbedding, ServiceContext, get_response_synthesizer\n'), ((7897, 7918), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (7916, 7918), False, 'import traceback\n'), ((8064, 8085), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (8083, 8085), False, 'import traceback\n'), ((11410, 11431), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (11429, 11431), False, 'import traceback\n'), ((14711, 14754), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': 'model'}), '(temperature=0, model_name=model)\n', (14721, 14754), False, 'from langchain.chat_models import ChatOpenAI\n'), ((2711, 2723), 'datetime.date.today', 'date.today', ([], {}), '()\n', (2721, 2723), False, 'from datetime import datetime, date\n'), ((2732, 2744), 'datetime.date.today', 'date.today', ([], {}), '()\n', (2742, 2744), False, 'from datetime import datetime, date\n'), ((6164, 6220), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'suffix': '""".pdf"""', 'delete': '(False)'}), "(suffix='.pdf', delete=False)\n", (6191, 6220), False, 'import tempfile\n'), ((12525, 12548), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {}), '()\n', (12546, 12548), False, 'import aiohttp\n'), ((14421, 14442), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (14440, 14442), False, 'import traceback\n'), ((14825, 14859), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['model'], {}), '(model)\n', (14852, 14859), False, 'import tiktoken\n'), ((15245, 15279), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['model'], {}), '(model)\n', (15272, 15279), False, 'import tiktoken\n'), ((16269, 16377), 'functools.partial', 'partial', (['GPTVectorStoreIndex.from_documents', 'documents'], {'service_context': 'service_context', 'use_async': '(True)'}), '(GPTVectorStoreIndex.from_documents, documents, service_context=\n service_context, use_async=True)\n', (16276, 16377), False, 'from functools import partial\n'), ((17209, 17263), 'functools.partial', 'partial', (['graph_builder.build_from_documents', 'documents'], {}), '(graph_builder.build_from_documents, documents)\n', (17216, 17263), False, 'from functools import partial\n'), ((19989, 20016), 'functools.partial', 'partial', (['index.query', 'query'], {}), '(index.query, query)\n', (19996, 20016), False, 'from functools import partial\n'), ((18735, 18779), 'functools.partial', 'partial', (['multistep_query_engine.query', 'query'], {}), '(multistep_query_engine.query, query)\n', (18742, 18779), False, 'from functools import partial\n'), ((18923, 18957), 'functools.partial', 'partial', (['query_engine.query', 'query'], {}), '(query_engine.query, query)\n', (18930, 18957), False, 'from functools import partial\n'), ((2534, 2556), 'services.environment_service.EnvService.save_path', 'EnvService.save_path', ([], {}), '()\n', (2554, 2556), False, 'from services.environment_service import EnvService\n'), ((2828, 2850), 'services.environment_service.EnvService.save_path', 'EnvService.save_path', ([], {}), '()\n', (2848, 2850), False, 'from services.environment_service import EnvService\n'), ((14174, 14207), 'functools.partial', 'partial', (['self.index_webpage', 'link'], {}), '(self.index_webpage, link)\n', (14181, 14207), False, 'from functools import partial\n'), ((10093, 10107), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (10105, 10107), False, 'from datetime import datetime, date\n'), ((10513, 10527), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (10525, 10527), False, 'from datetime import datetime, date\n')]

from typing import List from llama_index import Document, StorageContext, VectorStoreIndex, load_index_from_storage import os def create_vector(service_context, vector_storage_dir: str, doc_loader: callable) -> List[Document]: if not os.path.exists(vector_storage_dir): documents = doc_loader() print(f"About to build vector-index over {len(documents)} document(s) ...") vector_index = VectorStoreIndex.from_documents( documents, service_context=service_context ) print(f"Storing vector-index to {vector_storage_dir} ...") vector_index.storage_context.persist(persist_dir=vector_storage_dir) else: print(f"Loading vector-index from storage from {vector_storage_dir} ...") storage_context_vector = StorageContext.from_defaults(persist_dir=vector_storage_dir) vector_index = load_index_from_storage( service_context=service_context, storage_context=storage_context_vector ) return vector_index

[((240, 274), 'os.path.exists', 'os.path.exists', (['vector_storage_dir'], {}), '(vector_storage_dir)\n', (254, 274), False, 'import os\n'), ((416, 491), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (447, 491), False, 'from llama_index import Document, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((795, 855), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'vector_storage_dir'}), '(persist_dir=vector_storage_dir)\n', (823, 855), False, 'from llama_index import Document, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((879, 980), 'llama_index.load_index_from_storage', 'load_index_from_storage', ([], {'service_context': 'service_context', 'storage_context': 'storage_context_vector'}), '(service_context=service_context, storage_context=\n storage_context_vector)\n', (902, 980), False, 'from llama_index import Document, StorageContext, VectorStoreIndex, load_index_from_storage\n')]

import streamlit as st import torch from glob import glob from pathlib import Path from llama_index.prompts.prompts import SimpleInputPrompt from llama_index import ( set_global_service_context, ServiceContext, VectorStoreIndex, download_loader, ) from langchain.embeddings import HuggingFaceEmbeddings from llama_index.embeddings import LangchainEmbedding from transformers import AutoTokenizer, AutoModelForCausalLM from llama_index.llms import HuggingFaceLLM PyMuPDFReader = download_loader("PyMuPDFReader") loader = PyMuPDFReader() model_name = "meta-llama/Llama-2-7b-chat-hf" auth_token = "*******************************" system_prompt = """<s>[INST] <<SYS>> You are a helpful, respectful and honest assistant. Always answer as helpfully as possible, while being safe. Your answers should not include any harmful, unethical, racist, sexist, toxic, dangerous, or illegal content. Please ensure that your responses are socially unbiased and positive in nature. If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. If you don't know the answer to a question, please don't share false information. <</SYS>> """ # Llama2's official system prompt @st.cache_resource def model_tokenizer_embedder(model_name, auth_token): tokenizer = AutoTokenizer.from_pretrained( model_name, cache_dir="./model/", use_auth_token=auth_token ) model = AutoModelForCausalLM.from_pretrained( model_name, cache_dir="./model/", use_auth_token=auth_token, torch_dtype=torch.float16, load_in_8bit=True, ) embedding_llm = LangchainEmbedding( HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2") ) return tokenizer, model, embedding_llm def load_documents(directory): documents = [] for item_path in glob(directory + "*.pdf"): # documents.extend(loader.load(file_path=Path(item_path), metadata=True)) documents.extend(loader.load(file_path=item_path, metadata=True)) return documents tokenizer, model, embedding_llm = model_tokenizer_embedder(model_name, auth_token) query_wrapper_prompt = SimpleInputPrompt("{query_str} [/INST]") llm = HuggingFaceLLM( context_window=4096, max_new_tokens=256, system_prompt=system_prompt, query_wrapper_prompt=query_wrapper_prompt, model=model, tokenizer=tokenizer, ) service_context = ServiceContext.from_defaults( chunk_size=1024, llm=llm, embed_model=embedding_llm ) set_global_service_context(service_context) documents = load_documents("./documents/") index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() st.title("Llama2 RAG") prompt = st.text_input("Enter your prompt") if prompt: response = query_engine.query(prompt) st.write(response.response)

[((495, 527), 'llama_index.download_loader', 'download_loader', (['"""PyMuPDFReader"""'], {}), "('PyMuPDFReader')\n", (510, 527), False, 'from llama_index import set_global_service_context, ServiceContext, VectorStoreIndex, download_loader\n'), ((2176, 2216), 'llama_index.prompts.prompts.SimpleInputPrompt', 'SimpleInputPrompt', (['"""{query_str} [/INST]"""'], {}), "('{query_str} [/INST]')\n", (2193, 2216), False, 'from llama_index.prompts.prompts import SimpleInputPrompt\n'), ((2224, 2394), 'llama_index.llms.HuggingFaceLLM', 'HuggingFaceLLM', ([], {'context_window': '(4096)', 'max_new_tokens': '(256)', 'system_prompt': 'system_prompt', 'query_wrapper_prompt': 'query_wrapper_prompt', 'model': 'model', 'tokenizer': 'tokenizer'}), '(context_window=4096, max_new_tokens=256, system_prompt=\n system_prompt, query_wrapper_prompt=query_wrapper_prompt, model=model,\n tokenizer=tokenizer)\n', (2238, 2394), False, 'from llama_index.llms import HuggingFaceLLM\n'), ((2432, 2518), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'chunk_size': '(1024)', 'llm': 'llm', 'embed_model': 'embedding_llm'}), '(chunk_size=1024, llm=llm, embed_model=\n embedding_llm)\n', (2460, 2518), False, 'from llama_index import set_global_service_context, ServiceContext, VectorStoreIndex, download_loader\n'), ((2520, 2563), 'llama_index.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (2546, 2563), False, 'from llama_index import set_global_service_context, ServiceContext, VectorStoreIndex, download_loader\n'), ((2616, 2658), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (2647, 2658), False, 'from llama_index import set_global_service_context, ServiceContext, VectorStoreIndex, download_loader\n'), ((2699, 2721), 'streamlit.title', 'st.title', (['"""Llama2 RAG"""'], {}), "('Llama2 RAG')\n", (2707, 2721), True, 'import streamlit as st\n'), ((2732, 2766), 'streamlit.text_input', 'st.text_input', (['"""Enter your prompt"""'], {}), "('Enter your prompt')\n", (2745, 2766), True, 'import streamlit as st\n'), ((1330, 1424), 'transformers.AutoTokenizer.from_pretrained', 'AutoTokenizer.from_pretrained', (['model_name'], {'cache_dir': '"""./model/"""', 'use_auth_token': 'auth_token'}), "(model_name, cache_dir='./model/',\n use_auth_token=auth_token)\n", (1359, 1424), False, 'from transformers import AutoTokenizer, AutoModelForCausalLM\n'), ((1447, 1594), 'transformers.AutoModelForCausalLM.from_pretrained', 'AutoModelForCausalLM.from_pretrained', (['model_name'], {'cache_dir': '"""./model/"""', 'use_auth_token': 'auth_token', 'torch_dtype': 'torch.float16', 'load_in_8bit': '(True)'}), "(model_name, cache_dir='./model/',\n use_auth_token=auth_token, torch_dtype=torch.float16, load_in_8bit=True)\n", (1483, 1594), False, 'from transformers import AutoTokenizer, AutoModelForCausalLM\n'), ((1863, 1888), 'glob.glob', 'glob', (["(directory + '*.pdf')"], {}), "(directory + '*.pdf')\n", (1867, 1888), False, 'from glob import glob\n'), ((2824, 2851), 'streamlit.write', 'st.write', (['response.response'], {}), '(response.response)\n', (2832, 2851), True, 'import streamlit as st\n'), ((1687, 1739), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '"""all-MiniLM-L6-v2"""'}), "(model_name='all-MiniLM-L6-v2')\n", (1708, 1739), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n')]

from langchain.agents import load_tools, Tool, tool from langchain.agents import initialize_agent from langchain.llms import OpenAI, OpenAIChat from langchain.embeddings.openai import OpenAIEmbeddings from langchain.vectorstores import Qdrant, Chroma, Pinecone, FAISS from langchain.text_splitter import CharacterTextSplitter from langchain.document_loaders import TextLoader from langchain.chains import RetrievalQA from llama_index import GPTSimpleVectorIndex, SimpleDirectoryReader, Document from llama_index.readers.qdrant import QdrantReader from llama_index.optimization.optimizer import SentenceEmbeddingOptimizer from gptcache import cache from gptcache.adapter import openai import pinecone, warnings, yaml, os warnings.filterwarnings("ignore") class KapwingVectorStore: def __init__(self, chunk_size=10000, model_name="gpt-4", temperature=0, filepath='data/query_instructions.txt'): cache.init() cache.set_openai_key() with open("config/config.yaml", 'r') as stream: config = yaml.safe_load(stream) os.environ["OPENAI_API_KEY"] = config['OPENAI_API_KEY'] self.qdrant_host = config['QDRANT_HOST'] self.qdrant_api_key = config['QDRANT_API_KEY'] self.pcone_api_key = config['PINECONE_API_KEY'] self.pcone_env = config['PINECONE_HOST'] self.text_splitter = CharacterTextSplitter(separator="\n\n\n", chunk_size=chunk_size, chunk_overlap=0) self.loader = TextLoader(filepath) self.docs = self.text_splitter.split_documents(self.loader.load()) self.embeddings = OpenAIEmbeddings() self.llm_ = OpenAIChat(model_name=model_name, temperature=temperature) with open("config/prompts.yaml", 'r') as stream: prompts = yaml.safe_load(stream) self.prefix = prompts['vectorstore_prefix'] self.suffix = prompts['vectorstore_suffix'] self.simple_scripts_prompt = prompts['simple_scripts_prompt'] self.mask_prompt = prompts['mask_prompt'] self.fast_func_prompt = prompts['fast_func_prompt'] def get_qdrant(self): self.qdrant_tool_db = Qdrant.from_documents(self.docs, self.embeddings, host=self.qdrant_host, prefer_grpc=True, api_key=self.qdrant_api_key).as_retriever() self.qdrant_tool_vec = RetrievalQA.from_llm(llm=self.llm_, retriever=self.qdrant_tool_db) return self.qdrant_tool_db, self.qdrant_tool_vec def get_faiss(self): self.faiss_tool_db = FAISS.from_documents(self.docs, self.embeddings).as_retriever() self.faiss_tool_vec = RetrievalQA.from_llm(llm=self.llm_, retriever=self.faiss_tool_db) return self.faiss_tool_db, self.faiss_tool_vec def get_chroma(self): self.chroma_tool_db = Chroma.from_documents(self.docs, self.embeddings, collection_name="tools").as_retriever() self.chroma_tool_vec = RetrievalQA.from_llm(llm=self.llm_, retriever=self.chroma_tool_db) return self.chroma_tool_db, self.chroma_tool_vec def get_pcone(self): pinecone.init(api_key=self.pcone_api_key, environment=self.pcone_env) self.pcone_tool_db = Pinecone.from_documents(self.docs, self.embeddings, index_name="tool-db").as_retriever() self.pcone_tool_vec = RetrievalQA.from_llm(llm=self.llm_, retriever=self.pcone_tool_db) return self.pcone_tool_db, self.pcone_tool_vec def set_gpt_index(self): self.gpt_docs = [Document(doc.page_content) for doc in self.docs] self.tool_index = GPTSimpleVectorIndex.from_documents(self.gpt_docs) def gpt_index_query(self, query): res = self.tool_index.query(self.prefix.format(query=query) + self.mask_prompt + self.suffix, similarity_top_k=3 # optimizer=SentenceEmbeddingOptimizer(percentile_cutoff=0.3) ) return res def gpt_index_funcs(self, query): res = self.tool_index.query(self.fast_func_prompt.format(query=query), similarity_top_k=3 # optimizer=SentenceEmbeddingOptimizer(percentile_cutoff=0.3) ) return res def gpt_index_scripts_query(self, query): res = self.tool_index.query(self.simple_scripts_prompt.format(query=query) + self.mask_prompt, # similarity_top_k=3, # optimizer=SentenceEmbeddingOptimizer(percentile_cutoff=0.3) ) return res def qdrant_query(self, query): res = self.qdrant_tool_vec.run(self.prefix.format(query=query) + self.suffix) return res def pcone_query(self, query): res = self.pcone_tool_vec.run(self.prefix.format(query=query) + self.suffix) return res def faiss_query(self, query): res = self.faiss_tool_vec.run(self.prefix.format(query=query) + self.suffix) return res def faiss_scripts_query(self, query): res = self.faiss_tool_vec.run(self.simple_scripts_prompt.format(query=query) + self.mask_prompt) return res def main(): query = input("QUERY: ") vec = KapwingVectorStore() vec.get_faiss() res = vec.faiss_query(query) print(res) if __name__ == "__main__": main()

[((721, 754), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (744, 754), False, 'import pinecone, warnings, yaml, os\n'), ((978, 990), 'gptcache.cache.init', 'cache.init', ([], {}), '()\n', (988, 990), False, 'from gptcache import cache\n'), ((999, 1021), 'gptcache.cache.set_openai_key', 'cache.set_openai_key', ([], {}), '()\n', (1019, 1021), False, 'from gptcache import cache\n'), ((1435, 1520), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'separator': '"""\n\n\n"""', 'chunk_size': 'chunk_size', 'chunk_overlap': '(0)'}), "(separator='\\n\\n\\n', chunk_size=chunk_size,\n chunk_overlap=0)\n", (1456, 1520), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((1539, 1559), 'langchain.document_loaders.TextLoader', 'TextLoader', (['filepath'], {}), '(filepath)\n', (1549, 1559), False, 'from langchain.document_loaders import TextLoader\n'), ((1662, 1680), 'langchain.embeddings.openai.OpenAIEmbeddings', 'OpenAIEmbeddings', ([], {}), '()\n', (1678, 1680), False, 'from langchain.embeddings.openai import OpenAIEmbeddings\n'), ((1701, 1759), 'langchain.llms.OpenAIChat', 'OpenAIChat', ([], {'model_name': 'model_name', 'temperature': 'temperature'}), '(model_name=model_name, temperature=temperature)\n', (1711, 1759), False, 'from langchain.llms import OpenAI, OpenAIChat\n'), ((2379, 2445), 'langchain.chains.RetrievalQA.from_llm', 'RetrievalQA.from_llm', ([], {'llm': 'self.llm_', 'retriever': 'self.qdrant_tool_db'}), '(llm=self.llm_, retriever=self.qdrant_tool_db)\n', (2399, 2445), False, 'from langchain.chains import RetrievalQA\n'), ((2652, 2717), 'langchain.chains.RetrievalQA.from_llm', 'RetrievalQA.from_llm', ([], {'llm': 'self.llm_', 'retriever': 'self.faiss_tool_db'}), '(llm=self.llm_, retriever=self.faiss_tool_db)\n', (2672, 2717), False, 'from langchain.chains import RetrievalQA\n'), ((2951, 3017), 'langchain.chains.RetrievalQA.from_llm', 'RetrievalQA.from_llm', ([], {'llm': 'self.llm_', 'retriever': 'self.chroma_tool_db'}), '(llm=self.llm_, retriever=self.chroma_tool_db)\n', (2971, 3017), False, 'from langchain.chains import RetrievalQA\n'), ((3109, 3178), 'pinecone.init', 'pinecone.init', ([], {'api_key': 'self.pcone_api_key', 'environment': 'self.pcone_env'}), '(api_key=self.pcone_api_key, environment=self.pcone_env)\n', (3122, 3178), False, 'import pinecone, warnings, yaml, os\n'), ((3327, 3392), 'langchain.chains.RetrievalQA.from_llm', 'RetrievalQA.from_llm', ([], {'llm': 'self.llm_', 'retriever': 'self.pcone_tool_db'}), '(llm=self.llm_, retriever=self.pcone_tool_db)\n', (3347, 3392), False, 'from langchain.chains import RetrievalQA\n'), ((3578, 3628), 'llama_index.GPTSimpleVectorIndex.from_documents', 'GPTSimpleVectorIndex.from_documents', (['self.gpt_docs'], {}), '(self.gpt_docs)\n', (3613, 3628), False, 'from llama_index import GPTSimpleVectorIndex, SimpleDirectoryReader, Document\n'), ((1108, 1130), 'yaml.safe_load', 'yaml.safe_load', (['stream'], {}), '(stream)\n', (1122, 1130), False, 'import pinecone, warnings, yaml, os\n'), ((1848, 1870), 'yaml.safe_load', 'yaml.safe_load', (['stream'], {}), '(stream)\n', (1862, 1870), False, 'import pinecone, warnings, yaml, os\n'), ((3503, 3529), 'llama_index.Document', 'Document', (['doc.page_content'], {}), '(doc.page_content)\n', (3511, 3529), False, 'from llama_index import GPTSimpleVectorIndex, SimpleDirectoryReader, Document\n'), ((2213, 2336), 'langchain.vectorstores.Qdrant.from_documents', 'Qdrant.from_documents', (['self.docs', 'self.embeddings'], {'host': 'self.qdrant_host', 'prefer_grpc': '(True)', 'api_key': 'self.qdrant_api_key'}), '(self.docs, self.embeddings, host=self.qdrant_host,\n prefer_grpc=True, api_key=self.qdrant_api_key)\n', (2234, 2336), False, 'from langchain.vectorstores import Qdrant, Chroma, Pinecone, FAISS\n'), ((2558, 2606), 'langchain.vectorstores.FAISS.from_documents', 'FAISS.from_documents', (['self.docs', 'self.embeddings'], {}), '(self.docs, self.embeddings)\n', (2578, 2606), False, 'from langchain.vectorstores import Qdrant, Chroma, Pinecone, FAISS\n'), ((2830, 2904), 'langchain.vectorstores.Chroma.from_documents', 'Chroma.from_documents', (['self.docs', 'self.embeddings'], {'collection_name': '"""tools"""'}), "(self.docs, self.embeddings, collection_name='tools')\n", (2851, 2904), False, 'from langchain.vectorstores import Qdrant, Chroma, Pinecone, FAISS\n'), ((3208, 3281), 'langchain.vectorstores.Pinecone.from_documents', 'Pinecone.from_documents', (['self.docs', 'self.embeddings'], {'index_name': '"""tool-db"""'}), "(self.docs, self.embeddings, index_name='tool-db')\n", (3231, 3281), False, 'from langchain.vectorstores import Qdrant, Chroma, Pinecone, FAISS\n')]

import os, config, openai from llama_index import StorageContext, load_index_from_storage openai.api_key = config.OPENAI_API_KEY os.environ['OPENAI_API_KEY'] = config.OPENAI_API_KEY # new version of llama index uses StorageContext instead of load_from_disk # index = GPTSimpleVectorIndex.load_from_disk('index_news.json') storage_context = StorageContext.from_defaults(persist_dir="./storage") index = load_index_from_storage(storage_context) # new version of llama index uses query_engine.query() query_engine = index.as_query_engine() response = query_engine.query("What are some near-term risks to Nvidia?") print(response)

[((342, 395), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""./storage"""'}), "(persist_dir='./storage')\n", (370, 395), False, 'from llama_index import StorageContext, load_index_from_storage\n'), ((404, 444), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (427, 444), False, 'from llama_index import StorageContext, load_index_from_storage\n')]

import os from dotenv import load_dotenv, find_dotenv import numpy as np import nest_asyncio nest_asyncio.apply() def get_openai_api_key(): _ = load_dotenv(find_dotenv()) return os.getenv("OPENAI_API_KEY") from trulens_eval import ( Feedback, TruLlama, OpenAI ) from trulens_eval.feedback import Groundedness def get_prebuilt_trulens_recorder(query_engine, app_id): openai = OpenAI() qa_relevance = ( Feedback(openai.relevance_with_cot_reasons, name="Answer Relevance") .on_input_output() ) qs_relevance = ( Feedback(openai.relevance_with_cot_reasons, name = "Context Relevance") .on_input() .on(TruLlama.select_source_nodes().node.text) .aggregate(np.mean) ) # grounded = Groundedness(groundedness_provider=openai, summarize_provider=openai) grounded = Groundedness(groundedness_provider=openai) groundedness = ( Feedback(grounded.groundedness_measure_with_cot_reasons, name="Groundedness") .on(TruLlama.select_source_nodes().node.text) .on_output() .aggregate(grounded.grounded_statements_aggregator) ) feedbacks = [qa_relevance, qs_relevance, groundedness] tru_recorder = TruLlama( query_engine, app_id=app_id, feedbacks=feedbacks ) return tru_recorder from llama_index import ServiceContext, VectorStoreIndex, StorageContext from llama_index.node_parser import SentenceWindowNodeParser from llama_index.indices.postprocessor import MetadataReplacementPostProcessor from llama_index.indices.postprocessor import SentenceTransformerRerank from llama_index import load_index_from_storage import os def build_sentence_window_index( documents, llm, embed_model="local:BAAI/bge-small-en-v1.5", sentence_window_size=3, save_dir="sentence_index", ): # create the sentence window node parser w/ default settings node_parser = SentenceWindowNodeParser.from_defaults( window_size=sentence_window_size, window_metadata_key="window", original_text_metadata_key="original_text", ) sentence_context = ServiceContext.from_defaults( llm=llm, embed_model=embed_model, node_parser=node_parser, ) if not os.path.exists(save_dir): sentence_index = VectorStoreIndex.from_documents( documents, service_context=sentence_context ) sentence_index.storage_context.persist(persist_dir=save_dir) else: sentence_index = load_index_from_storage( StorageContext.from_defaults(persist_dir=save_dir), service_context=sentence_context, ) return sentence_index def get_sentence_window_query_engine( sentence_index, similarity_top_k=6, rerank_top_n=2, ): # define postprocessors postproc = MetadataReplacementPostProcessor(target_metadata_key="window") rerank = SentenceTransformerRerank( top_n=rerank_top_n, model="BAAI/bge-reranker-base" ) sentence_window_engine = sentence_index.as_query_engine( similarity_top_k=similarity_top_k, node_postprocessors=[postproc, rerank] ) return sentence_window_engine from llama_index.node_parser import HierarchicalNodeParser from llama_index.node_parser import get_leaf_nodes from llama_index import StorageContext from llama_index.retrievers import AutoMergingRetriever from llama_index.indices.postprocessor import SentenceTransformerRerank from llama_index.query_engine import RetrieverQueryEngine def build_automerging_index( documents, llm, embed_model="local:BAAI/bge-small-en-v1.5", save_dir="merging_index", chunk_sizes=None, ): chunk_sizes = chunk_sizes or [2048, 512, 128] node_parser = HierarchicalNodeParser.from_defaults(chunk_sizes=chunk_sizes) nodes = node_parser.get_nodes_from_documents(documents) leaf_nodes = get_leaf_nodes(nodes) merging_context = ServiceContext.from_defaults( llm=llm, embed_model=embed_model, ) storage_context = StorageContext.from_defaults() storage_context.docstore.add_documents(nodes) if not os.path.exists(save_dir): automerging_index = VectorStoreIndex( leaf_nodes, storage_context=storage_context, service_context=merging_context ) automerging_index.storage_context.persist(persist_dir=save_dir) else: automerging_index = load_index_from_storage( StorageContext.from_defaults(persist_dir=save_dir), service_context=merging_context, ) return automerging_index def get_automerging_query_engine( automerging_index, similarity_top_k=12, rerank_top_n=6, ): base_retriever = automerging_index.as_retriever(similarity_top_k=similarity_top_k) retriever = AutoMergingRetriever( base_retriever, automerging_index.storage_context, verbose=True ) rerank = SentenceTransformerRerank( top_n=rerank_top_n, model="BAAI/bge-reranker-base" ) auto_merging_engine = RetrieverQueryEngine.from_args( retriever, node_postprocessors=[rerank] ) return auto_merging_engine

[((96, 116), 'nest_asyncio.apply', 'nest_asyncio.apply', ([], {}), '()\n', (114, 116), False, 'import nest_asyncio\n'), ((192, 219), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (201, 219), False, 'import os\n'), ((408, 416), 'trulens_eval.OpenAI', 'OpenAI', ([], {}), '()\n', (414, 416), False, 'from trulens_eval import Feedback, TruLlama, OpenAI\n'), ((862, 904), 'trulens_eval.feedback.Groundedness', 'Groundedness', ([], {'groundedness_provider': 'openai'}), '(groundedness_provider=openai)\n', (874, 904), False, 'from trulens_eval.feedback import Groundedness\n'), ((1245, 1303), 'trulens_eval.TruLlama', 'TruLlama', (['query_engine'], {'app_id': 'app_id', 'feedbacks': 'feedbacks'}), '(query_engine, app_id=app_id, feedbacks=feedbacks)\n', (1253, 1303), False, 'from trulens_eval import Feedback, TruLlama, OpenAI\n'), ((1954, 2104), 'llama_index.node_parser.SentenceWindowNodeParser.from_defaults', 'SentenceWindowNodeParser.from_defaults', ([], {'window_size': 'sentence_window_size', 'window_metadata_key': '"""window"""', 'original_text_metadata_key': '"""original_text"""'}), "(window_size=sentence_window_size,\n window_metadata_key='window', original_text_metadata_key='original_text')\n", (1992, 2104), False, 'from llama_index.node_parser import SentenceWindowNodeParser\n'), ((2155, 2247), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': 'embed_model', 'node_parser': 'node_parser'}), '(llm=llm, embed_model=embed_model, node_parser=\n node_parser)\n', (2183, 2247), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext\n'), ((2861, 2923), 'llama_index.indices.postprocessor.MetadataReplacementPostProcessor', 'MetadataReplacementPostProcessor', ([], {'target_metadata_key': '"""window"""'}), "(target_metadata_key='window')\n", (2893, 2923), False, 'from llama_index.indices.postprocessor import MetadataReplacementPostProcessor\n'), ((2937, 3014), 'llama_index.indices.postprocessor.SentenceTransformerRerank', 'SentenceTransformerRerank', ([], {'top_n': 'rerank_top_n', 'model': '"""BAAI/bge-reranker-base"""'}), "(top_n=rerank_top_n, model='BAAI/bge-reranker-base')\n", (2962, 3014), False, 'from llama_index.indices.postprocessor import SentenceTransformerRerank\n'), ((3777, 3838), 'llama_index.node_parser.HierarchicalNodeParser.from_defaults', 'HierarchicalNodeParser.from_defaults', ([], {'chunk_sizes': 'chunk_sizes'}), '(chunk_sizes=chunk_sizes)\n', (3813, 3838), False, 'from llama_index.node_parser import HierarchicalNodeParser\n'), ((3916, 3937), 'llama_index.node_parser.get_leaf_nodes', 'get_leaf_nodes', (['nodes'], {}), '(nodes)\n', (3930, 3937), False, 'from llama_index.node_parser import get_leaf_nodes\n'), ((3960, 4022), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': 'embed_model'}), '(llm=llm, embed_model=embed_model)\n', (3988, 4022), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext\n'), ((4068, 4098), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {}), '()\n', (4096, 4098), False, 'from llama_index import StorageContext\n'), ((4825, 4914), 'llama_index.retrievers.AutoMergingRetriever', 'AutoMergingRetriever', (['base_retriever', 'automerging_index.storage_context'], {'verbose': '(True)'}), '(base_retriever, automerging_index.storage_context,\n verbose=True)\n', (4845, 4914), False, 'from llama_index.retrievers import AutoMergingRetriever\n'), ((4938, 5015), 'llama_index.indices.postprocessor.SentenceTransformerRerank', 'SentenceTransformerRerank', ([], {'top_n': 'rerank_top_n', 'model': '"""BAAI/bge-reranker-base"""'}), "(top_n=rerank_top_n, model='BAAI/bge-reranker-base')\n", (4963, 5015), False, 'from llama_index.indices.postprocessor import SentenceTransformerRerank\n'), ((5056, 5127), 'llama_index.query_engine.RetrieverQueryEngine.from_args', 'RetrieverQueryEngine.from_args', (['retriever'], {'node_postprocessors': '[rerank]'}), '(retriever, node_postprocessors=[rerank])\n', (5086, 5127), False, 'from llama_index.query_engine import RetrieverQueryEngine\n'), ((165, 178), 'dotenv.find_dotenv', 'find_dotenv', ([], {}), '()\n', (176, 178), False, 'from dotenv import load_dotenv, find_dotenv\n'), ((2285, 2309), 'os.path.exists', 'os.path.exists', (['save_dir'], {}), '(save_dir)\n', (2299, 2309), False, 'import os\n'), ((2336, 2412), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'service_context': 'sentence_context'}), '(documents, service_context=sentence_context)\n', (2367, 2412), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext\n'), ((4161, 4185), 'os.path.exists', 'os.path.exists', (['save_dir'], {}), '(save_dir)\n', (4175, 4185), False, 'import os\n'), ((4215, 4313), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', (['leaf_nodes'], {'storage_context': 'storage_context', 'service_context': 'merging_context'}), '(leaf_nodes, storage_context=storage_context,\n service_context=merging_context)\n', (4231, 4313), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext\n'), ((447, 515), 'trulens_eval.Feedback', 'Feedback', (['openai.relevance_with_cot_reasons'], {'name': '"""Answer Relevance"""'}), "(openai.relevance_with_cot_reasons, name='Answer Relevance')\n", (455, 515), False, 'from trulens_eval import Feedback, TruLlama, OpenAI\n'), ((2576, 2626), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'save_dir'}), '(persist_dir=save_dir)\n', (2604, 2626), False, 'from llama_index import StorageContext\n'), ((4479, 4529), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'save_dir'}), '(persist_dir=save_dir)\n', (4507, 4529), False, 'from llama_index import StorageContext\n'), ((683, 713), 'trulens_eval.TruLlama.select_source_nodes', 'TruLlama.select_source_nodes', ([], {}), '()\n', (711, 713), False, 'from trulens_eval import Feedback, TruLlama, OpenAI\n'), ((579, 648), 'trulens_eval.Feedback', 'Feedback', (['openai.relevance_with_cot_reasons'], {'name': '"""Context Relevance"""'}), "(openai.relevance_with_cot_reasons, name='Context Relevance')\n", (587, 648), False, 'from trulens_eval import Feedback, TruLlama, OpenAI\n'), ((935, 1012), 'trulens_eval.Feedback', 'Feedback', (['grounded.groundedness_measure_with_cot_reasons'], {'name': '"""Groundedness"""'}), "(grounded.groundedness_measure_with_cot_reasons, name='Groundedness')\n", (943, 1012), False, 'from trulens_eval import Feedback, TruLlama, OpenAI\n'), ((1029, 1059), 'trulens_eval.TruLlama.select_source_nodes', 'TruLlama.select_source_nodes', ([], {}), '()\n', (1057, 1059), False, 'from trulens_eval import Feedback, TruLlama, OpenAI\n')]

import streamlit as st from llama_index import VectorStoreIndex, ServiceContext from llama_index.llms import Perplexity from llama_index import SimpleDirectoryReader @st.cache_resource(show_spinner=True) def load_data(): with st.spinner(text="Die LSB-Informationen werden indiziert. Das dauert nur ein paar Augenblicke."): reader = SimpleDirectoryReader(input_dir="chatbot/data", recursive=True) docs = reader.load_data() service_context = ServiceContext.from_defaults(llm=llm) index = VectorStoreIndex.from_documents(docs, service_context=service_context) return index pplx_api_key = st.secrets.pplx_key llm = Perplexity( api_key=pplx_api_key, model="pplx-70b-chat", temperature=0.4, system_prompt="Du bist ein Experte für die Leipziger Städtischen Bibliotheken. Du hilfst Nutzerinnen und Nutzern dabei, die Bibliothek zu benutzen. Du beantwortest Fragen zum Ausleihbetrieb, zu den Standorten und den verfügbaren Services. Deine Antworten sollen auf Fakten basieren. Halluziniere keine Informationen über die Bibliotheken, die nicht auf Fakten basieren. Wenn Du eine Information über die Bibliotheken nicht hast, sage den Nutzenden, dass Du Ihnen nicht weiterhelfen kannst. Antworte auf Deutsch." ) st.header("Der LSB-Service-Chat 💬 📚") if "messages" not in st.session_state.keys(): # Initialize the chat message history st.session_state.messages = [ {"role": "assistant", "content": "Was möchten Sie über die Leipziger Städtischen Bibliotheken wissen?"} ] index = load_data() chat_engine = index.as_chat_engine(chat_mode="condense_question", verbose=True) if prompt := st.chat_input("Ihre Frage"): # Prompt for user input and save to chat history st.session_state.messages.append({"role": "user", "content": prompt}) for message in st.session_state.messages: # Display the prior chat messages with st.chat_message(message["role"]): st.write(message["content"]) # If last message is not from assistant, generate a new response if st.session_state.messages[-1]["role"] != "assistant": with st.chat_message("assistant"): with st.spinner("Ich denke nach ..."): response = chat_engine.chat(prompt) st.write(response.response) message = {"role": "assistant", "content": response.response} st.session_state.messages.append(message) # Add response to message history

[((168, 204), 'streamlit.cache_resource', 'st.cache_resource', ([], {'show_spinner': '(True)'}), '(show_spinner=True)\n', (185, 204), True, 'import streamlit as st\n'), ((657, 1257), 'llama_index.llms.Perplexity', 'Perplexity', ([], {'api_key': 'pplx_api_key', 'model': '"""pplx-70b-chat"""', 'temperature': '(0.4)', 'system_prompt': '"""Du bist ein Experte für die Leipziger Städtischen Bibliotheken. Du hilfst Nutzerinnen und Nutzern dabei, die Bibliothek zu benutzen. Du beantwortest Fragen zum Ausleihbetrieb, zu den Standorten und den verfügbaren Services. Deine Antworten sollen auf Fakten basieren. Halluziniere keine Informationen über die Bibliotheken, die nicht auf Fakten basieren. Wenn Du eine Information über die Bibliotheken nicht hast, sage den Nutzenden, dass Du Ihnen nicht weiterhelfen kannst. Antworte auf Deutsch."""'}), "(api_key=pplx_api_key, model='pplx-70b-chat', temperature=0.4,\n system_prompt=\n 'Du bist ein Experte für die Leipziger Städtischen Bibliotheken. Du hilfst Nutzerinnen und Nutzern dabei, die Bibliothek zu benutzen. Du beantwortest Fragen zum Ausleihbetrieb, zu den Standorten und den verfügbaren Services. Deine Antworten sollen auf Fakten basieren. Halluziniere keine Informationen über die Bibliotheken, die nicht auf Fakten basieren. Wenn Du eine Information über die Bibliotheken nicht hast, sage den Nutzenden, dass Du Ihnen nicht weiterhelfen kannst. Antworte auf Deutsch.'\n )\n", (667, 1257), False, 'from llama_index.llms import Perplexity\n'), ((1251, 1288), 'streamlit.header', 'st.header', (['"""Der LSB-Service-Chat 💬 📚"""'], {}), "('Der LSB-Service-Chat 💬 📚')\n", (1260, 1288), True, 'import streamlit as st\n'), ((1311, 1334), 'streamlit.session_state.keys', 'st.session_state.keys', ([], {}), '()\n', (1332, 1334), True, 'import streamlit as st\n'), ((1643, 1670), 'streamlit.chat_input', 'st.chat_input', (['"""Ihre Frage"""'], {}), "('Ihre Frage')\n", (1656, 1670), True, 'import streamlit as st\n'), ((1725, 1794), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (1757, 1794), True, 'import streamlit as st\n'), ((231, 336), 'streamlit.spinner', 'st.spinner', ([], {'text': '"""Die LSB-Informationen werden indiziert. Das dauert nur ein paar Augenblicke."""'}), "(text=\n 'Die LSB-Informationen werden indiziert. Das dauert nur ein paar Augenblicke.'\n )\n", (241, 336), True, 'import streamlit as st\n'), ((345, 408), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': '"""chatbot/data"""', 'recursive': '(True)'}), "(input_dir='chatbot/data', recursive=True)\n", (366, 408), False, 'from llama_index import SimpleDirectoryReader\n'), ((469, 506), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm'}), '(llm=llm)\n', (497, 506), False, 'from llama_index import VectorStoreIndex, ServiceContext\n'), ((523, 593), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['docs'], {'service_context': 'service_context'}), '(docs, service_context=service_context)\n', (554, 593), False, 'from llama_index import VectorStoreIndex, ServiceContext\n'), ((1881, 1913), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (1896, 1913), True, 'import streamlit as st\n'), ((1923, 1951), 'streamlit.write', 'st.write', (["message['content']"], {}), "(message['content'])\n", (1931, 1951), True, 'import streamlit as st\n'), ((2084, 2112), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (2099, 2112), True, 'import streamlit as st\n'), ((2127, 2159), 'streamlit.spinner', 'st.spinner', (['"""Ich denke nach ..."""'], {}), "('Ich denke nach ...')\n", (2137, 2159), True, 'import streamlit as st\n'), ((2221, 2248), 'streamlit.write', 'st.write', (['response.response'], {}), '(response.response)\n', (2229, 2248), True, 'import streamlit as st\n'), ((2335, 2376), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (['message'], {}), '(message)\n', (2367, 2376), True, 'import streamlit as st\n')]

import logging import os import sys from shutil import rmtree import openai from llama_index import ServiceContext, SimpleDirectoryReader, TreeIndex from llama_index.llms.openai import OpenAI logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) openai.api_key = os.environ['OPENAI_API_KEY'] service_context = ServiceContext.from_defaults(llm=OpenAI()) def build_index(data_dir: str, knowledge_base_dir: str) -> None: """Build the vector index from the markdown files in the directory.""" print("Building vector index...") documents = SimpleDirectoryReader(data_dir).load_data() index = TreeIndex.from_documents(documents, service_context=service_context) index.storage_context.persist(persist_dir=knowledge_base_dir) print("Done.") def main() -> None: """Build the vector index from the markdown files in the directory.""" base_dir = os.path.dirname(os.path.abspath(__file__)) knowledge_base_dir = os.path.join(base_dir, "kb") # Delete Storage Directory if os.path.exists(knowledge_base_dir): rmtree(knowledge_base_dir) data_dir = os.path.join(base_dir, "content", "blogs") build_index(data_dir, knowledge_base_dir) if __name__ == "__main__": main()

[((194, 252), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (213, 252), False, 'import logging\n'), ((284, 324), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (305, 324), False, 'import logging\n'), ((688, 756), 'llama_index.TreeIndex.from_documents', 'TreeIndex.from_documents', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (712, 756), False, 'from llama_index import ServiceContext, SimpleDirectoryReader, TreeIndex\n'), ((1026, 1054), 'os.path.join', 'os.path.join', (['base_dir', '"""kb"""'], {}), "(base_dir, 'kb')\n", (1038, 1054), False, 'import os\n'), ((1093, 1127), 'os.path.exists', 'os.path.exists', (['knowledge_base_dir'], {}), '(knowledge_base_dir)\n', (1107, 1127), False, 'import os\n'), ((1179, 1221), 'os.path.join', 'os.path.join', (['base_dir', '"""content"""', '"""blogs"""'], {}), "(base_dir, 'content', 'blogs')\n", (1191, 1221), False, 'import os\n'), ((253, 272), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (270, 272), False, 'import logging\n'), ((425, 433), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {}), '()\n', (431, 433), False, 'from llama_index.llms.openai import OpenAI\n'), ((974, 999), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (989, 999), False, 'import os\n'), ((1137, 1163), 'shutil.rmtree', 'rmtree', (['knowledge_base_dir'], {}), '(knowledge_base_dir)\n', (1143, 1163), False, 'from shutil import rmtree\n'), ((631, 662), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['data_dir'], {}), '(data_dir)\n', (652, 662), False, 'from llama_index import ServiceContext, SimpleDirectoryReader, TreeIndex\n')]

import logging import sys from dotenv import load_dotenv from llama_index.core import VectorStoreIndex from llama_index.readers.web import SimpleWebPageReader def setup_logging(): """ Initialize logging configuration to output logs to stdout. """ logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) def load_environment_variables(): """ Load environment variables from the .env file. """ load_dotenv() def load_web_data(url): """ Load data from a web page using SimpleWebPageReader. :param url: The URL of the web page to load. :return: A list of loaded documents. """ return SimpleWebPageReader(html_to_text=True).load_data(urls=[url]) def create_vector_store_index(documents): """ Create a VectorStoreIndex from the loaded documents. :param documents: The list of loaded documents. :return: The created VectorStoreIndex. """ return VectorStoreIndex.from_documents(documents) def query_index(index, query): """ Query the VectorStoreIndex using the provided query. :param index: The VectorStoreIndex to query. :param query: The query string. :return: The response from the query engine. """ query_engine = index.as_query_engine() return query_engine.query(query) def main(): """ Main function to orchestrate the data loading, indexing, and querying process. """ setup_logging() load_environment_variables() url = 'https://www.llamaindex.ai/blog/agentic-rag-with-llamaindex-2721b8a49ff6' documents = load_web_data(url) index = create_vector_store_index(documents) query = "Agentic RAG is an example of:" response = query_index(index, query) print(response) if __name__ == "__main__": main()

[((264, 322), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (283, 322), False, 'import logging\n'), ((506, 519), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (517, 519), False, 'from dotenv import load_dotenv\n'), ((1002, 1044), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (1033, 1044), False, 'from llama_index.core import VectorStoreIndex\n'), ((358, 398), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (379, 398), False, 'import logging\n'), ((327, 346), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (344, 346), False, 'import logging\n'), ((719, 757), 'llama_index.readers.web.SimpleWebPageReader', 'SimpleWebPageReader', ([], {'html_to_text': '(True)'}), '(html_to_text=True)\n', (738, 757), False, 'from llama_index.readers.web import SimpleWebPageReader\n')]

import logging import sys import pandas as pd import os from llmload import LoadLLM logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) from llama_index.evaluation import DatasetGenerator, RelevancyEvaluator from llama_index import ( SimpleDirectoryReader, VectorStoreIndex, ServiceContext, LLMPredictor, Response, ) source_directory = os.environ.get('SOURCE_DIRECTORY', 'source_documents') model_n_ctx = os.environ.get('MODEL_N_CTX') model_n_batch = os.environ.get('MODEL_N_BATCH') def generateQuestion(): reader = SimpleDirectoryReader(source_directory) documents = reader.load_data() data_generator = DatasetGenerator.from_documents(documents) eval_questions = data_generator.generate_questions_from_nodes() print(eval_questions) # define jupyter display function def display_eval_df(query: str, response: Response, eval_result: str) -> None: eval_df = pd.DataFrame( { "Query": query, "Response": str(response), "Source": ( response.source_nodes[0].node.get_content()[:1000] + "..." ), "Evaluation Result": eval_result, }, index=[0], ) eval_df = eval_df.style.set_properties( **{ "inline-size": "600px", "overflow-wrap": "break-word", }, subset=["Response", "Source"] ) print(eval_df) def generateQuestionEval(): reader = SimpleDirectoryReader(source_directory) documents = reader.load_data() data_generator = DatasetGenerator.from_documents(documents) eval_questions = data_generator.generate_questions_from_nodes() print(eval_questions) service_context_gpt4 = ServiceContext.from_defaults(llm=LoadLLM(n_ctx=model_n_ctx, n_batch=model_n_batch, verbose=False)) evaluator_gpt4 = RelevancyEvaluator(service_context=service_context_gpt4) vector_index = VectorStoreIndex.from_documents( documents, service_context=service_context_gpt4 ) query_engine = vector_index.as_query_engine() response_vector = query_engine.query(eval_questions[1]) eval_result = evaluator_gpt4.evaluate_response( query=eval_questions[1], response=response_vector ) display_eval_df(eval_questions[1], response_vector, eval_result)

[((84, 142), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (103, 142), False, 'import logging\n'), ((437, 491), 'os.environ.get', 'os.environ.get', (['"""SOURCE_DIRECTORY"""', '"""source_documents"""'], {}), "('SOURCE_DIRECTORY', 'source_documents')\n", (451, 491), False, 'import os\n'), ((506, 535), 'os.environ.get', 'os.environ.get', (['"""MODEL_N_CTX"""'], {}), "('MODEL_N_CTX')\n", (520, 535), False, 'import os\n'), ((552, 583), 'os.environ.get', 'os.environ.get', (['"""MODEL_N_BATCH"""'], {}), "('MODEL_N_BATCH')\n", (566, 583), False, 'import os\n'), ((174, 214), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (195, 214), False, 'import logging\n'), ((626, 665), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['source_directory'], {}), '(source_directory)\n', (647, 665), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, ServiceContext, LLMPredictor, Response\n'), ((723, 765), 'llama_index.evaluation.DatasetGenerator.from_documents', 'DatasetGenerator.from_documents', (['documents'], {}), '(documents)\n', (754, 765), False, 'from llama_index.evaluation import DatasetGenerator, RelevancyEvaluator\n'), ((1533, 1572), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['source_directory'], {}), '(source_directory)\n', (1554, 1572), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, ServiceContext, LLMPredictor, Response\n'), ((1630, 1672), 'llama_index.evaluation.DatasetGenerator.from_documents', 'DatasetGenerator.from_documents', (['documents'], {}), '(documents)\n', (1661, 1672), False, 'from llama_index.evaluation import DatasetGenerator, RelevancyEvaluator\n'), ((1917, 1973), 'llama_index.evaluation.RelevancyEvaluator', 'RelevancyEvaluator', ([], {'service_context': 'service_context_gpt4'}), '(service_context=service_context_gpt4)\n', (1935, 1973), False, 'from llama_index.evaluation import DatasetGenerator, RelevancyEvaluator\n'), ((1994, 2079), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'service_context': 'service_context_gpt4'}), '(documents, service_context=service_context_gpt4\n )\n', (2025, 2079), False, 'from llama_index import SimpleDirectoryReader, VectorStoreIndex, ServiceContext, LLMPredictor, Response\n'), ((143, 162), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (160, 162), False, 'import logging\n'), ((1830, 1894), 'llmload.LoadLLM', 'LoadLLM', ([], {'n_ctx': 'model_n_ctx', 'n_batch': 'model_n_batch', 'verbose': '(False)'}), '(n_ctx=model_n_ctx, n_batch=model_n_batch, verbose=False)\n', (1837, 1894), False, 'from llmload import LoadLLM\n')]

# %% [markdown] # # Llama-Index Quickstart # # In this quickstart you will create a simple Llama Index App and learn how to log it and get feedback on an LLM response. # # For evaluation, we will leverage the "hallucination triad" of groundedness, context relevance and answer relevance. # # [](https://colab.research.google.com/github/truera/trulens/blob/main/trulens_eval/examples/quickstart/llama_index_quickstart.ipynb) # %% # %pip install -qU "trulens_eval>=0.19.2" "llama_index>0.9.17" "html2text>=2020.1.16" qdrant_client python-dotenv ipywidgets streamlit_jupyter "litellm>=1.15.1" google-cloud-aiplatform import os from trulens_eval import Feedback, TruLlama from trulens_eval.feedback import Groundedness from trulens_eval import LiteLLM import numpy as np from trulens_eval import Tru from google.cloud import aiplatform from llama_index.readers.web import SimpleWebPageReader from llama_index import VectorStoreIndex, StorageContext, ServiceContext from llama_index.embeddings import GeminiEmbedding from llama_index.llms import Gemini from llama_index.vector_stores import QdrantVectorStore import qdrant_client from llama_index import StorageContext GOOGLE_API_KEY = os.environ["GEMINI_API_KEY"] # This is used by the LiteLLM for Vertex AI models including Gemini. # The LiteLLM wrapper for Gemini is used by the TruLens evaluation provider. aiplatform.init(project="fovi-site", location="us-west1") tru = Tru(database_redact_keys=True) # ### Create Simple LLM Application # # This example uses LlamaIndex which internally uses an OpenAI LLM. __documents = SimpleWebPageReader(html_to_text=True).load_data( ["http://paulgraham.com/worked.html"] ) # from llama_index.vector_stores import ChromaVectorStore # import chromadb # # initialize client, setting path to save data # db = chromadb.PersistentClient(path="./chroma_db") # # create collection # chroma_collection = db.get_or_create_collection("quickstart") # # assign chroma as the vector_store to the context # vector_store = ChromaVectorStore(chroma_collection=chroma_collection) # Create a local Qdrant vector store __client = qdrant_client.QdrantClient(path="qdrant_gemini_3") __vector_store = QdrantVectorStore(client=__client, collection_name="collection") # Using the embedding model to Gemini __embed_model = GeminiEmbedding( model_name="models/embedding-001", api_key=GOOGLE_API_KEY ) __service_context = ServiceContext.from_defaults( llm=Gemini(api_key=GOOGLE_API_KEY), embed_model=__embed_model ) __storage_context = StorageContext.from_defaults(vector_store=__vector_store) __index = VectorStoreIndex.from_documents( __documents, service_context=__service_context, storage_context=__storage_context, show_progress=True, ) def load_llamaindex_app(): return __index.as_query_engine() query_engine = load_llamaindex_app() # response = query_engine.query("What does the author say about their education?") # print(response) # response = query_engine.query("Where did the author go to school?") # print(response) # response = query_engine.query("Who was the author's Harvard PhD advisor?") # print(response) # response = query_engine.query("who was Tom Cheatham to the author?") # print(response) # response = query_engine.query("who is Tom? why is he in this story?") # print(response) # response = query_engine.query("what is this story about? what are the most important things the author want the reader to learn?") # print(response) # ## Initialize Feedback Function(s) # import litellm # litellm.set_verbose=True # Initialize provider class gemini_provider = LiteLLM(model_engine="gemini-pro") grounded = Groundedness(groundedness_provider=gemini_provider) # Define a groundedness feedback function f_groundedness = ( Feedback(grounded.groundedness_measure_with_cot_reasons) .on(TruLlama.select_source_nodes().node.text.collect()) .on_output() .aggregate(grounded.grounded_statements_aggregator) ) # Question/answer relevance between overall question and answer. f_qa_relevance = Feedback(gemini_provider.relevance).on_input_output() # Question/statement relevance between question and each context chunk. f_qs_relevance = ( Feedback(gemini_provider.qs_relevance) .on_input() .on(TruLlama.select_source_nodes().node.text) .aggregate(np.mean) ) # ## Instrument app for logging with TruLens tru_query_engine_recorder = TruLlama( query_engine, tru=tru, app_id="PaulGraham", initial_app_loader=load_llamaindex_app, feedbacks=[f_groundedness, f_qa_relevance, f_qs_relevance], ) # # or as context manager # with tru_query_engine_recorder as recording: # response = query_engine.query("Why did the author drop AI?") # print(response) # ## Explore in a Dashboard tru.run_dashboard() # open a local streamlit app to explore # tru.run_dashboard_in_jupyter() # open a streamlit app in the notebook # tru.stop_dashboard(force=True) # stop if needed # Alternatively, you can run `trulens-eval` from a command line in the same folder to start the dashboard. # Note: Feedback functions evaluated in the deferred manner can be seen in the "Progress" page of the TruLens dashboard. # ## Or view results directly in your notebook # tru.get_records_and_feedback(app_ids=[])[0] # pass an empty list of app_ids to get all # def load_llamaindex_app(): # # from llama_index import VectorStoreIndex # index = VectorStoreIndex.from_documents(documents) # query_engine = index.as_query_engine() # return query_engine # app2 = load_llamaindex_app() # # tru_app2 = tru.Llama( # # Can't specify which Tru instance to use with tru.Llama. # tru_app2 = TruLlama( # app2, # tru=tru, # app_id="llamaindex_appZZ", # initial_app_loader=load_llamaindex_app, # feedbacks=[f_groundedness, f_qa_relevance, f_qs_relevance] # ) # tru.add_app(tru_app2) # from trulens_eval.appui import AppUI # aui = AppUI( # app=tru_app2, # app_selectors=[ # ], # record_selectors=[ # "app.retriever.retrieve[0].rets[:].score", # "app.retriever.retrieve[0].rets[:].node.text", # ] # ) # aui.widget

[((1436, 1493), 'google.cloud.aiplatform.init', 'aiplatform.init', ([], {'project': '"""fovi-site"""', 'location': '"""us-west1"""'}), "(project='fovi-site', location='us-west1')\n", (1451, 1493), False, 'from google.cloud import aiplatform\n'), ((1501, 1531), 'trulens_eval.Tru', 'Tru', ([], {'database_redact_keys': '(True)'}), '(database_redact_keys=True)\n', (1504, 1531), False, 'from trulens_eval import Tru\n'), ((2190, 2240), 'qdrant_client.QdrantClient', 'qdrant_client.QdrantClient', ([], {'path': '"""qdrant_gemini_3"""'}), "(path='qdrant_gemini_3')\n", (2216, 2240), False, 'import qdrant_client\n'), ((2259, 2323), 'llama_index.vector_stores.QdrantVectorStore', 'QdrantVectorStore', ([], {'client': '__client', 'collection_name': '"""collection"""'}), "(client=__client, collection_name='collection')\n", (2276, 2323), False, 'from llama_index.vector_stores import QdrantVectorStore\n'), ((2379, 2453), 'llama_index.embeddings.GeminiEmbedding', 'GeminiEmbedding', ([], {'model_name': '"""models/embedding-001"""', 'api_key': 'GOOGLE_API_KEY'}), "(model_name='models/embedding-001', api_key=GOOGLE_API_KEY)\n", (2394, 2453), False, 'from llama_index.embeddings import GeminiEmbedding\n'), ((2598, 2655), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': '__vector_store'}), '(vector_store=__vector_store)\n', (2626, 2655), False, 'from llama_index import StorageContext\n'), ((2667, 2806), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['__documents'], {'service_context': '__service_context', 'storage_context': '__storage_context', 'show_progress': '(True)'}), '(__documents, service_context=\n __service_context, storage_context=__storage_context, show_progress=True)\n', (2698, 2806), False, 'from llama_index import VectorStoreIndex, StorageContext, ServiceContext\n'), ((3677, 3711), 'trulens_eval.LiteLLM', 'LiteLLM', ([], {'model_engine': '"""gemini-pro"""'}), "(model_engine='gemini-pro')\n", (3684, 3711), False, 'from trulens_eval import LiteLLM\n'), ((3724, 3775), 'trulens_eval.feedback.Groundedness', 'Groundedness', ([], {'groundedness_provider': 'gemini_provider'}), '(groundedness_provider=gemini_provider)\n', (3736, 3775), False, 'from trulens_eval.feedback import Groundedness\n'), ((4473, 4634), 'trulens_eval.TruLlama', 'TruLlama', (['query_engine'], {'tru': 'tru', 'app_id': '"""PaulGraham"""', 'initial_app_loader': 'load_llamaindex_app', 'feedbacks': '[f_groundedness, f_qa_relevance, f_qs_relevance]'}), "(query_engine, tru=tru, app_id='PaulGraham', initial_app_loader=\n load_llamaindex_app, feedbacks=[f_groundedness, f_qa_relevance,\n f_qs_relevance])\n", (4481, 4634), False, 'from trulens_eval import Feedback, TruLlama\n'), ((1654, 1692), 'llama_index.readers.web.SimpleWebPageReader', 'SimpleWebPageReader', ([], {'html_to_text': '(True)'}), '(html_to_text=True)\n', (1673, 1692), False, 'from llama_index.readers.web import SimpleWebPageReader\n'), ((2518, 2548), 'llama_index.llms.Gemini', 'Gemini', ([], {'api_key': 'GOOGLE_API_KEY'}), '(api_key=GOOGLE_API_KEY)\n', (2524, 2548), False, 'from llama_index.llms import Gemini\n'), ((4117, 4152), 'trulens_eval.Feedback', 'Feedback', (['gemini_provider.relevance'], {}), '(gemini_provider.relevance)\n', (4125, 4152), False, 'from trulens_eval import Feedback, TruLlama\n'), ((4330, 4360), 'trulens_eval.TruLlama.select_source_nodes', 'TruLlama.select_source_nodes', ([], {}), '()\n', (4358, 4360), False, 'from trulens_eval import Feedback, TruLlama\n'), ((3842, 3898), 'trulens_eval.Feedback', 'Feedback', (['grounded.groundedness_measure_with_cot_reasons'], {}), '(grounded.groundedness_measure_with_cot_reasons)\n', (3850, 3898), False, 'from trulens_eval import Feedback, TruLlama\n'), ((4267, 4305), 'trulens_eval.Feedback', 'Feedback', (['gemini_provider.qs_relevance'], {}), '(gemini_provider.qs_relevance)\n', (4275, 4305), False, 'from trulens_eval import Feedback, TruLlama\n'), ((3907, 3937), 'trulens_eval.TruLlama.select_source_nodes', 'TruLlama.select_source_nodes', ([], {}), '()\n', (3935, 3937), False, 'from trulens_eval import Feedback, TruLlama\n')]

import os import shutil import tarfile import tempfile import time from pathlib import Path import arxiv import openai import pandas as pd import pdfplumber import streamlit as st from llama_index import (KeywordTableIndex, KnowledgeGraphIndex, ServiceContext, SimpleDirectoryReader, SummaryIndex, TreeIndex, VectorStoreIndex, download_loader, set_global_service_context) from llama_index.llms import OpenAI, Xinference from llama_index.schema import Document from PIL import Image from st_files_connection import FilesConnection from xinference.client import RESTfulClient from pdfextract.export_annotation import export_annotation from pdfextract.pdf_extract import pdf_extract from texannotate.annotate_file import annotate_file from texannotate.color_annotation import ColorAnnotation from texcompile.client import compile_pdf_return_bytes from utils.utils import (find_latex_file, postprocess_latex, preprocess_latex, tup2str) st.set_page_config(page_title='Chat with arXiv paper without PDF noise, powered by LaTeX Rainbow.', layout="wide") texcompile_host = st.secrets.texcompile_host texcompile_port = st.secrets.texcompile_port def main(): """ The main function for the Streamlit app. :return: None. """ st.title("Chat with arXiv paper, without PDF noise") st.sidebar.markdown('# Github link: [LaTeX Rainbow](https://github.com/InsightsNet/texannotate)') st.sidebar.markdown("""<small>It's always good practice to verify that a website is safe before giving it your API key. This site is open source, so you can check the code yourself, or run the streamlit app locally.</small>""", unsafe_allow_html=True) col1, col2 = st.columns([1, 0.8], gap='medium') with col2: with st.form("my_form"): api_key = st.text_input("Enter OpenAI API key here.", type='password') arxiv_id = st.text_input("Please enter a arXiv paper id:", value='1601.00978') submitted = st.form_submit_button("Submit and process arXiv paper (click once and wait)") if submitted: process_submit_button(col1, col2, arxiv_id, api_key) index = load_data() st.session_state["index"] = index if 'index' in st.session_state: if "imgs" in st.session_state.keys(): with col1.container(): for img in st.session_state["imgs"]: st.image(img) chat_engine = st.session_state["index"].as_chat_engine(chat_mode="condense_question", verbose=True) if "messages" not in st.session_state.keys(): # Initialize the chat message history st.session_state.messages = [ {"role": "assistant", "content": "Ask me a question about the paper!"} ] if prompt := st.chat_input("Your question"): # Prompt for user input and save to chat history st.session_state.messages.append({"role": "user", "content": prompt}) for message in st.session_state.messages: # Display the prior chat messages with st.chat_message(message["role"]): st.write(message["content"]) # If last message is not from assistant, generate a new response if st.session_state.messages[-1]["role"] != "assistant": with st.chat_message("assistant"): with st.spinner("Thinking..."): response = chat_engine.chat(prompt) st.write(response.response) message = {"role": "assistant", "content": response.response} st.session_state.messages.append(message) # Add response to message history def process_submit_button(col1, col2, arxiv_id, api_key): with col2: with st.spinner("Downloading LaTeX code..."): filename = validate_input(arxiv_id) if not filename: st.error("id not found on arXiv, or the paper doesn't contain LaTeX code.") return with st.spinner("Annotating LaTeX code... please wait..."): df_toc, df_data = extract_file(filename, col1) df_data.to_csv('data.csv', sep='\t') with st.spinner("Loading llm..."): if api_key == '': st.error('Please set your OpenAI key.') if api_key == 'local': set_local_llm() else: openai.api_key = api_key set_openai_llm() st.info("Now you get a cleaned PDF. Only colored part are penned by paper author. Extracted text are resorted by the reading order.", icon="📃") @st.cache_resource(show_spinner=True) def load_data(): df_data = pd.read_csv('data.csv', sep='\t') text = '' section_id = 0 df_data.index.name='myindex' for i, row in df_data[df_data['reading_order']!=-1].sort_values(by=['reading_order', 'myindex']).iterrows(): if row['section_id'] > section_id: text += '\n' section_id = row['section_id'] if row['label'] != 'Figure': text += row['token'] + ' ' sections = text.split('\n') docs = [Document(text=section) for section in sections] with st.spinner(text="Loading and indexing the paper - hang tight! This should take 1-2 minutes."): index = VectorStoreIndex.from_documents(docs) return index def validate_input(arxiv_id): try: paper = next(arxiv.Search(id_list=[arxiv_id]).results()) filename = paper.download_source() return filename except: return False def extract_file(filename, col1): with col1: placeholder = st.empty() st.session_state['imgs'] = [] try: Path("tmp").mkdir(parents=True, exist_ok=True) td = 'tmp' #print('temp dir', td) with tarfile.open(filename ,'r:gz') as tar: tar.extractall(td) preprocess_latex(td) basename, pdf_bytes = compile_pdf_return_bytes( sources_dir=td, host=texcompile_host, port=texcompile_port ) # compile the unmodified latex firstly with placeholder.container(): for page in pdfplumber.open(pdf_bytes).pages: image = page.to_image(resolution=300).original st.image(image) shapes, tokens = pdf_extract(pdf_bytes) ## get colors color_dict = ColorAnnotation() for rect in shapes: color_dict.add_existing_color(tup2str(rect['stroking_color'])) for token in tokens: color_dict.add_existing_color(token['color']) shutil.rmtree(td) Path("tmp").mkdir(parents=True, exist_ok=True) with tarfile.open(filename ,'r:gz') as tar: tar.extractall(td) tex_file = Path(find_latex_file(Path(basename).stem, basepath=td)).name annotate_file(tex_file, color_dict, latex_context=None, basepath=td) postprocess_latex(str(Path(find_latex_file(Path(basename).stem, basepath=td)))) basename, pdf_bytes_mod = compile_pdf_return_bytes( sources_dir=td, host=texcompile_host, port=texcompile_port ) # compile the modified latex placeholder.empty() with placeholder.container(): for page in pdfplumber.open(pdf_bytes_mod).pages: image = page.to_image(resolution=300).original st.image(image) shapes, tokens = pdf_extract(pdf_bytes_mod) df_toc, df_data = export_annotation(shapes, tokens, color_dict) shutil.rmtree(td) colors = { "Abstract":(255, 182, 193), "Author":(0, 0, 139), "Caption":(57, 230, 10), "Equation":(255, 0, 0),"Figure":(230, 51, 249),"Footer":(255, 255, 255), "List":(46, 33, 109),"Paragraph":(181, 196, 220),"Reference":(81, 142, 32), "Section":(24, 14, 248),"Table":(129, 252, 254),"Title":(97, 189, 251) } imgs = [] placeholder.empty() with placeholder.container(): for i, page in enumerate(pdfplumber.open(pdf_bytes).pages): image = page.to_image(resolution=300) for _, rect in df_data.iterrows(): if rect['page'] == i+1: color = colors.get(rect['label'], (0,0,0)) image.draw_rect((rect['x0'], rect['y0'], rect['x1'], rect['y1']), fill=(color[0],color[1],color[2],70), stroke=color, stroke_width=1) imgs.append(image.annotated) st.image(image.annotated) st.session_state['imgs'] = imgs return df_toc, df_data except Exception as e: raise e #st.error("LaTeX code parsing error, please follow LaTeX Rainbow's example to add new parsing rules.") return None, None def set_local_llm(): port = 9997 # replace with your endpoint port number client = RESTfulClient(f"http://localhost:{port}") # Download and Launch a model, this may take a while the first time model_uid = client.launch_model( model_name="llama-2-chat", model_size_in_billions=7, model_format="pytorch", quantization="none", ) # Initiate Xinference object to use the LLM llm = Xinference( endpoint=f"http://localhost:{port}", model_uid=model_uid, temperature=0.5, max_tokens=512, ) service_context = ServiceContext.from_defaults( llm=llm, embed_model="local:BAAI/bge-small-en" ) set_global_service_context(service_context) def set_openai_llm(): service_context = ServiceContext.from_defaults(llm=OpenAI(model="gpt-3.5-turbo", temperature=0.5, system_prompt="You are an expert on the paper and your job is to answer technical questions. Keep your answers precise and based on facts – do not hallucinate features.")) set_global_service_context(service_context) if __name__ == '__main__': main()

[((1035, 1158), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""Chat with arXiv paper without PDF noise, powered by LaTeX Rainbow."""', 'layout': '"""wide"""'}), "(page_title=\n 'Chat with arXiv paper without PDF noise, powered by LaTeX Rainbow.',\n layout='wide')\n", (1053, 1158), True, 'import streamlit as st\n'), ((4713, 4749), 'streamlit.cache_resource', 'st.cache_resource', ([], {'show_spinner': '(True)'}), '(show_spinner=True)\n', (4730, 4749), True, 'import streamlit as st\n'), ((1338, 1390), 'streamlit.title', 'st.title', (['"""Chat with arXiv paper, without PDF noise"""'], {}), "('Chat with arXiv paper, without PDF noise')\n", (1346, 1390), True, 'import streamlit as st\n'), ((1395, 1502), 'streamlit.sidebar.markdown', 'st.sidebar.markdown', (['"""# Github link: [LaTeX Rainbow](https://github.com/InsightsNet/texannotate)"""'], {}), "(\n '# Github link: [LaTeX Rainbow](https://github.com/InsightsNet/texannotate)'\n )\n", (1414, 1502), True, 'import streamlit as st\n'), ((1497, 1783), 'streamlit.sidebar.markdown', 'st.sidebar.markdown', (['"""<small>It\'s always good practice to verify that a website is safe before giving it your API key. \n This site is open source, so you can check the code yourself, or run the streamlit app locally.</small>"""'], {'unsafe_allow_html': '(True)'}), '(\n """<small>It\'s always good practice to verify that a website is safe before giving it your API key. \n This site is open source, so you can check the code yourself, or run the streamlit app locally.</small>"""\n , unsafe_allow_html=True)\n', (1516, 1783), True, 'import streamlit as st\n'), ((1791, 1825), 'streamlit.columns', 'st.columns', (['[1, 0.8]'], {'gap': '"""medium"""'}), "([1, 0.8], gap='medium')\n", (1801, 1825), True, 'import streamlit as st\n'), ((4781, 4814), 'pandas.read_csv', 'pd.read_csv', (['"""data.csv"""'], {'sep': '"""\t"""'}), "('data.csv', sep='\\t')\n", (4792, 4814), True, 'import pandas as pd\n'), ((9288, 9329), 'xinference.client.RESTfulClient', 'RESTfulClient', (['f"""http://localhost:{port}"""'], {}), "(f'http://localhost:{port}')\n", (9301, 9329), False, 'from xinference.client import RESTfulClient\n'), ((9635, 9740), 'llama_index.llms.Xinference', 'Xinference', ([], {'endpoint': 'f"""http://localhost:{port}"""', 'model_uid': 'model_uid', 'temperature': '(0.5)', 'max_tokens': '(512)'}), "(endpoint=f'http://localhost:{port}', model_uid=model_uid,\n temperature=0.5, max_tokens=512)\n", (9645, 9740), False, 'from llama_index.llms import OpenAI, Xinference\n'), ((9798, 9874), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': '"""local:BAAI/bge-small-en"""'}), "(llm=llm, embed_model='local:BAAI/bge-small-en')\n", (9826, 9874), False, 'from llama_index import KeywordTableIndex, KnowledgeGraphIndex, ServiceContext, SimpleDirectoryReader, SummaryIndex, TreeIndex, VectorStoreIndex, download_loader, set_global_service_context\n'), ((9893, 9936), 'llama_index.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (9919, 9936), False, 'from llama_index import KeywordTableIndex, KnowledgeGraphIndex, ServiceContext, SimpleDirectoryReader, SummaryIndex, TreeIndex, VectorStoreIndex, download_loader, set_global_service_context\n'), ((10239, 10282), 'llama_index.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (10265, 10282), False, 'from llama_index import KeywordTableIndex, KnowledgeGraphIndex, ServiceContext, SimpleDirectoryReader, SummaryIndex, TreeIndex, VectorStoreIndex, download_loader, set_global_service_context\n'), ((4566, 4719), 'streamlit.info', 'st.info', (['"""Now you get a cleaned PDF. Only colored part are penned by paper author. Extracted text are resorted by the reading order."""'], {'icon': '"""📃"""'}), "(\n 'Now you get a cleaned PDF. Only colored part are penned by paper author. Extracted text are resorted by the reading order.'\n , icon='📃')\n", (4573, 4719), True, 'import streamlit as st\n'), ((5226, 5248), 'llama_index.schema.Document', 'Document', ([], {'text': 'section'}), '(text=section)\n', (5234, 5248), False, 'from llama_index.schema import Document\n'), ((5283, 5386), 'streamlit.spinner', 'st.spinner', ([], {'text': '"""Loading and indexing the paper - hang tight! This should take 1-2 minutes."""'}), "(text=\n 'Loading and indexing the paper - hang tight! This should take 1-2 minutes.'\n )\n", (5293, 5386), True, 'import streamlit as st\n'), ((5394, 5431), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['docs'], {}), '(docs)\n', (5425, 5431), False, 'from llama_index import KeywordTableIndex, KnowledgeGraphIndex, ServiceContext, SimpleDirectoryReader, SummaryIndex, TreeIndex, VectorStoreIndex, download_loader, set_global_service_context\n'), ((5739, 5749), 'streamlit.empty', 'st.empty', ([], {}), '()\n', (5747, 5749), True, 'import streamlit as st\n'), ((1854, 1872), 'streamlit.form', 'st.form', (['"""my_form"""'], {}), "('my_form')\n", (1861, 1872), True, 'import streamlit as st\n'), ((1896, 1956), 'streamlit.text_input', 'st.text_input', (['"""Enter OpenAI API key here."""'], {'type': '"""password"""'}), "('Enter OpenAI API key here.', type='password')\n", (1909, 1956), True, 'import streamlit as st\n'), ((1980, 2047), 'streamlit.text_input', 'st.text_input', (['"""Please enter a arXiv paper id:"""'], {'value': '"""1601.00978"""'}), "('Please enter a arXiv paper id:', value='1601.00978')\n", (1993, 2047), True, 'import streamlit as st\n'), ((2072, 2149), 'streamlit.form_submit_button', 'st.form_submit_button', (['"""Submit and process arXiv paper (click once and wait)"""'], {}), "('Submit and process arXiv paper (click once and wait)')\n", (2093, 2149), True, 'import streamlit as st\n'), ((2388, 2411), 'streamlit.session_state.keys', 'st.session_state.keys', ([], {}), '()\n', (2409, 2411), True, 'import streamlit as st\n'), ((2674, 2697), 'streamlit.session_state.keys', 'st.session_state.keys', ([], {}), '()\n', (2695, 2697), True, 'import streamlit as st\n'), ((2902, 2932), 'streamlit.chat_input', 'st.chat_input', (['"""Your question"""'], {}), "('Your question')\n", (2915, 2932), True, 'import streamlit as st\n'), ((2995, 3064), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (3027, 3064), True, 'import streamlit as st\n'), ((3858, 3897), 'streamlit.spinner', 'st.spinner', (['"""Downloading LaTeX code..."""'], {}), "('Downloading LaTeX code...')\n", (3868, 3897), True, 'import streamlit as st\n'), ((4105, 4158), 'streamlit.spinner', 'st.spinner', (['"""Annotating LaTeX code... please wait..."""'], {}), "('Annotating LaTeX code... please wait...')\n", (4115, 4158), True, 'import streamlit as st\n'), ((4282, 4310), 'streamlit.spinner', 'st.spinner', (['"""Loading llm..."""'], {}), "('Loading llm...')\n", (4292, 4310), True, 'import streamlit as st\n'), ((6081, 6170), 'texcompile.client.compile_pdf_return_bytes', 'compile_pdf_return_bytes', ([], {'sources_dir': 'td', 'host': 'texcompile_host', 'port': 'texcompile_port'}), '(sources_dir=td, host=texcompile_host, port=\n texcompile_port)\n', (6105, 6170), False, 'from texcompile.client import compile_pdf_return_bytes\n'), ((6505, 6527), 'pdfextract.pdf_extract.pdf_extract', 'pdf_extract', (['pdf_bytes'], {}), '(pdf_bytes)\n', (6516, 6527), False, 'from pdfextract.pdf_extract import pdf_extract\n'), ((6579, 6596), 'texannotate.color_annotation.ColorAnnotation', 'ColorAnnotation', ([], {}), '()\n', (6594, 6596), False, 'from texannotate.color_annotation import ColorAnnotation\n'), ((6815, 6832), 'shutil.rmtree', 'shutil.rmtree', (['td'], {}), '(td)\n', (6828, 6832), False, 'import shutil\n'), ((7080, 7148), 'texannotate.annotate_file.annotate_file', 'annotate_file', (['tex_file', 'color_dict'], {'latex_context': 'None', 'basepath': 'td'}), '(tex_file, color_dict, latex_context=None, basepath=td)\n', (7093, 7148), False, 'from texannotate.annotate_file import annotate_file\n'), ((7279, 7368), 'texcompile.client.compile_pdf_return_bytes', 'compile_pdf_return_bytes', ([], {'sources_dir': 'td', 'host': 'texcompile_host', 'port': 'texcompile_port'}), '(sources_dir=td, host=texcompile_host, port=\n texcompile_port)\n', (7303, 7368), False, 'from texcompile.client import compile_pdf_return_bytes\n'), ((7728, 7754), 'pdfextract.pdf_extract.pdf_extract', 'pdf_extract', (['pdf_bytes_mod'], {}), '(pdf_bytes_mod)\n', (7739, 7754), False, 'from pdfextract.pdf_extract import pdf_extract\n'), ((7785, 7830), 'pdfextract.export_annotation.export_annotation', 'export_annotation', (['shapes', 'tokens', 'color_dict'], {}), '(shapes, tokens, color_dict)\n', (7802, 7830), False, 'from pdfextract.export_annotation import export_annotation\n'), ((7843, 7860), 'shutil.rmtree', 'shutil.rmtree', (['td'], {}), '(td)\n', (7856, 7860), False, 'import shutil\n'), ((10016, 10243), 'llama_index.llms.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""', 'temperature': '(0.5)', 'system_prompt': '"""You are an expert on the paper and your job is to answer technical questions. Keep your answers precise and based on facts – do not hallucinate features."""'}), "(model='gpt-3.5-turbo', temperature=0.5, system_prompt=\n 'You are an expert on the paper and your job is to answer technical questions. Keep your answers precise and based on facts – do not hallucinate features.'\n )\n", (10022, 10243), False, 'from llama_index.llms import OpenAI, Xinference\n'), ((3175, 3207), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (3190, 3207), True, 'import streamlit as st\n'), ((3225, 3253), 'streamlit.write', 'st.write', (["message['content']"], {}), "(message['content'])\n", (3233, 3253), True, 'import streamlit as st\n'), ((3410, 3438), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (3425, 3438), True, 'import streamlit as st\n'), ((3992, 4067), 'streamlit.error', 'st.error', (['"""id not found on arXiv, or the paper doesn\'t contain LaTeX code."""'], {}), '("id not found on arXiv, or the paper doesn\'t contain LaTeX code.")\n', (4000, 4067), True, 'import streamlit as st\n'), ((4358, 4397), 'streamlit.error', 'st.error', (['"""Please set your OpenAI key."""'], {}), "('Please set your OpenAI key.')\n", (4366, 4397), True, 'import streamlit as st\n'), ((5935, 5965), 'tarfile.open', 'tarfile.open', (['filename', '"""r:gz"""'], {}), "(filename, 'r:gz')\n", (5947, 5965), False, 'import tarfile\n'), ((6025, 6045), 'utils.utils.preprocess_latex', 'preprocess_latex', (['td'], {}), '(td)\n', (6041, 6045), False, 'from utils.utils import find_latex_file, postprocess_latex, preprocess_latex, tup2str\n'), ((6910, 6940), 'tarfile.open', 'tarfile.open', (['filename', '"""r:gz"""'], {}), "(filename, 'r:gz')\n", (6922, 6940), False, 'import tarfile\n'), ((2521, 2534), 'streamlit.image', 'st.image', (['img'], {}), '(img)\n', (2529, 2534), True, 'import streamlit as st\n'), ((3461, 3486), 'streamlit.spinner', 'st.spinner', (['"""Thinking..."""'], {}), "('Thinking...')\n", (3471, 3486), True, 'import streamlit as st\n'), ((3564, 3591), 'streamlit.write', 'st.write', (['response.response'], {}), '(response.response)\n', (3572, 3591), True, 'import streamlit as st\n'), ((3694, 3735), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (['message'], {}), '(message)\n', (3726, 3735), True, 'import streamlit as st\n'), ((5519, 5551), 'arxiv.Search', 'arxiv.Search', ([], {'id_list': '[arxiv_id]'}), '(id_list=[arxiv_id])\n', (5531, 5551), False, 'import arxiv\n'), ((5813, 5824), 'pathlib.Path', 'Path', (['"""tmp"""'], {}), "('tmp')\n", (5817, 5824), False, 'from pathlib import Path\n'), ((6338, 6364), 'pdfplumber.open', 'pdfplumber.open', (['pdf_bytes'], {}), '(pdf_bytes)\n', (6353, 6364), False, 'import pdfplumber\n'), ((6459, 6474), 'streamlit.image', 'st.image', (['image'], {}), '(image)\n', (6467, 6474), True, 'import streamlit as st\n'), ((6675, 6706), 'utils.utils.tup2str', 'tup2str', (["rect['stroking_color']"], {}), "(rect['stroking_color'])\n", (6682, 6706), False, 'from utils.utils import find_latex_file, postprocess_latex, preprocess_latex, tup2str\n'), ((6845, 6856), 'pathlib.Path', 'Path', (['"""tmp"""'], {}), "('tmp')\n", (6849, 6856), False, 'from pathlib import Path\n'), ((7558, 7588), 'pdfplumber.open', 'pdfplumber.open', (['pdf_bytes_mod'], {}), '(pdf_bytes_mod)\n', (7573, 7588), False, 'import pdfplumber\n'), ((7683, 7698), 'streamlit.image', 'st.image', (['image'], {}), '(image)\n', (7691, 7698), True, 'import streamlit as st\n'), ((8893, 8918), 'streamlit.image', 'st.image', (['image.annotated'], {}), '(image.annotated)\n', (8901, 8918), True, 'import streamlit as st\n'), ((8395, 8421), 'pdfplumber.open', 'pdfplumber.open', (['pdf_bytes'], {}), '(pdf_bytes)\n', (8410, 8421), False, 'import pdfplumber\n'), ((7028, 7042), 'pathlib.Path', 'Path', (['basename'], {}), '(basename)\n', (7032, 7042), False, 'from pathlib import Path\n'), ((7204, 7218), 'pathlib.Path', 'Path', (['basename'], {}), '(basename)\n', (7208, 7218), False, 'from pathlib import Path\n')]

"""Global eval handlers.""" from typing import Any from llama_index.legacy.callbacks.argilla_callback import argilla_callback_handler from llama_index.legacy.callbacks.arize_phoenix_callback import ( arize_phoenix_callback_handler, ) from llama_index.legacy.callbacks.base_handler import BaseCallbackHandler from llama_index.legacy.callbacks.deepeval_callback import deepeval_callback_handler from llama_index.legacy.callbacks.honeyhive_callback import honeyhive_callback_handler from llama_index.legacy.callbacks.open_inference_callback import ( OpenInferenceCallbackHandler, ) from llama_index.legacy.callbacks.promptlayer_handler import PromptLayerHandler from llama_index.legacy.callbacks.simple_llm_handler import SimpleLLMHandler from llama_index.legacy.callbacks.wandb_callback import WandbCallbackHandler def set_global_handler(eval_mode: str, **eval_params: Any) -> None: """Set global eval handlers.""" import llama_index.legacy llama_index.legacy.global_handler = create_global_handler(eval_mode, **eval_params) def create_global_handler(eval_mode: str, **eval_params: Any) -> BaseCallbackHandler: """Get global eval handler.""" if eval_mode == "wandb": handler: BaseCallbackHandler = WandbCallbackHandler(**eval_params) elif eval_mode == "openinference": handler = OpenInferenceCallbackHandler(**eval_params) elif eval_mode == "arize_phoenix": handler = arize_phoenix_callback_handler(**eval_params) elif eval_mode == "honeyhive": handler = honeyhive_callback_handler(**eval_params) elif eval_mode == "promptlayer": handler = PromptLayerHandler(**eval_params) elif eval_mode == "deepeval": handler = deepeval_callback_handler(**eval_params) elif eval_mode == "simple": handler = SimpleLLMHandler(**eval_params) elif eval_mode == "argilla": handler = argilla_callback_handler(**eval_params) else: raise ValueError(f"Eval mode {eval_mode} not supported.") return handler

[((1239, 1274), 'llama_index.legacy.callbacks.wandb_callback.WandbCallbackHandler', 'WandbCallbackHandler', ([], {}), '(**eval_params)\n', (1259, 1274), False, 'from llama_index.legacy.callbacks.wandb_callback import WandbCallbackHandler\n'), ((1332, 1375), 'llama_index.legacy.callbacks.open_inference_callback.OpenInferenceCallbackHandler', 'OpenInferenceCallbackHandler', ([], {}), '(**eval_params)\n', (1360, 1375), False, 'from llama_index.legacy.callbacks.open_inference_callback import OpenInferenceCallbackHandler\n'), ((1433, 1478), 'llama_index.legacy.callbacks.arize_phoenix_callback.arize_phoenix_callback_handler', 'arize_phoenix_callback_handler', ([], {}), '(**eval_params)\n', (1463, 1478), False, 'from llama_index.legacy.callbacks.arize_phoenix_callback import arize_phoenix_callback_handler\n'), ((1532, 1573), 'llama_index.legacy.callbacks.honeyhive_callback.honeyhive_callback_handler', 'honeyhive_callback_handler', ([], {}), '(**eval_params)\n', (1558, 1573), False, 'from llama_index.legacy.callbacks.honeyhive_callback import honeyhive_callback_handler\n'), ((1629, 1662), 'llama_index.legacy.callbacks.promptlayer_handler.PromptLayerHandler', 'PromptLayerHandler', ([], {}), '(**eval_params)\n', (1647, 1662), False, 'from llama_index.legacy.callbacks.promptlayer_handler import PromptLayerHandler\n'), ((1715, 1755), 'llama_index.legacy.callbacks.deepeval_callback.deepeval_callback_handler', 'deepeval_callback_handler', ([], {}), '(**eval_params)\n', (1740, 1755), False, 'from llama_index.legacy.callbacks.deepeval_callback import deepeval_callback_handler\n'), ((1806, 1837), 'llama_index.legacy.callbacks.simple_llm_handler.SimpleLLMHandler', 'SimpleLLMHandler', ([], {}), '(**eval_params)\n', (1822, 1837), False, 'from llama_index.legacy.callbacks.simple_llm_handler import SimpleLLMHandler\n'), ((1889, 1928), 'llama_index.legacy.callbacks.argilla_callback.argilla_callback_handler', 'argilla_callback_handler', ([], {}), '(**eval_params)\n', (1913, 1928), False, 'from llama_index.legacy.callbacks.argilla_callback import argilla_callback_handler\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. from typing import Any, Callable, Coroutine from langchain.llms.base import BaseLLM from nemoguardrails import LLMRails, RailsConfig COLANG_CONFIG = """ define user express greeting "hi" define user express ill intent "I hate you" "I want to destroy the world" define bot express cannot respond "I'm sorry I cannot help you with that." define user express question "What is the current unemployment rate?" # Basic guardrail example define flow user express ill intent bot express cannot respond # Question answering flow define flow user ... $answer = execute llama_index_query(query=$last_user_message) bot $answer """ YAML_CONFIG = """ models: - type: main engine: openai model: gpt-3.5-turbo-instruct """ def demo(): try: import llama_index from llama_index.indices.query.base import BaseQueryEngine from llama_index.response.schema import StreamingResponse except ImportError: raise ImportError( "Could not import llama_index, please install it with " "`pip install llama_index`." ) config = RailsConfig.from_content(COLANG_CONFIG, YAML_CONFIG) app = LLMRails(config) def _get_llama_index_query_engine(llm: BaseLLM): docs = llama_index.SimpleDirectoryReader( input_files=["../examples/bots/abc/kb/employee-handbook.md"] ).load_data() llm_predictor = llama_index.LLMPredictor(llm=llm) index = llama_index.GPTVectorStoreIndex.from_documents( docs, llm_predictor=llm_predictor ) default_query_engine = index.as_query_engine() return default_query_engine def _get_callable_query_engine( query_engine: BaseQueryEngine, ) -> Callable[[str], Coroutine[Any, Any, str]]: async def get_query_response(query: str) -> str: response = query_engine.query(query) if isinstance(response, StreamingResponse): typed_response = response.get_response() else: typed_response = response response_str = typed_response.response if response_str is None: return "" return response_str return get_query_response query_engine = _get_llama_index_query_engine(app.llm) app.register_action( _get_callable_query_engine(query_engine), name="llama_index_query" ) history = [{"role": "user", "content": "How many vacation days do I get?"}] result = app.generate(messages=history) print(result) if __name__ == "__main__": demo()

[((1797, 1849), 'nemoguardrails.RailsConfig.from_content', 'RailsConfig.from_content', (['COLANG_CONFIG', 'YAML_CONFIG'], {}), '(COLANG_CONFIG, YAML_CONFIG)\n', (1821, 1849), False, 'from nemoguardrails import LLMRails, RailsConfig\n'), ((1860, 1876), 'nemoguardrails.LLMRails', 'LLMRails', (['config'], {}), '(config)\n', (1868, 1876), False, 'from nemoguardrails import LLMRails, RailsConfig\n'), ((2100, 2133), 'llama_index.LLMPredictor', 'llama_index.LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (2124, 2133), False, 'import llama_index\n'), ((2150, 2236), 'llama_index.GPTVectorStoreIndex.from_documents', 'llama_index.GPTVectorStoreIndex.from_documents', (['docs'], {'llm_predictor': 'llm_predictor'}), '(docs, llm_predictor=\n llm_predictor)\n', (2196, 2236), False, 'import llama_index\n'), ((1946, 2046), 'llama_index.SimpleDirectoryReader', 'llama_index.SimpleDirectoryReader', ([], {'input_files': "['../examples/bots/abc/kb/employee-handbook.md']"}), "(input_files=[\n '../examples/bots/abc/kb/employee-handbook.md'])\n", (1979, 2046), False, 'import llama_index\n')]

import sys from langchain import OpenAI from pathlib import Path import llama_index as li #from llamahub.connectors import TextFileConnector from llama_index import SimpleDirectoryReader,GPTListIndex,LLMPredictor file_name = sys.argv[1] llm_predictor = LLMPredictor(llm=OpenAI(model_name="gpt-3.5-turbo")) #temperature=0, docs = SimpleDirectoryReader('.', [file_name]).load_data() index = GPTListIndex(docs) ex = """Today we finish off our study of collaborative filtering by looking closely at embeddings—a critical building block of many deep learning algorithms. Then we’ll dive into convolutional neural networks (CNNs) and see how they really work. We’ve used plenty of CNNs through this course, but we haven’t peeked inside them to see what’s really going on in there. As well as learning about their most fundamental building block, the convolution, we’ll also look at pooling, dropout, and more.""" q = f"""Here's an example of a lesson summary from a previous fast.ai lesson: "{ex}" Write a four paragraph summary of the fast.ai lesson contained in the following transcript, using a similar informal writing style to the above summary from the previous lesson.""" summary = index.query(q, response_mode="tree_summarize", llm_predictor=llm_predictor) Path(f'{Path(file_name).stem}-summ.txt').write_text(str(summary))

[((391, 409), 'llama_index.GPTListIndex', 'GPTListIndex', (['docs'], {}), '(docs)\n', (403, 409), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, LLMPredictor\n'), ((271, 305), 'langchain.OpenAI', 'OpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""'}), "(model_name='gpt-3.5-turbo')\n", (277, 305), False, 'from langchain import OpenAI\n'), ((331, 370), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""."""', '[file_name]'], {}), "('.', [file_name])\n", (352, 370), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, LLMPredictor\n'), ((1270, 1285), 'pathlib.Path', 'Path', (['file_name'], {}), '(file_name)\n', (1274, 1285), False, 'from pathlib import Path\n')]

# Copyright © 2024 Pathway """ Pathway vector search server and client. The server reads source documents and build a vector index over them, then starts serving HTTP requests. The client queries the server and returns matching documents. """ import asyncio import functools import json import logging import threading from collections.abc import Callable, Coroutine from typing import TYPE_CHECKING import jmespath import numpy as np import requests import pathway as pw import pathway.xpacks.llm.parsers import pathway.xpacks.llm.splitters from pathway.stdlib.ml import index from pathway.stdlib.ml.classifiers import _knn_lsh if TYPE_CHECKING: import langchain_core.documents import langchain_core.embeddings import llama_index.core.schema def _unwrap_udf(func): if isinstance(func, pw.UDF): return func.__wrapped__ return func # https://stackoverflow.com/a/75094151 class _RunThread(threading.Thread): def __init__(self, coroutine): self.coroutine = coroutine self.result = None super().__init__() def run(self): self.result = asyncio.run(self.coroutine) def _run_async(coroutine): try: loop = asyncio.get_running_loop() except RuntimeError: loop = None if loop and loop.is_running(): thread = _RunThread(coroutine) thread.start() thread.join() return thread.result else: return asyncio.run(coroutine) def _coerce_sync(func: Callable) -> Callable: if asyncio.iscoroutinefunction(func): @functools.wraps(func) def wrapper(*args, **kwargs): return _run_async(func(*args, **kwargs)) return wrapper else: return func class VectorStoreServer: """ Builds a document indexing pipeline and starts an HTTP REST server for nearest neighbors queries. Args: - docs: pathway tables typically coming out of connectors which contain source documents. - embedder: callable that embeds a single document - parser: callable that parses file contents into a list of documents - splitter: callable that splits long documents """ def __init__( self, *docs: pw.Table, embedder: Callable[[str], list[float] | Coroutine], parser: Callable[[bytes], list[tuple[str, dict]]] | None = None, splitter: Callable[[str], list[tuple[str, dict]]] | None = None, doc_post_processors: ( list[Callable[[str, dict], tuple[str, dict]]] | None ) = None, index_params: dict | None = None, ): self.docs = docs self.parser: Callable[[bytes], list[tuple[str, dict]]] = _unwrap_udf( parser if parser is not None else pathway.xpacks.llm.parsers.ParseUtf8() ) self.doc_post_processors = [] if doc_post_processors: self.doc_post_processors = [ _unwrap_udf(processor) for processor in doc_post_processors if processor is not None ] self.splitter = _unwrap_udf( splitter if splitter is not None else pathway.xpacks.llm.splitters.null_splitter ) self.embedder = _unwrap_udf(embedder) # detect the dimensionality of the embeddings self.embedding_dimension = len(_coerce_sync(self.embedder)(".")) logging.debug("Embedder has dimension %s", self.embedding_dimension) DEFAULT_INDEX_PARAMS = dict(distance_type="cosine") if index_params is not None: DEFAULT_INDEX_PARAMS.update(index_params) self.index_params = DEFAULT_INDEX_PARAMS self._graph = self._build_graph() @classmethod def from_langchain_components( cls, *docs, embedder: "langchain_core.embeddings.Embeddings", parser: Callable[[bytes], list[tuple[str, dict]]] | None = None, splitter: "langchain_core.documents.BaseDocumentTransformer | None" = None, **kwargs, ): """ Initializes VectorStoreServer by using LangChain components. Args: - docs: pathway tables typically coming out of connectors which contain source documents - embedder: Langchain component for embedding documents - parser: callable that parses file contents into a list of documents - splitter: Langchaing component for splitting documents into parts """ try: from langchain_core.documents import Document except ImportError: raise ImportError( "Please install langchain_core: `pip install langchain_core`" ) generic_splitter = None if splitter: generic_splitter = lambda x: [ # noqa (doc.page_content, doc.metadata) for doc in splitter.transform_documents([Document(page_content=x)]) ] async def generic_embedded(x: str): res = await embedder.aembed_documents([x]) return res[0] return cls( *docs, embedder=generic_embedded, parser=parser, splitter=generic_splitter, **kwargs, ) @classmethod def from_llamaindex_components( cls, *docs, transformations: list["llama_index.core.schema.TransformComponent"], parser: Callable[[bytes], list[tuple[str, dict]]] | None = None, **kwargs, ): """ Initializes VectorStoreServer by using LlamaIndex TransformComponents. Args: - docs: pathway tables typically coming out of connectors which contain source documents - transformations: list of LlamaIndex components. The last component in this list is required to inherit from LlamaIndex `BaseEmbedding` - parser: callable that parses file contents into a list of documents """ try: from llama_index.core.base.embeddings.base import BaseEmbedding from llama_index.core.ingestion.pipeline import run_transformations from llama_index.core.schema import BaseNode, MetadataMode, TextNode except ImportError: raise ImportError( "Please install llama-index-core: `pip install llama-index-core`" ) try: from llama_index.legacy.embeddings.base import ( BaseEmbedding as LegacyBaseEmbedding, ) legacy_llama_index_not_imported = True except ImportError: legacy_llama_index_not_imported = False def node_transformer(x: str) -> list[BaseNode]: return [TextNode(text=x)] def node_to_pathway(x: list[BaseNode]) -> list[tuple[str, dict]]: return [ (node.get_content(metadata_mode=MetadataMode.NONE), node.extra_info) for node in x ] if transformations is None or not transformations: raise ValueError("Transformations list cannot be None or empty.") if not isinstance(transformations[-1], BaseEmbedding) and ( legacy_llama_index_not_imported or not isinstance(transformations[-1], LegacyBaseEmbedding) ): raise ValueError( f"Last step of transformations should be an instance of {BaseEmbedding.__name__}, " f"found {type(transformations[-1])}." ) embedder: BaseEmbedding = transformations.pop() async def embedding_callable(x: str) -> list[float]: embedding = await embedder.aget_text_embedding(x) return embedding def generic_transformer(x: str) -> list[tuple[str, dict]]: starting_node = node_transformer(x) final_node = run_transformations(starting_node, transformations) return node_to_pathway(final_node) return VectorStoreServer( *docs, embedder=embedding_callable, parser=parser, splitter=generic_transformer, **kwargs, ) def _build_graph(self) -> dict: """ Builds the pathway computation graph for indexing documents and serving queries. """ docs_s = self.docs if not docs_s: raise ValueError( """Please provide at least one data source, e.g. read files from disk: pw.io.fs.read('./sample_docs', format='binary', mode='static', with_metadata=True) """ ) if len(docs_s) == 1: (docs,) = docs_s else: docs: pw.Table = docs_s[0].concat_reindex(*docs_s[1:]) # type: ignore @pw.udf def parse_doc(data: bytes, metadata) -> list[pw.Json]: rets = self.parser(data) metadata = metadata.value return [dict(text=ret[0], metadata={**metadata, **ret[1]}) for ret in rets] # type: ignore parsed_docs = docs.select(data=parse_doc(docs.data, docs._metadata)).flatten( pw.this.data ) @pw.udf def post_proc_docs(data_json: pw.Json) -> pw.Json: data: dict = data_json.value # type:ignore text = data["text"] metadata = data["metadata"] for processor in self.doc_post_processors: text, metadata = processor(text, metadata) return dict(text=text, metadata=metadata) # type: ignore parsed_docs = parsed_docs.select(data=post_proc_docs(pw.this.data)) @pw.udf def split_doc(data_json: pw.Json) -> list[pw.Json]: data: dict = data_json.value # type:ignore text = data["text"] metadata = data["metadata"] rets = self.splitter(text) return [ dict(text=ret[0], metadata={**metadata, **ret[1]}) # type:ignore for ret in rets ] chunked_docs = parsed_docs.select(data=split_doc(pw.this.data)).flatten( pw.this.data ) if asyncio.iscoroutinefunction(self.embedder): @pw.udf async def embedder(txt): result = await self.embedder(txt) return np.asarray(result) else: @pw.udf def embedder(txt): result = self.embedder(txt) return np.asarray(result) chunked_docs += chunked_docs.select( embedding=embedder(pw.this.data["text"].as_str()) ) knn_index = index.KNNIndex( chunked_docs.embedding, chunked_docs, n_dimensions=self.embedding_dimension, metadata=chunked_docs.data["metadata"], **self.index_params, # type:ignore ) parsed_docs += parsed_docs.select( modified=pw.this.data["metadata"]["modified_at"].as_int(), indexed=pw.this.data["metadata"]["seen_at"].as_int(), path=pw.this.data["metadata"]["path"].as_str(), ) stats = parsed_docs.reduce( count=pw.reducers.count(), last_modified=pw.reducers.max(pw.this.modified), last_indexed=pw.reducers.max(pw.this.indexed), paths=pw.reducers.tuple(pw.this.path), ) return locals() class StatisticsQuerySchema(pw.Schema): pass class QueryResultSchema(pw.Schema): result: pw.Json class InputResultSchema(pw.Schema): result: list[pw.Json] @pw.table_transformer def statistics_query( self, info_queries: pw.Table[StatisticsQuerySchema] ) -> pw.Table[QueryResultSchema]: stats = self._graph["stats"] # VectorStore statistics computation @pw.udf def format_stats(counts, last_modified, last_indexed) -> pw.Json: if counts is not None: response = { "file_count": counts, "last_modified": last_modified, "last_indexed": last_indexed, } else: response = { "file_count": 0, "last_modified": None, "last_indexed": None, } return pw.Json(response) info_results = info_queries.join_left(stats, id=info_queries.id).select( result=format_stats(stats.count, stats.last_modified, stats.last_indexed) ) return info_results class FilterSchema(pw.Schema): metadata_filter: str | None = pw.column_definition( default_value=None, description="Metadata filter in JMESPath format" ) filepath_globpattern: str | None = pw.column_definition( default_value=None, description="An optional Glob pattern for the file path" ) InputsQuerySchema = FilterSchema @staticmethod def merge_filters(queries: pw.Table): @pw.udf def _get_jmespath_filter( metadata_filter: str, filepath_globpattern: str ) -> str | None: ret_parts = [] if metadata_filter: ret_parts.append(f"({metadata_filter})") if filepath_globpattern: ret_parts.append(f'globmatch(`"{filepath_globpattern}"`, path)') if ret_parts: return " && ".join(ret_parts) return None queries = queries.without( *VectorStoreServer.FilterSchema.__columns__.keys() ) + queries.select( metadata_filter=_get_jmespath_filter( pw.this.metadata_filter, pw.this.filepath_globpattern ) ) return queries @pw.table_transformer def inputs_query( self, input_queries: pw.Table[InputsQuerySchema] # type:ignore ) -> pw.Table[InputResultSchema]: docs = self._graph["docs"] # TODO: compare this approach to first joining queries to dicuments, then filtering, # then grouping to get each response. # The "dumb" tuple approach has more work precomputed for an all inputs query all_metas = docs.reduce(metadatas=pw.reducers.tuple(pw.this._metadata)) input_queries = self.merge_filters(input_queries) @pw.udf def format_inputs( metadatas: list[pw.Json] | None, metadata_filter: str | None ) -> list[pw.Json]: metadatas: list = metadatas if metadatas is not None else [] # type:ignore assert metadatas is not None if metadata_filter: metadatas = [ m for m in metadatas if jmespath.search( metadata_filter, m.value, options=_knn_lsh._glob_options ) ] return metadatas input_results = input_queries.join_left(all_metas, id=input_queries.id).select( all_metas.metadatas, input_queries.metadata_filter ) input_results = input_results.select( result=format_inputs(pw.this.metadatas, pw.this.metadata_filter) ) return input_results class RetrieveQuerySchema(pw.Schema): query: str = pw.column_definition( description="Your query for the similarity search", example="Pathway data processing framework", ) k: int = pw.column_definition( description="The number of documents to provide", example=2 ) metadata_filter: str | None = pw.column_definition( default_value=None, description="Metadata filter in JMESPath format" ) filepath_globpattern: str | None = pw.column_definition( default_value=None, description="An optional Glob pattern for the file path" ) @pw.table_transformer def retrieve_query( self, retrieval_queries: pw.Table[RetrieveQuerySchema] ) -> pw.Table[QueryResultSchema]: embedder = self._graph["embedder"] knn_index = self._graph["knn_index"] # Relevant document search retrieval_queries = self.merge_filters(retrieval_queries) retrieval_queries += retrieval_queries.select( embedding=embedder(pw.this.query), ) retrieval_results = retrieval_queries + knn_index.get_nearest_items( retrieval_queries.embedding, k=pw.this.k, collapse_rows=True, metadata_filter=retrieval_queries.metadata_filter, with_distances=True, ).select( result=pw.this.data, dist=pw.this.dist, ) retrieval_results = retrieval_results.select( result=pw.apply_with_type( lambda x, y: pw.Json( sorted( [{**res.value, "dist": dist} for res, dist in zip(x, y)], key=lambda x: x["dist"], # type: ignore ) ), pw.Json, pw.this.result, pw.this.dist, ) ) return retrieval_results def run_server( self, host, port, threaded: bool = False, with_cache: bool = True, cache_backend: ( pw.persistence.Backend | None ) = pw.persistence.Backend.filesystem("./Cache"), ): """ Builds the document processing pipeline and runs it. Args: - host: host to bind the HTTP listener - port: to bind the HTTP listener - threaded: if True, run in a thread. Else block computation - with_cache: if True, embedding requests for the same contents are cached - cache_backend: the backend to use for caching if it is enabled. The default is the disk cache, hosted locally in the folder ``./Cache``. You can use ``Backend`` class of the [`persistence API`](/developers/api-docs/persistence-api/#pathway.persistence.Backend) to override it. Returns: If threaded, return the Thread object. Else, does not return. """ webserver = pw.io.http.PathwayWebserver(host=host, port=port, with_cors=True) # TODO(move into webserver??) def serve(route, schema, handler, documentation): queries, writer = pw.io.http.rest_connector( webserver=webserver, route=route, methods=("GET", "POST"), schema=schema, autocommit_duration_ms=50, delete_completed_queries=True, documentation=documentation, ) writer(handler(queries)) serve( "/v1/retrieve", self.RetrieveQuerySchema, self.retrieve_query, pw.io.http.EndpointDocumentation( summary="Do a similarity search for your query", description="Request the given number of documents from the " "realtime-maintained index.", method_types=("GET",), ), ) serve( "/v1/statistics", self.StatisticsQuerySchema, self.statistics_query, pw.io.http.EndpointDocumentation( summary="Get current indexer stats", description="Request for the basic stats of the indexer process. " "It returns the number of documents that are currently present in the " "indexer and the time the last of them was added.", method_types=("GET",), ), ) serve( "/v1/inputs", self.InputsQuerySchema, self.inputs_query, pw.io.http.EndpointDocumentation( summary="Get indexed documents list", description="Request for the list of documents present in the indexer. " "It returns the list of metadata objects.", method_types=("GET",), ), ) def run(): if with_cache: if cache_backend is None: raise ValueError( "Cache usage was requested but the backend is unspecified" ) persistence_config = pw.persistence.Config.simple_config( cache_backend, persistence_mode=pw.PersistenceMode.UDF_CACHING, ) else: persistence_config = None pw.run( monitoring_level=pw.MonitoringLevel.NONE, persistence_config=persistence_config, ) if threaded: t = threading.Thread(target=run, name="VectorStoreServer") t.start() return t else: run() class VectorStoreClient: def __init__( self, host: str | None = None, port: int | None = None, url: str | None = None, timeout: int = 15, additional_headers: dict | None = None, ): """ A client you can use to query :py:class:`VectorStoreServer`. Please provide either the `url`, or `host` and `port`. Args: - host: host on which `:py:class:`VectorStoreServer` listens - port: port on which `:py:class:`VectorStoreServer` listens - url: url at which `:py:class:`VectorStoreServer` listens - timeout: timeout for the post requests in seconds """ err = "Either (`host` and `port`) or `url` must be provided, but not both." if url is not None: if host or port: raise ValueError(err) self.url = url else: if host is None: raise ValueError(err) port = port or 80 self.url = f"http://{host}:{port}" self.timeout = timeout self.additional_headers = additional_headers or {} def query( self, query: str, k: int = 3, metadata_filter: str | None = None ) -> list[dict]: """ Perform a query to the vector store and fetch results. Args: - query: - k: number of documents to be returned - metadata_filter: optional string representing the metadata filtering query in the JMESPath format. The search will happen only for documents satisfying this filtering. """ data = {"query": query, "k": k} if metadata_filter is not None: data["metadata_filter"] = metadata_filter url = self.url + "/v1/retrieve" response = requests.post( url, data=json.dumps(data), headers=self._get_request_headers(), timeout=self.timeout, ) responses = response.json() return sorted(responses, key=lambda x: x["dist"]) # Make an alias __call__ = query def get_vectorstore_statistics(self): """Fetch basic statistics about the vector store.""" url = self.url + "/v1/statistics" response = requests.post( url, json={}, headers=self._get_request_headers(), timeout=self.timeout, ) responses = response.json() return responses def get_input_files( self, metadata_filter: str | None = None, filepath_globpattern: str | None = None, ): """ Fetch information on documents in the the vector store. Args: metadata_filter: optional string representing the metadata filtering query in the JMESPath format. The search will happen only for documents satisfying this filtering. filepath_globpattern: optional glob pattern specifying which documents will be searched for this query. """ url = self.url + "/v1/inputs" response = requests.post( url, json={ "metadata_filter": metadata_filter, "filepath_globpattern": filepath_globpattern, }, headers=self._get_request_headers(), timeout=self.timeout, ) responses = response.json() return responses def _get_request_headers(self): request_headers = {"Content-Type": "application/json"} request_headers.update(self.additional_headers) return request_headers

[((1515, 1548), 'asyncio.iscoroutinefunction', 'asyncio.iscoroutinefunction', (['func'], {}), '(func)\n', (1542, 1548), False, 'import asyncio\n'), ((1111, 1138), 'asyncio.run', 'asyncio.run', (['self.coroutine'], {}), '(self.coroutine)\n', (1122, 1138), False, 'import asyncio\n'), ((1192, 1218), 'asyncio.get_running_loop', 'asyncio.get_running_loop', ([], {}), '()\n', (1216, 1218), False, 'import asyncio\n'), ((1437, 1459), 'asyncio.run', 'asyncio.run', (['coroutine'], {}), '(coroutine)\n', (1448, 1459), False, 'import asyncio\n'), ((1560, 1581), 'functools.wraps', 'functools.wraps', (['func'], {}), '(func)\n', (1575, 1581), False, 'import functools\n'), ((3406, 3474), 'logging.debug', 'logging.debug', (['"""Embedder has dimension %s"""', 'self.embedding_dimension'], {}), "('Embedder has dimension %s', self.embedding_dimension)\n", (3419, 3474), False, 'import logging\n'), ((10102, 10144), 'asyncio.iscoroutinefunction', 'asyncio.iscoroutinefunction', (['self.embedder'], {}), '(self.embedder)\n', (10129, 10144), False, 'import asyncio\n'), ((10588, 10750), 'pathway.stdlib.ml.index.KNNIndex', 'index.KNNIndex', (['chunked_docs.embedding', 'chunked_docs'], {'n_dimensions': 'self.embedding_dimension', 'metadata': "chunked_docs.data['metadata']"}), "(chunked_docs.embedding, chunked_docs, n_dimensions=self.\n embedding_dimension, metadata=chunked_docs.data['metadata'], **self.\n index_params)\n", (10602, 10750), False, 'from pathway.stdlib.ml import index\n'), ((12607, 12702), 'pathway.column_definition', 'pw.column_definition', ([], {'default_value': 'None', 'description': '"""Metadata filter in JMESPath format"""'}), "(default_value=None, description=\n 'Metadata filter in JMESPath format')\n", (12627, 12702), True, 'import pathway as pw\n'), ((12763, 12866), 'pathway.column_definition', 'pw.column_definition', ([], {'default_value': 'None', 'description': '"""An optional Glob pattern for the file path"""'}), "(default_value=None, description=\n 'An optional Glob pattern for the file path')\n", (12783, 12866), True, 'import pathway as pw\n'), ((15276, 15397), 'pathway.column_definition', 'pw.column_definition', ([], {'description': '"""Your query for the similarity search"""', 'example': '"""Pathway data processing framework"""'}), "(description='Your query for the similarity search',\n example='Pathway data processing framework')\n", (15296, 15397), True, 'import pathway as pw\n'), ((15446, 15531), 'pathway.column_definition', 'pw.column_definition', ([], {'description': '"""The number of documents to provide"""', 'example': '(2)'}), "(description='The number of documents to provide',\n example=2)\n", (15466, 15531), True, 'import pathway as pw\n'), ((15588, 15683), 'pathway.column_definition', 'pw.column_definition', ([], {'default_value': 'None', 'description': '"""Metadata filter in JMESPath format"""'}), "(default_value=None, description=\n 'Metadata filter in JMESPath format')\n", (15608, 15683), True, 'import pathway as pw\n'), ((15744, 15847), 'pathway.column_definition', 'pw.column_definition', ([], {'default_value': 'None', 'description': '"""An optional Glob pattern for the file path"""'}), "(default_value=None, description=\n 'An optional Glob pattern for the file path')\n", (15764, 15847), True, 'import pathway as pw\n'), ((17383, 17427), 'pathway.persistence.Backend.filesystem', 'pw.persistence.Backend.filesystem', (['"""./Cache"""'], {}), "('./Cache')\n", (17416, 17427), True, 'import pathway as pw\n'), ((18253, 18318), 'pathway.io.http.PathwayWebserver', 'pw.io.http.PathwayWebserver', ([], {'host': 'host', 'port': 'port', 'with_cors': '(True)'}), '(host=host, port=port, with_cors=True)\n', (18280, 18318), True, 'import pathway as pw\n'), ((7862, 7913), 'llama_index.core.ingestion.pipeline.run_transformations', 'run_transformations', (['starting_node', 'transformations'], {}), '(starting_node, transformations)\n', (7881, 7913), False, 'from llama_index.core.ingestion.pipeline import run_transformations\n'), ((12309, 12326), 'pathway.Json', 'pw.Json', (['response'], {}), '(response)\n', (12316, 12326), True, 'import pathway as pw\n'), ((18446, 18640), 'pathway.io.http.rest_connector', 'pw.io.http.rest_connector', ([], {'webserver': 'webserver', 'route': 'route', 'methods': "('GET', 'POST')", 'schema': 'schema', 'autocommit_duration_ms': '(50)', 'delete_completed_queries': '(True)', 'documentation': 'documentation'}), "(webserver=webserver, route=route, methods=('GET',\n 'POST'), schema=schema, autocommit_duration_ms=50,\n delete_completed_queries=True, documentation=documentation)\n", (18471, 18640), True, 'import pathway as pw\n'), ((18924, 19132), 'pathway.io.http.EndpointDocumentation', 'pw.io.http.EndpointDocumentation', ([], {'summary': '"""Do a similarity search for your query"""', 'description': '"""Request the given number of documents from the realtime-maintained index."""', 'method_types': "('GET',)"}), "(summary=\n 'Do a similarity search for your query', description=\n 'Request the given number of documents from the realtime-maintained index.'\n , method_types=('GET',))\n", (18956, 19132), True, 'import pathway as pw\n'), ((19343, 19634), 'pathway.io.http.EndpointDocumentation', 'pw.io.http.EndpointDocumentation', ([], {'summary': '"""Get current indexer stats"""', 'description': '"""Request for the basic stats of the indexer process. It returns the number of documents that are currently present in the indexer and the time the last of them was added."""', 'method_types': "('GET',)"}), "(summary='Get current indexer stats',\n description=\n 'Request for the basic stats of the indexer process. It returns the number of documents that are currently present in the indexer and the time the last of them was added.'\n , method_types=('GET',))\n", (19375, 19634), True, 'import pathway as pw\n'), ((19853, 20074), 'pathway.io.http.EndpointDocumentation', 'pw.io.http.EndpointDocumentation', ([], {'summary': '"""Get indexed documents list"""', 'description': '"""Request for the list of documents present in the indexer. It returns the list of metadata objects."""', 'method_types': "('GET',)"}), "(summary='Get indexed documents list',\n description=\n 'Request for the list of documents present in the indexer. It returns the list of metadata objects.'\n , method_types=('GET',))\n", (19885, 20074), True, 'import pathway as pw\n'), ((20655, 20747), 'pathway.run', 'pw.run', ([], {'monitoring_level': 'pw.MonitoringLevel.NONE', 'persistence_config': 'persistence_config'}), '(monitoring_level=pw.MonitoringLevel.NONE, persistence_config=\n persistence_config)\n', (20661, 20747), True, 'import pathway as pw\n'), ((20828, 20882), 'threading.Thread', 'threading.Thread', ([], {'target': 'run', 'name': '"""VectorStoreServer"""'}), "(target=run, name='VectorStoreServer')\n", (20844, 20882), False, 'import threading\n'), ((6736, 6752), 'llama_index.core.schema.TextNode', 'TextNode', ([], {'text': 'x'}), '(text=x)\n', (6744, 6752), False, 'from llama_index.core.schema import BaseNode, MetadataMode, TextNode\n'), ((10277, 10295), 'numpy.asarray', 'np.asarray', (['result'], {}), '(result)\n', (10287, 10295), True, 'import numpy as np\n'), ((10430, 10448), 'numpy.asarray', 'np.asarray', (['result'], {}), '(result)\n', (10440, 10448), True, 'import numpy as np\n'), ((11133, 11152), 'pathway.reducers.count', 'pw.reducers.count', ([], {}), '()\n', (11150, 11152), True, 'import pathway as pw\n'), ((11180, 11213), 'pathway.reducers.max', 'pw.reducers.max', (['pw.this.modified'], {}), '(pw.this.modified)\n', (11195, 11213), True, 'import pathway as pw\n'), ((11240, 11272), 'pathway.reducers.max', 'pw.reducers.max', (['pw.this.indexed'], {}), '(pw.this.indexed)\n', (11255, 11272), True, 'import pathway as pw\n'), ((11292, 11323), 'pathway.reducers.tuple', 'pw.reducers.tuple', (['pw.this.path'], {}), '(pw.this.path)\n', (11309, 11323), True, 'import pathway as pw\n'), ((14203, 14239), 'pathway.reducers.tuple', 'pw.reducers.tuple', (['pw.this._metadata'], {}), '(pw.this._metadata)\n', (14220, 14239), True, 'import pathway as pw\n'), ((20423, 20527), 'pathway.persistence.Config.simple_config', 'pw.persistence.Config.simple_config', (['cache_backend'], {'persistence_mode': 'pw.PersistenceMode.UDF_CACHING'}), '(cache_backend, persistence_mode=pw.\n PersistenceMode.UDF_CACHING)\n', (20458, 20527), True, 'import pathway as pw\n'), ((22847, 22863), 'json.dumps', 'json.dumps', (['data'], {}), '(data)\n', (22857, 22863), False, 'import json\n'), ((14720, 14793), 'jmespath.search', 'jmespath.search', (['metadata_filter', 'm.value'], {'options': '_knn_lsh._glob_options'}), '(metadata_filter, m.value, options=_knn_lsh._glob_options)\n', (14735, 14793), False, 'import jmespath\n'), ((4913, 4937), 'langchain_core.documents.Document', 'Document', ([], {'page_content': 'x'}), '(page_content=x)\n', (4921, 4937), False, 'from langchain_core.documents import Document\n')]

import logging import llama_index import graphsignal from graphsignal.recorders.base_recorder import BaseRecorder from graphsignal.recorders.instrumentation import parse_semver, compare_semver from graphsignal.proto import signals_pb2 from graphsignal.recorders.instrumentation import patch_method logger = logging.getLogger('graphsignal') class LlamaIndexRecorder(BaseRecorder): def __init__(self): self._library_version = None self._v1_handler = None def setup(self): if not graphsignal._tracer.auto_instrument: return version = '' if hasattr(llama_index, '__version__') and llama_index.__version__: version = llama_index.__version__ self._library_version = version def is_v1(): return ( hasattr(llama_index, 'indices') and hasattr(llama_index.indices.service_context, 'ServiceContext') ) def is_v2(): return self._library_version and compare_semver(self._library_version, (0, 10, 10)) >= 0 if is_v2(): # the handler should be added manually for now pass elif is_v1(): from graphsignal.callbacks.llama_index.v1 import GraphsignalCallbackHandler from llama_index.indices.service_context import ServiceContext def after_from_defaults(args, kwargs, ret, exc, context): if isinstance(ret, ServiceContext): if not any(isinstance(handler, GraphsignalCallbackHandler) for handler in ret.callback_manager.handlers): ret.callback_manager.add_handler(GraphsignalCallbackHandler()) else: logger.error(f'Cannot add callback for LlamaIndex {version}') if not patch_method(ServiceContext, 'from_defaults', after_func=after_from_defaults): logger.error(f'Cannot instrument LlamaIndex {version}') else: logger.error(f'Cannot auto-instrument LlamaIndex {version}') def shutdown(self): if self._v1_handler: llama_index.callbacks.get_callback_manager().remove_handler(self._v1_handler) self._v1_handler = None def on_span_read(self, span, context): if self._library_version: entry = span.config.add() entry.key = 'llama_index' entry.value = self._library_version

[((309, 341), 'logging.getLogger', 'logging.getLogger', (['"""graphsignal"""'], {}), "('graphsignal')\n", (326, 341), False, 'import logging\n'), ((997, 1047), 'graphsignal.recorders.instrumentation.compare_semver', 'compare_semver', (['self._library_version', '(0, 10, 10)'], {}), '(self._library_version, (0, 10, 10))\n', (1011, 1047), False, 'from graphsignal.recorders.instrumentation import parse_semver, compare_semver\n'), ((1793, 1870), 'graphsignal.recorders.instrumentation.patch_method', 'patch_method', (['ServiceContext', '"""from_defaults"""'], {'after_func': 'after_from_defaults'}), "(ServiceContext, 'from_defaults', after_func=after_from_defaults)\n", (1805, 1870), False, 'from graphsignal.recorders.instrumentation import patch_method\n'), ((2097, 2141), 'llama_index.callbacks.get_callback_manager', 'llama_index.callbacks.get_callback_manager', ([], {}), '()\n', (2139, 2141), False, 'import llama_index\n'), ((1640, 1668), 'graphsignal.callbacks.llama_index.v1.GraphsignalCallbackHandler', 'GraphsignalCallbackHandler', ([], {}), '()\n', (1666, 1668), False, 'from graphsignal.callbacks.llama_index.v1 import GraphsignalCallbackHandler\n')]

import llama_index from llama_index.readers.file import CSVReader from llama_index.readers.file import DocxReader from llama_index.readers.file import EpubReader from llama_index.readers.file import FlatReader from llama_index.readers.file import HTMLTagReader from llama_index.readers.file import HWPReader from llama_index.readers.file import IPYNBReader from llama_index.readers.file import ImageCaptionReader from llama_index.readers.file import ImageReader from llama_index.readers.file import ImageTabularChartReader from llama_index.readers.file import ImageVisionLLMReader from llama_index.readers.file import MarkdownReader from llama_index.readers.file import MboxReader from llama_index.readers.file import PDFReader from llama_index.readers.file import PagedCSVReader from llama_index.readers.file import PandasCSVReader from llama_index.readers.file import PptxReader from llama_index.readers.file import PyMuPDFReader from llama_index.readers.file import RTFReader from llama_index.readers.file import UnstructuredReader from llama_index.readers.file import VideoAudioReader from llama_index.readers.file import XMLReader from llama_index.readers.chroma import ChromaReader from llama_index.readers.web import AsyncWebPageReader from llama_index.readers.web import BeautifulSoupWebReader from llama_index.readers.web import KnowledgeBaseWebReader from llama_index.readers.web import MainContentExtractorReader from llama_index.readers.web import NewsArticleReader from llama_index.readers.web import ReadabilityWebPageReader from llama_index.readers.web import RssNewsReader from llama_index.readers.web import RssReader from llama_index.readers.web import SimpleWebPageReader from llama_index.readers.web import SitemapReader from llama_index.readers.web import TrafilaturaWebReader from llama_index.readers.web import UnstructuredURLLoader from llama_index.readers.web import WholeSiteReader from langchain_core.documents.base import Document ####LlamaParse import llama_parse from llama_parse import LlamaParse from llama_index.core import SimpleDirectoryReader import random from typing import List, Optional from pydantic import BaseModel import dspy import gradio as gr import dspy from dspy.retrieve.chromadb_rm import ChromadbRM from dspy.evaluate import Evaluate from dspy.datasets.hotpotqa import HotPotQA from dspy.teleprompt import BootstrapFewShotWithRandomSearch, BootstrapFinetune from dsp.modules.lm import LM from dsp.utils.utils import deduplicate import os import dotenv from dotenv import load_dotenv, set_key from pathlib import Path from typing import Any, List, Dict import base64 import chromadb # Define constants and configurations NUM_THREADS = 4 # Example constant, adjust according to your actual configuration RECOMPILE_INTO_MODEL_FROM_SCRATCH = False # Example flag # ## LOADING DATA # %load_ext autoreload # %autoreload 2 # %set_env CUDA_VISIBLE_DEVICES=7 # import sys; sys.path.append('/future/u/okhattab/repos/public/stanfordnlp/dspy') # Assume all necessary imports for llama_index readers are correctly done at the beginning ports = [7140, 7141, 7142, 7143, 7144, 7145] #llamaChat = dspy.HFClientTGI(model="meta-llama/Llama-2-13b-chat-hf", port=ports, max_tokens=150) (DELETED) # colbertv2 = dspy.ColBERTv2(url='http://20.102.90.50:2017/wiki17_abstracts') class APIKeyManager: @staticmethod def set_api_keys(anthropic_api_key: str, openai_api_key: str): """ Function to securely set API keys by updating the .env file in the application's directory. This approach ensures that sensitive information is not hard-coded into the application. """ print("Setting API keys...") # Define the path to the .env file env_path = Path('.') / '.env' print(f"Loading existing .env file from: {env_path}") # Load existing .env file or create one if it doesn't exist load_dotenv(dotenv_path=env_path, override=True) print("Updating .env file with new API keys...") # Update the .env file with the new values set_key(env_path, "ANTHROPIC_API_KEY", anthropic_api_key) set_key(env_path, "OPENAI_API_KEY", openai_api_key) print("API keys updated successfully.") # Returns a confirmation without exposing the keys return "API keys updated successfully in .env file. Please proceed with your operations." @staticmethod def load_api_keys_and_prompts(): """ Loads API keys and prompts from an existing .env file into the application's environment. This function assumes the .env file is located in the same directory as the script. """ print("Loading API keys and prompts...") # Define the path to the .env file env_path = Path('.') / '.env' print(f"Loading .env file from: {env_path}") # Load the .env file load_dotenv(dotenv_path=env_path) print("Accessing variables from the environment...") # Access the variables from the environment anthropic_api_key = os.getenv("ANTHROPIC_API_KEY") openai_api_key = os.getenv("OPENAI_API_KEY") field_prompt = os.getenv("FIELDPROMPT") example_prompt = os.getenv("EXAMPLEPROMPT") description_prompt = os.getenv("DESCRIPTIONPROMPT") print("API keys and prompts loaded successfully.") # Optionally, print a confirmation or return the loaded values return { "ANTHROPIC_API_KEY": anthropic_api_key, "OPENAI_API_KEY": openai_api_key, "FIELDPROMPT": field_prompt, "EXAMPLEPROMPT": example_prompt, "DESCRIPTIONPROMPT": description_prompt } class DataProcessor: def __init__(self, source_file: str, collection_name: str, persist_directory: str): self.source_file = source_file self.collection_name = collection_name self.persist_directory = persist_directory def load_data_from_source_and_store(self) -> Any: # def load_data_from_source_and_store(source: Union[str, dict], collection_name: str, persist_directory: str) -> Any: """ Loads data from various sources and stores the data in ChromaDB. :param source: A string representing a file path or a URL, or a dictionary specifying web content to fetch. :param collection_name: Name of the ChromaDB collection to store the data. :param persist_directory: Path to the directory where ChromaDB data will be persisted. :return: Loaded data. """ # Determine the file extension if isinstance(self.source_file, str): ext = os.path.splitext(self.source_file)[-1].lower() else: raise TypeError("Source must be a string (file path or URL).") # Load data using appropriate reader if ext == '.csv': reader = CSVReader() elif ext == '.docx': reader = DocxReader() elif ext == '.epub': reader = EpubReader() elif ext == '.html': reader = HTMLTagReader() elif ext == '.hwp': reader = HWPReader() elif ext == '.ipynb': reader = IPYNBReader() elif ext in ['.png', '.jpg', '.jpeg']: reader = ImageReader() # Assuming ImageReader can handle common image formats elif ext == '.md': reader = MarkdownReader() elif ext == '.mbox': reader = MboxReader() elif ext == '.pdf': reader = PDFReader() elif ext == '.pptx': reader = PptxReader() elif ext == '.rtf': reader = RTFReader() elif ext == '.xml': reader = XMLReader() elif self.source_file.startswith('http'): reader = AsyncWebPageReader() # Simplified assumption for URLs else: raise ValueError(f"Unsupported source type: {self.source_file}") # Use the reader to load data # data = reader.read(self.source_file) # Adjust method name as necessary data = reader.load_data(self.source_file) # Adjust method name as necessary chroma_client = chromadb.Client() collection = chroma_client.create_collection(name=self.collection_name) collection.add( documents=[i.text for i in data], # the text fields metadatas=[i.extra_info for i in data], # the metadata ids=[i.doc_id for i in data], # the generated ids ) # Store the data in ChromaDB # retriever_model = ChromadbRM(self.collection_name, self.persist_directory) # retriever_model(data) return data def choose_reader(full_path:str): """ Loads data from various sources and stores the data in ChromaDB. :param source: A string representing a file path or a URL, or a dictionary specifying web content to fetch. """ # Determine the file extension if isinstance(full_path, str): ext = os.path.splitext(full_path)[-1].lower() else: raise TypeError("Source must be a string (file path or URL).") # Load data using appropriate reader if ext == '.csv': reader = CSVReader() elif ext == '.docx': reader = DocxReader() elif ext == '.epub': reader = EpubReader() elif ext == '.html': reader = HTMLTagReader() elif ext == '.hwp': reader = HWPReader() elif ext == '.ipynb': reader = IPYNBReader() elif ext in ['.png', '.jpg', '.jpeg']: reader = ImageReader() # Assuming ImageReader can handle common image formats elif ext == '.md': reader = MarkdownReader() elif ext == '.mbox': reader = MboxReader() elif ext == '.pdf': reader = PDFReader() elif ext == '.pptx': reader = PptxReader() elif ext == '.rtf': reader = RTFReader() elif ext == '.xml': reader = XMLReader() elif full_path.startswith('http'): reader = AsyncWebPageReader() # Simplified assumption for URLs else: raise ValueError(f"Unsupported source type: {full_path}") # Use the reader to load data data = reader.read(full_path) # Adjust method name as necessary return data class DocumentLoader: @staticmethod def load_documents_from_folder(folder_path: str) -> List[Document]: """Loads documents from files within a specified folder""" folder_path = "./add_your_files_here" documents = [] for root, _, filenames in os.walk(folder_path): for filename in filenames: full_path = os.path.join(root, filename) reader = choose_reader(full_path) x=0 if reader: print(f"Loading document from '{filename}' with {type(reader).__name__}") try: docs = list(reader.load_data(input_files=[full_path])) documents.extend(docs) except Exception as e: print(f"Failed to load document from '{filename}'. Error: {e}") # Convert to langchain format documents = [ doc.to_langchain_format() for doc in documents ] return documents ### DSPY DATA GENERATOR # class descriptionSignature(dspy.Signature): # load_dotenv() # field_prompt = os.getenv('FIELDPROMPT', 'Default field prompt if not set') # example_prompt = os.getenv('EXAMPLEPROMPT', 'Default example prompt if not set') # description_prompt = os.getenv('DESCRIPTIONPROMPT', 'Default description prompt if not set') # field_name = dspy.InputField(desc=field_prompt) # example = dspy.InputField(desc=example_prompt) # description = dspy.OutputField(desc=description_prompt) load_dotenv() # https://github.com/stanfordnlp/dspy?tab=readme-ov-file#4-two-powerful-concepts-signatures--teleprompters class DescriptionSignature(dspy.Signature): """Write a simple search query that will help answer a complex question.""" context = dspy.InputField(desc="may contain relevant facts") question = dspy.InputField() query = dspy.OutputField() class SyntheticDataGenerator: def __init__(self, schema_class: Optional[BaseModel] = None, examples: Optional[List[dspy.Example]] = None): self.schema_class = schema_class self.examples = examples print("SyntheticDataGenerator initialized.") def generate(self, sample_size: int) -> List[dspy.Example]: print(f"Starting data generation for sample size: {sample_size}") if not self.schema_class and not self.examples: raise ValueError("Either a schema_class or examples must be provided.") if self.examples and len(self.examples) >= sample_size: print("No additional data generation needed.") return self.examples[:sample_size] additional_samples_needed = sample_size - (len(self.examples) if self.examples else 0) print(f"Generating {additional_samples_needed} additional samples.") generated_examples = self._generate_additional_examples(additional_samples_needed) return self.examples + generated_examples if self.examples else generated_examples def _define_or_infer_fields(self): print("Defining or inferring fields for data generation.") if self.schema_class: data_schema = self.schema_class.model_json_schema() properties = data_schema['properties'] elif self.examples: inferred_schema = self.examples[0].__dict__['_store'] descriptor = dspy.Predict(DescriptionSignature) properties = {field: {'description': str((descriptor(field_name=field, example=str(inferred_schema[field]))).description)} for field in inferred_schema.keys()} else: properties = {} return properties def _generate_additional_examples(self, additional_samples_needed: int) -> List[dspy.Example]: print(f"Generating {additional_samples_needed} additional examples.") properties = self._define_or_infer_fields() class_name = f"{self.schema_class.__name__ if self.schema_class else 'Inferred'}Signature" fields = self._prepare_fields(properties) signature_class = type(class_name, (dspy.Signature,), fields) generator = dspy.Predict(signature_class, n=additional_samples_needed) response = generator(sindex=str(random.randint(1, additional_samples_needed))) return [dspy.Example({field_name: getattr(completion, field_name) for field_name in properties.keys()}) for completion in response.completions] def _prepare_fields(self, properties) -> dict: print("Preparing fields for the signature class.") return { '__doc__': f"Generates the following outputs: {{{', '.join(properties.keys())}}}.", 'sindex': dspy.InputField(desc="a random string"), **{field_name: dspy.OutputField(desc=properties[field_name].get('description', 'No description')) for field_name in properties.keys()}, } # # Generating synthetic data via existing examples # generator = SyntheticDataGenerator(examples=existing_examples) # dataframe = generator.generate(sample_size=5) class ClaudeModelManager: def __init__(self, model: str = "claude-3-opus-20240229", api_key: Optional[str] = None, api_base: Optional[str] = None): self.model = model self.api_key = api_key self.api_base = api_base self.initialize_claude() def initialize_claude(self): """Wrapper around anthropic's API. Supports both the Anthropic and Azure APIs.""" def __init__( self, model: str = "claude-3-opus-20240229", api_key: Optional[str] = None, api_base: Optional[str] = None, **kwargs, ): print("Initializing Claude...") super().__init__(model) try: from anthropic import Anthropic, RateLimitError print("Successfully imported Anthropics's API client.") except ImportError as err: print("Failed to import Anthropics's API client.") raise ImportError("Claude requires `pip install anthropic`.") from err self.provider = "anthropic" self.api_key = os.environ.get("ANTHROPIC_API_KEY") if api_key is None else api_key if self.api_key: print("API key is set.") else: print("API key is not set. Please ensure it's provided or set in the environment variables.") self.api_base = BASE_URL if api_base is None else api_base print(f"API base URL is set to: {self.api_base}") self.kwargs = { "temperature": 0.0 if "temperature" not in kwargs else kwargs["temperature"], "max_tokens": min(kwargs.get("max_tokens", 4096), 4096), "top_p": 1.0 if "top_p" not in kwargs else kwargs["top_p"], "top_k": 1 if "top_k" not in kwargs else kwargs["top_k"], "n": kwargs.pop("n", kwargs.pop("num_generations", 1)), **kwargs, } self.kwargs["model"] = model print(f"Model parameters set: {self.kwargs}") # self.history: List[dict[str, Any]] = [] self.history = [] # changed to be commatible with older versions self.client = Anthropic(api_key=self.api_key) print("Anthropic client initialized.") class SyntheticDataHandler: def __init__(self, examples: Optional[List[dspy.Example]] = None): self.generator = SyntheticDataGenerator(examples=examples) def generate_data(self, sample_size: int): return self.generator.generate(sample_size=sample_size) class ClaudeModelConfig: def __init__(self, model_name): self.model = model_name def get_model(self): return Claude(model=self.model) def configure_dspy_settings(lm_model): dspy.settings.configure(rm=colbertv2, lm=lm_model) class DatasetPreparation: @staticmethod def prepare_datasets(dataset): trainset = [x.with_inputs('question') for x in dataset.train] devset = [x.with_inputs('question') for x in dataset.dev] testset = [x.with_inputs('question') for x in dataset.test] return trainset, devset, testset # class BasicMH(dspy.Module): # def __init__(self, claude_model, passages_per_hop=3): # super().__init__() # self.claude_model = claude_model # self.passages_per_hop = passages_per_hop # def forward(self, question): # context = [] # for hop in range(2): # search_results = self.claude_model.search(question, context=context, k=self.passages_per_hop) # passages = [result.passage for result in search_results] # context = self.deduplicate(context + passages) # answer = self.claude_model.generate(context=context, question=question) # return answer # @staticmethod # def deduplicate(passages): # return list(dict.fromkeys(passages)) class ModelCompilationAndEnsemble: @staticmethod def compile_or_load_models(recompile, trainset, num_models=4): ensemble = [] if recompile: metric_EM = dspy.evaluate.answer_exact_match tp = BootstrapFewShotWithRandomSearch(metric=metric_EM, max_bootstrapped_demos=2, num_threads=NUM_THREADS) claude_bs = tp.compile(Claude(), trainset=trainset[:50], valset=trainset[50:200]) ensemble = [prog for *_, prog in claude_bs.candidate_programs[:num_models]] else: for idx in range(num_models): claude_model = Claude(model=f'multihop_claude3opus_{idx}.json') ensemble.append(claude_model) return ensemble # # # Instantiate Claude with desired parameters # # claude_model = Claude(model="claude-3-opus-20240229") # # # Configure dspy settings with Claude as the language model # # dspy.settings.configure(rm=colbertv2, lm=claude_model) # # #dspy.settings.configure(rm=colbertv2, lm=llamaChat) #Llama change into model based on line 166 # # dataset = dataframe # # trainset = [x.with_inputs('question') for x in dataset.train] # # devset = [x.with_inputs('question') for x in dataset.dev] # # testset = [x.with_inputs('question') for x in dataset.test] # # #len(trainset), len(devset), len(testset) # # #trainset[0] # class BasicMH(dspy.Module): # def __init__(self, claude_model, passages_per_hop=3): # super().__init__() # self.claude_model = claude_model # self.passages_per_hop = passages_per_hop # def forward(self, question): # context = [] # for hop in range(2): # # Retrieval using Claude model # search_results = self.claude_model.search(question, context=context, k=self.passages_per_hop) # passages = [result.passage for result in search_results] # context = deduplicate(context + passages) # # Generation using Claude model # answer = self.claude_model.generate(context=context, question=question) # return answer # metric_EM = dspy.evaluate.answer_exact_match # if RECOMPILE_INTO_MODEL_FROM_SCRATCH: # tp = BootstrapFewShotWithRandomSearch(metric=metric_EM, max_bootstrapped_demos=2, num_threads=NUM_THREADS) # # Compile the Claude model using BootstrapFewShotWithRandomSearch # claude_bs = tp.compile(Claude(), trainset=trainset[:50], valset=trainset[50:200]) # # Get the compiled programs # ensemble = [prog for *_, prog in claude_bs.candidate_programs[:4]] # for idx, prog in enumerate(ensemble): # # Save the compiled Claude models if needed # # prog.save(f'multihop_llama213b_{idx}.json') # pass # else: # ensemble = [] # for idx in range(4): # # Load the previously trained Claude models # claude_model = Claude(model=f'multihop_claude3opus_{idx}.json') #need to prepare this .json file # ensemble.append(claude_model) # # Select the first Claude model from the ensemble # claude_program = ensemble[0] # Add this class definition to your app.py class ChatbotManager: def __init__(self): self.models = self.load_models() self.history = [] def load_models(self): pass # return models def generate_response(self, text, image, model_select_dropdown, top_p, temperature, repetition_penalty, max_length_tokens, max_context_length_tokens): return gradio_chatbot_output, self.history, "Generate: Success" def generate_prompt_with_history( text, history, max_length=2048): """ Generate a prompt with history for the deepseek application. Args: text (str): The text prompt. history (list): List of previous conversation messages. max_length (int): The maximum length of the prompt. Returns: tuple: A tuple containing the generated prompt, conversation, and conversation copy. If the prompt could not be generated within the max_length limit, returns None. """ user_role_ind = 0 bot_role_ind = 1 # Initialize conversation conversation = ""# ADD DSPY HERE vl_chat_processor.new_chat_template() if history: conversation.messages = history # if image is not None: # if "<image_placeholder>" not in text: # text = ( # "<image_placeholder>" + "\n" + text # ) # append the <image_placeholder> in a new line after the text prompt # text = (text, image) conversation.append_message(conversation.roles[user_role_ind], text) conversation.append_message(conversation.roles[bot_role_ind], "") # Create a copy of the conversation to avoid history truncation in the UI conversation_copy = conversation.copy() logger.info("=" * 80) logger.info(get_prompt(conversation)) rounds = len(conversation.messages) // 2 for _ in range(rounds): current_prompt = get_prompt(conversation) # current_prompt = ( # current_prompt.replace("</s>", "") # if sft_format == "deepseek" # else current_prompt # ) # if current_prompt.count("<image_placeholder>") > 2: # for _ in range(len(conversation_copy.messages) - 2): # conversation_copy.messages.pop(0) # return conversation_copy # if torch.tensor(tokenizer.encode(current_prompt)).size(-1) <= max_length: # return conversation_copy if len(conversation.messages) % 2 != 0: gr.Error("The messages between user and assistant are not paired.") return try: for _ in range(2): # pop out two messages in a row conversation.messages.pop(0) except IndexError: gr.Error("Input text processing failed, unable to respond in this round.") return None gr.Error("Prompt could not be generated within max_length limit.") return None def to_gradio_chatbot(conv): """Convert the conversation to gradio chatbot format.""" ret = [] for i, (role, msg) in enumerate(conv.messages[conv.offset :]): if i % 2 == 0: if type(msg) is tuple: msg, image = msg msg = msg if isinstance(image, str): with open(image, "rb") as f: data = f.read() img_b64_str = base64.b64encode(data).decode() image_str = f'<video src="data:video/mp4;base64,{img_b64_str}" controls width="426" height="240"></video>' msg = msg.replace("\n".join(["<image_placeholder>"] * 4), image_str) else: max_hw, min_hw = max(image.size), min(image.size) aspect_ratio = max_hw / min_hw max_len, min_len = 800, 400 shortest_edge = int(min(max_len / aspect_ratio, min_len, min_hw)) longest_edge = int(shortest_edge * aspect_ratio) W, H = image.size if H > W: H, W = longest_edge, shortest_edge else: H, W = shortest_edge, longest_edge image = image.resize((W, H)) buffered = BytesIO() image.save(buffered, format="JPEG") img_b64_str = base64.b64encode(buffered.getvalue()).decode() img_str = f'<img src="data:image/png;base64,{img_b64_str}" alt="user upload image" />' msg = msg.replace("<image_placeholder>", img_str) ret.append([msg, None]) else: ret[-1][-1] = msg return ret def to_gradio_history(conv): """Convert the conversation to gradio history state.""" return conv.messages[conv.offset :] def get_prompt(conv) -> str: """Get the prompt for generation.""" system_prompt = conv.system_template.format(system_message=conv.system_message) if conv.sep_style == SeparatorStyle.DeepSeek: seps = [conv.sep, conv.sep2] if system_prompt == "" or system_prompt is None: ret = "" else: ret = system_prompt + seps[0] for i, (role, message) in enumerate(conv.messages): if message: if type(message) is tuple: # multimodal message message, _ = message ret += role + ": " + message + seps[i % 2] else: ret += role + ":" return ret else: return conv.get_prompt def predict(text, chatbot, history, top_p, temperature, repetition_penalty, max_length_tokens, max_context_length_tokens, model_select_dropdown,): """ Function to predict the response based on the user's input and selected model. Parameters: user_text (str): The input text from the user. user_image (str): The input image from the user. chatbot (str): The chatbot's name. history (str): The history of the chat. top_p (float): The top-p parameter for the model. temperature (float): The temperature parameter for the model. max_length_tokens (int): The maximum length of tokens for the model. max_context_length_tokens (int): The maximum length of context tokens for the model. model_select_dropdown (str): The selected model from the dropdown. Returns: generator: A generator that yields the chatbot outputs, history, and status. """ print("running the prediction function") # try: # tokenizer, vl_gpt, vl_chat_processor = models[model_select_dropdown] # if text == "": # yield chatbot, history, "Empty context." # return # except KeyError: # yield [[text, "No Model Found"]], [], "No Model Found" # return conversation = generate_prompt_with_history( text, image, history, max_length=max_context_length_tokens, ) prompts = convert_conversation_to_prompts(conversation) gradio_chatbot_output = to_gradio_chatbot(conversation) # full_response = "" # with torch.no_grad(): # for x in deepseek_generate( # prompts=prompts, # vl_gpt=vl_gpt, # vl_chat_processor=vl_chat_processor, # tokenizer=tokenizer, # stop_words=stop_words, # max_length=max_length_tokens, # temperature=temperature, # repetition_penalty=repetition_penalty, # top_p=top_p, # ): # full_response += x # response = strip_stop_words(full_response, stop_words) # conversation.update_last_message(response) # gradio_chatbot_output[-1][1] = response # yield gradio_chatbot_output, to_gradio_history( # conversation # ), "Generating..." print("flushed result to gradio") # torch.cuda.empty_cache() # if is_variable_assigned("x"): # print(f"{model_select_dropdown}:\n{text}\n{'-' * 80}\n{x}\n{'=' * 80}") # print( # f"temperature: {temperature}, top_p: {top_p}, repetition_penalty: {repetition_penalty}, max_length_tokens: {max_length_tokens}" # ) yield gradio_chatbot_output, to_gradio_history(conversation), "Generate: Success" def retry( text, image, chatbot, history, top_p, temperature, repetition_penalty, max_length_tokens, max_context_length_tokens, model_select_dropdown, ): if len(history) == 0: yield (chatbot, history, "Empty context") return chatbot.pop() history.pop() text = history.pop()[-1] if type(text) is tuple: text, image = text yield from predict( text, chatbot, history, top_p, temperature, repetition_penalty, max_length_tokens, max_context_length_tokens, model_select_dropdown, ) class Application: def __init__(self): self.api_key_manager = APIKeyManager() # self.data_processor = DataProcessor(source_file="", collection_name="adapt-a-rag", persist_directory="/your_files_here") self.data_processor = DataProcessor(source_file="", collection_name="adapt-a-rag", persist_directory="your_files_here") self.claude_model_manager = ClaudeModelManager() self.synthetic_data_handler = SyntheticDataHandler() self.chatbot_manager = ChatbotManager() def set_api_keys(self, anthropic_api_key, openai_api_key): return self.api_key_manager.set_api_keys(anthropic_api_key, openai_api_key) def handle_file_upload(self, uploaded_file): self.data_processor.source_file = uploaded_file.name loaded_data = self.data_processor.load_data_from_source_and_store() print("Data from {uploaded_file.name} loaded and stored successfully.") return loaded_data def handle_synthetic_data(self, schema_class_name, sample_size): synthetic_data = self.synthetic_data_handler.generate_data(sample_size=int(sample_size)) synthetic_data_str = "\n".join([str(data) for data in synthetic_data]) print ("Generated {sample_size} synthetic data items:\n{synthetic_data_str}") return synthetic_data def handle_chatbot_interaction(self, text, model_select, top_p, temperature, repetition_penalty, max_length_tokens, max_context_length_tokens): chatbot_response, history, status = self.chatbot_manager.generate_response(text, None, model_select, top_p, temperature, repetition_penalty, max_length_tokens, max_context_length_tokens) return chatbot_response def main(self): with gr.Blocks() as demo: with gr.Accordion("API Keys", open=True) as api_keys_accordion: with gr.Row(): anthropic_api_key_input = gr.Textbox(label="Anthropic API Key", type="password") openai_api_key_input = gr.Textbox(label="OpenAI API Key", type="password") submit_button = gr.Button("Submit") confirmation_output = gr.Textbox(label="Confirmation", visible=False) submit_button.click( fn=self.set_api_keys, inputs=[anthropic_api_key_input, openai_api_key_input], outputs=confirmation_output ) with gr.Accordion("Upload Data") as upload_data_accordion: file_upload = gr.File(label="Upload Data File") file_upload_button = gr.Button("Process Uploaded File") file_upload_output = gr.Textbox() file_upload_button.click( fn=self.handle_file_upload, inputs=[file_upload], outputs=file_upload_output ) with gr.Accordion("Generate Synthetic Data") as generate_data_accordion: schema_input = gr.Textbox(label="Schema Class Name") sample_size_input = gr.Number(label="Sample Size", value=100) synthetic_data_button = gr.Button("Generate Synthetic Data") synthetic_data_output = gr.Textbox() synthetic_data_button.click( fn=self.handle_synthetic_data, inputs=[schema_input, sample_size_input], outputs=synthetic_data_output ) with gr.Accordion("Chatbot") as chatbot_accordion: text_input = gr.Textbox(label="Enter your question") # model_select = gr.Dropdown(label="Select Model", choices=list(self.chatbot_manager.models.keys())) model_select = gr.Dropdown(label="Select Model", choices=[ClaudeModelManager(api_key=os.getenv("ANTHROPIC_API_KEY"))]) top_p_input = gr.Slider(label="Top-p", minimum=0.0, maximum=1.0, value=0.95, step=0.01) # top_p_input = gr.Slider() temperature_input = gr.Slider(label="Temperature", minimum=0.0, maximum=1.0, value=0.7, step=0.01) repetition_penalty_input = gr.Slider(label="Repetition Penalty", minimum=1.0, maximum=2.0, value=1.1, step=0.1) max_length_tokens_input = gr.Number(label="Max Length Tokens", value=2048) max_context_length_tokens_input = gr.Number(label="Max Context Length Tokens", value=2048) chatbot_output = gr.Chatbot(label="Chatbot Conversation") submit_button = gr.Button("Submit") submit_button.click( fn=self.handle_chatbot_interaction, inputs=[text_input, model_select, top_p_input, temperature_input, repetition_penalty_input, max_length_tokens_input, max_context_length_tokens_input], outputs=chatbot_output ) demo.launch() if __name__ == "__main__": app = Application() app.main() # Example usage # source_file = "example.txt" # Replace with your source file path # collection_name = "adapt-a-rag" #Need to be defined # persist_directory = "/your_files_here" #Need to be defined # loaded_data = load_data_from_source_and_store(source_file, collection_name="adapt-a-rag", persist_directory="/your_files_here") # print("Data loaded and stored successfully in ChromaDB.")

[((12016, 12029), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (12027, 12029), False, 'from dotenv import load_dotenv, set_key\n'), ((12277, 12327), 'dspy.InputField', 'dspy.InputField', ([], {'desc': '"""may contain relevant facts"""'}), "(desc='may contain relevant facts')\n", (12292, 12327), False, 'import dspy\n'), ((12343, 12360), 'dspy.InputField', 'dspy.InputField', ([], {}), '()\n', (12358, 12360), False, 'import dspy\n'), ((12373, 12391), 'dspy.OutputField', 'dspy.OutputField', ([], {}), '()\n', (12389, 12391), False, 'import dspy\n'), ((18385, 18435), 'dspy.settings.configure', 'dspy.settings.configure', ([], {'rm': 'colbertv2', 'lm': 'lm_model'}), '(rm=colbertv2, lm=lm_model)\n', (18408, 18435), False, 'import dspy\n'), ((3909, 3957), 'dotenv.load_dotenv', 'load_dotenv', ([], {'dotenv_path': 'env_path', 'override': '(True)'}), '(dotenv_path=env_path, override=True)\n', (3920, 3957), False, 'from dotenv import load_dotenv, set_key\n'), ((4083, 4140), 'dotenv.set_key', 'set_key', (['env_path', '"""ANTHROPIC_API_KEY"""', 'anthropic_api_key'], {}), "(env_path, 'ANTHROPIC_API_KEY', anthropic_api_key)\n", (4090, 4140), False, 'from dotenv import load_dotenv, set_key\n'), ((4149, 4200), 'dotenv.set_key', 'set_key', (['env_path', '"""OPENAI_API_KEY"""', 'openai_api_key'], {}), "(env_path, 'OPENAI_API_KEY', openai_api_key)\n", (4156, 4200), False, 'from dotenv import load_dotenv, set_key\n'), ((4914, 4947), 'dotenv.load_dotenv', 'load_dotenv', ([], {'dotenv_path': 'env_path'}), '(dotenv_path=env_path)\n', (4925, 4947), False, 'from dotenv import load_dotenv, set_key\n'), ((5098, 5128), 'os.getenv', 'os.getenv', (['"""ANTHROPIC_API_KEY"""'], {}), "('ANTHROPIC_API_KEY')\n", (5107, 5128), False, 'import os\n'), ((5154, 5181), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (5163, 5181), False, 'import os\n'), ((5205, 5229), 'os.getenv', 'os.getenv', (['"""FIELDPROMPT"""'], {}), "('FIELDPROMPT')\n", (5214, 5229), False, 'import os\n'), ((5255, 5281), 'os.getenv', 'os.getenv', (['"""EXAMPLEPROMPT"""'], {}), "('EXAMPLEPROMPT')\n", (5264, 5281), False, 'import os\n'), ((5311, 5341), 'os.getenv', 'os.getenv', (['"""DESCRIPTIONPROMPT"""'], {}), "('DESCRIPTIONPROMPT')\n", (5320, 5341), False, 'import os\n'), ((8220, 8237), 'chromadb.Client', 'chromadb.Client', ([], {}), '()\n', (8235, 8237), False, 'import chromadb\n'), ((9287, 9298), 'llama_index.readers.file.CSVReader', 'CSVReader', ([], {}), '()\n', (9296, 9298), False, 'from llama_index.readers.file import CSVReader\n'), ((10638, 10658), 'os.walk', 'os.walk', (['folder_path'], {}), '(folder_path)\n', (10645, 10658), False, 'import os\n'), ((14611, 14669), 'dspy.Predict', 'dspy.Predict', (['signature_class'], {'n': 'additional_samples_needed'}), '(signature_class, n=additional_samples_needed)\n', (14623, 14669), False, 'import dspy\n'), ((25630, 25696), 'gradio.Error', 'gr.Error', (['"""Prompt could not be generated within max_length limit."""'], {}), "('Prompt could not be generated within max_length limit.')\n", (25638, 25696), True, 'import gradio as gr\n'), ((3743, 3752), 'pathlib.Path', 'Path', (['"""."""'], {}), "('.')\n", (3747, 3752), False, 'from pathlib import Path\n'), ((4796, 4805), 'pathlib.Path', 'Path', (['"""."""'], {}), "('.')\n", (4800, 4805), False, 'from pathlib import Path\n'), ((6922, 6933), 'llama_index.readers.file.CSVReader', 'CSVReader', ([], {}), '()\n', (6931, 6933), False, 'from llama_index.readers.file import CSVReader\n'), ((9341, 9353), 'llama_index.readers.file.DocxReader', 'DocxReader', ([], {}), '()\n', (9351, 9353), False, 'from llama_index.readers.file import DocxReader\n'), ((15172, 15211), 'dspy.InputField', 'dspy.InputField', ([], {'desc': '"""a random string"""'}), "(desc='a random string')\n", (15187, 15211), False, 'import dspy\n'), ((17818, 17849), 'anthropic.Anthropic', 'Anthropic', ([], {'api_key': 'self.api_key'}), '(api_key=self.api_key)\n', (17827, 17849), False, 'from anthropic import Anthropic, RateLimitError\n'), ((19755, 19860), 'dspy.teleprompt.BootstrapFewShotWithRandomSearch', 'BootstrapFewShotWithRandomSearch', ([], {'metric': 'metric_EM', 'max_bootstrapped_demos': '(2)', 'num_threads': 'NUM_THREADS'}), '(metric=metric_EM, max_bootstrapped_demos=2,\n num_threads=NUM_THREADS)\n', (19787, 19860), False, 'from dspy.teleprompt import BootstrapFewShotWithRandomSearch, BootstrapFinetune\n'), ((34073, 34084), 'gradio.Blocks', 'gr.Blocks', ([], {}), '()\n', (34082, 34084), True, 'import gradio as gr\n'), ((6984, 6996), 'llama_index.readers.file.DocxReader', 'DocxReader', ([], {}), '()\n', (6994, 6996), False, 'from llama_index.readers.file import DocxReader\n'), ((9396, 9408), 'llama_index.readers.file.EpubReader', 'EpubReader', ([], {}), '()\n', (9406, 9408), False, 'from llama_index.readers.file import EpubReader\n'), ((10727, 10755), 'os.path.join', 'os.path.join', (['root', 'filename'], {}), '(root, filename)\n', (10739, 10755), False, 'import os\n'), ((13840, 13874), 'dspy.Predict', 'dspy.Predict', (['DescriptionSignature'], {}), '(DescriptionSignature)\n', (13852, 13874), False, 'import dspy\n'), ((16691, 16726), 'os.environ.get', 'os.environ.get', (['"""ANTHROPIC_API_KEY"""'], {}), "('ANTHROPIC_API_KEY')\n", (16705, 16726), False, 'import os\n'), ((25245, 25312), 'gradio.Error', 'gr.Error', (['"""The messages between user and assistant are not paired."""'], {}), "('The messages between user and assistant are not paired.')\n", (25253, 25312), True, 'import gradio as gr\n'), ((34111, 34146), 'gradio.Accordion', 'gr.Accordion', (['"""API Keys"""'], {'open': '(True)'}), "('API Keys', open=True)\n", (34123, 34146), True, 'import gradio as gr\n'), ((34429, 34448), 'gradio.Button', 'gr.Button', (['"""Submit"""'], {}), "('Submit')\n", (34438, 34448), True, 'import gradio as gr\n'), ((34487, 34534), 'gradio.Textbox', 'gr.Textbox', ([], {'label': '"""Confirmation"""', 'visible': '(False)'}), "(label='Confirmation', visible=False)\n", (34497, 34534), True, 'import gradio as gr\n'), ((34775, 34802), 'gradio.Accordion', 'gr.Accordion', (['"""Upload Data"""'], {}), "('Upload Data')\n", (34787, 34802), True, 'import gradio as gr\n'), ((34859, 34892), 'gradio.File', 'gr.File', ([], {'label': '"""Upload Data File"""'}), "(label='Upload Data File')\n", (34866, 34892), True, 'import gradio as gr\n'), ((34930, 34964), 'gradio.Button', 'gr.Button', (['"""Process Uploaded File"""'], {}), "('Process Uploaded File')\n", (34939, 34964), True, 'import gradio as gr\n'), ((35002, 35014), 'gradio.Textbox', 'gr.Textbox', ([], {}), '()\n', (35012, 35014), True, 'import gradio as gr\n'), ((35231, 35270), 'gradio.Accordion', 'gr.Accordion', (['"""Generate Synthetic Data"""'], {}), "('Generate Synthetic Data')\n", (35243, 35270), True, 'import gradio as gr\n'), ((35330, 35367), 'gradio.Textbox', 'gr.Textbox', ([], {'label': '"""Schema Class Name"""'}), "(label='Schema Class Name')\n", (35340, 35367), True, 'import gradio as gr\n'), ((35404, 35445), 'gradio.Number', 'gr.Number', ([], {'label': '"""Sample Size"""', 'value': '(100)'}), "(label='Sample Size', value=100)\n", (35413, 35445), True, 'import gradio as gr\n'), ((35486, 35522), 'gradio.Button', 'gr.Button', (['"""Generate Synthetic Data"""'], {}), "('Generate Synthetic Data')\n", (35495, 35522), True, 'import gradio as gr\n'), ((35563, 35575), 'gradio.Textbox', 'gr.Textbox', ([], {}), '()\n', (35573, 35575), True, 'import gradio as gr\n'), ((35821, 35844), 'gradio.Accordion', 'gr.Accordion', (['"""Chatbot"""'], {}), "('Chatbot')\n", (35833, 35844), True, 'import gradio as gr\n'), ((35896, 35935), 'gradio.Textbox', 'gr.Textbox', ([], {'label': '"""Enter your question"""'}), "(label='Enter your question')\n", (35906, 35935), True, 'import gradio as gr\n'), ((36218, 36291), 'gradio.Slider', 'gr.Slider', ([], {'label': '"""Top-p"""', 'minimum': '(0.0)', 'maximum': '(1.0)', 'value': '(0.95)', 'step': '(0.01)'}), "(label='Top-p', minimum=0.0, maximum=1.0, value=0.95, step=0.01)\n", (36227, 36291), True, 'import gradio as gr\n'), ((36372, 36450), 'gradio.Slider', 'gr.Slider', ([], {'label': '"""Temperature"""', 'minimum': '(0.0)', 'maximum': '(1.0)', 'value': '(0.7)', 'step': '(0.01)'}), "(label='Temperature', minimum=0.0, maximum=1.0, value=0.7, step=0.01)\n", (36381, 36450), True, 'import gradio as gr\n'), ((36494, 36582), 'gradio.Slider', 'gr.Slider', ([], {'label': '"""Repetition Penalty"""', 'minimum': '(1.0)', 'maximum': '(2.0)', 'value': '(1.1)', 'step': '(0.1)'}), "(label='Repetition Penalty', minimum=1.0, maximum=2.0, value=1.1,\n step=0.1)\n", (36503, 36582), True, 'import gradio as gr\n'), ((36621, 36669), 'gradio.Number', 'gr.Number', ([], {'label': '"""Max Length Tokens"""', 'value': '(2048)'}), "(label='Max Length Tokens', value=2048)\n", (36630, 36669), True, 'import gradio as gr\n'), ((36720, 36776), 'gradio.Number', 'gr.Number', ([], {'label': '"""Max Context Length Tokens"""', 'value': '(2048)'}), "(label='Max Context Length Tokens', value=2048)\n", (36729, 36776), True, 'import gradio as gr\n'), ((36810, 36850), 'gradio.Chatbot', 'gr.Chatbot', ([], {'label': '"""Chatbot Conversation"""'}), "(label='Chatbot Conversation')\n", (36820, 36850), True, 'import gradio as gr\n'), ((36883, 36902), 'gradio.Button', 'gr.Button', (['"""Submit"""'], {}), "('Submit')\n", (36892, 36902), True, 'import gradio as gr\n'), ((7047, 7059), 'llama_index.readers.file.EpubReader', 'EpubReader', ([], {}), '()\n', (7057, 7059), False, 'from llama_index.readers.file import EpubReader\n'), ((9081, 9108), 'os.path.splitext', 'os.path.splitext', (['full_path'], {}), '(full_path)\n', (9097, 9108), False, 'import os\n'), ((9451, 9466), 'llama_index.readers.file.HTMLTagReader', 'HTMLTagReader', ([], {}), '()\n', (9464, 9466), False, 'from llama_index.readers.file import HTMLTagReader\n'), ((14710, 14754), 'random.randint', 'random.randint', (['(1)', 'additional_samples_needed'], {}), '(1, additional_samples_needed)\n', (14724, 14754), False, 'import random\n'), ((25518, 25592), 'gradio.Error', 'gr.Error', (['"""Input text processing failed, unable to respond in this round."""'], {}), "('Input text processing failed, unable to respond in this round.')\n", (25526, 25592), True, 'import gradio as gr\n'), ((34191, 34199), 'gradio.Row', 'gr.Row', ([], {}), '()\n', (34197, 34199), True, 'import gradio as gr\n'), ((34247, 34301), 'gradio.Textbox', 'gr.Textbox', ([], {'label': '"""Anthropic API Key"""', 'type': '"""password"""'}), "(label='Anthropic API Key', type='password')\n", (34257, 34301), True, 'import gradio as gr\n'), ((34345, 34396), 'gradio.Textbox', 'gr.Textbox', ([], {'label': '"""OpenAI API Key"""', 'type': '"""password"""'}), "(label='OpenAI API Key', type='password')\n", (34355, 34396), True, 'import gradio as gr\n'), ((6693, 6727), 'os.path.splitext', 'os.path.splitext', (['self.source_file'], {}), '(self.source_file)\n', (6709, 6727), False, 'import os\n'), ((7110, 7125), 'llama_index.readers.file.HTMLTagReader', 'HTMLTagReader', ([], {}), '()\n', (7123, 7125), False, 'from llama_index.readers.file import HTMLTagReader\n'), ((9508, 9519), 'llama_index.readers.file.HWPReader', 'HWPReader', ([], {}), '()\n', (9517, 9519), False, 'from llama_index.readers.file import HWPReader\n'), ((7175, 7186), 'llama_index.readers.file.HWPReader', 'HWPReader', ([], {}), '()\n', (7184, 7186), False, 'from llama_index.readers.file import HWPReader\n'), ((9563, 9576), 'llama_index.readers.file.IPYNBReader', 'IPYNBReader', ([], {}), '()\n', (9574, 9576), False, 'from llama_index.readers.file import IPYNBReader\n'), ((7238, 7251), 'llama_index.readers.file.IPYNBReader', 'IPYNBReader', ([], {}), '()\n', (7249, 7251), False, 'from llama_index.readers.file import IPYNBReader\n'), ((9637, 9650), 'llama_index.readers.file.ImageReader', 'ImageReader', ([], {}), '()\n', (9648, 9650), False, 'from llama_index.readers.file import ImageReader\n'), ((26219, 26241), 'base64.b64encode', 'base64.b64encode', (['data'], {}), '(data)\n', (26235, 26241), False, 'import base64\n'), ((7320, 7333), 'llama_index.readers.file.ImageReader', 'ImageReader', ([], {}), '()\n', (7331, 7333), False, 'from llama_index.readers.file import ImageReader\n'), ((9747, 9763), 'llama_index.readers.file.MarkdownReader', 'MarkdownReader', ([], {}), '()\n', (9761, 9763), False, 'from llama_index.readers.file import MarkdownReader\n'), ((36154, 36184), 'os.getenv', 'os.getenv', (['"""ANTHROPIC_API_KEY"""'], {}), "('ANTHROPIC_API_KEY')\n", (36163, 36184), False, 'import os\n'), ((7438, 7454), 'llama_index.readers.file.MarkdownReader', 'MarkdownReader', ([], {}), '()\n', (7452, 7454), False, 'from llama_index.readers.file import MarkdownReader\n'), ((9806, 9818), 'llama_index.readers.file.MboxReader', 'MboxReader', ([], {}), '()\n', (9816, 9818), False, 'from llama_index.readers.file import MboxReader\n'), ((7505, 7517), 'llama_index.readers.file.MboxReader', 'MboxReader', ([], {}), '()\n', (7515, 7517), False, 'from llama_index.readers.file import MboxReader\n'), ((9860, 9871), 'llama_index.readers.file.PDFReader', 'PDFReader', ([], {}), '()\n', (9869, 9871), False, 'from llama_index.readers.file import PDFReader\n'), ((7567, 7578), 'llama_index.readers.file.PDFReader', 'PDFReader', ([], {}), '()\n', (7576, 7578), False, 'from llama_index.readers.file import PDFReader\n'), ((9914, 9926), 'llama_index.readers.file.PptxReader', 'PptxReader', ([], {}), '()\n', (9924, 9926), False, 'from llama_index.readers.file import PptxReader\n'), ((7629, 7641), 'llama_index.readers.file.PptxReader', 'PptxReader', ([], {}), '()\n', (7639, 7641), False, 'from llama_index.readers.file import PptxReader\n'), ((9968, 9979), 'llama_index.readers.file.RTFReader', 'RTFReader', ([], {}), '()\n', (9977, 9979), False, 'from llama_index.readers.file import RTFReader\n'), ((7691, 7702), 'llama_index.readers.file.RTFReader', 'RTFReader', ([], {}), '()\n', (7700, 7702), False, 'from llama_index.readers.file import RTFReader\n'), ((10021, 10032), 'llama_index.readers.file.XMLReader', 'XMLReader', ([], {}), '()\n', (10030, 10032), False, 'from llama_index.readers.file import XMLReader\n'), ((7752, 7763), 'llama_index.readers.file.XMLReader', 'XMLReader', ([], {}), '()\n', (7761, 7763), False, 'from llama_index.readers.file import XMLReader\n'), ((10089, 10109), 'llama_index.readers.web.AsyncWebPageReader', 'AsyncWebPageReader', ([], {}), '()\n', (10107, 10109), False, 'from llama_index.readers.web import AsyncWebPageReader\n'), ((7835, 7855), 'llama_index.readers.web.AsyncWebPageReader', 'AsyncWebPageReader', ([], {}), '()\n', (7853, 7855), False, 'from llama_index.readers.web import AsyncWebPageReader\n')]

# Imports from collections import defaultdict from time import sleep from llama_index import ( StorageContext, load_index_from_storage, set_global_service_context, ) from model_context import get_anyscale_context from templates import custom_template, yn_template import csv from tqdm import tqdm from openai import OpenAI client = OpenAI(base_url="https://api.endpoints.anyscale.com/v1", api_key="KEY") # DEBUG LOGS # import llama_index # llama_index.set_global_handler("simple") rag = True yn = False if rag: # Select Model print("Loading model context...") service_context = get_anyscale_context() set_global_service_context(service_context) # Load embedded data for RAG print("Loading RAG embeddings...") storage_context = StorageContext.from_defaults(persist_dir="vector-db-all") index = load_index_from_storage( service_context=service_context, storage_context=storage_context ) # Assemble Query Engine top_k = 3 if yn: query_engine = index.as_query_engine( text_qa_template=yn_template, similarity_top_k=top_k, # verbose=True, # streaming=True, ) else: query_engine = index.as_query_engine( text_qa_template=custom_template, similarity_top_k=top_k, # verbose=True, # streaming=True, ) def query_baseline(text: str, yn: bool) -> str: while True: if yn: content_msg = "Answer with yes/no and an explanation." else: content_msg = "Express whether the statement is true or false and explain why." #Your job is to try: chat_completion = client.chat.completions.create( model="meta-llama/Llama-2-7b-chat-hf", messages=[ { "role": "system", "content": content_msg, }, { "role": "user", "content": text, }, ], temperature=0, ) return chat_completion.choices[0].message.content.strip() except: print("BROKE: ", text) sleep(10) # Load evaluation data print("Loading evaluation data...") labeled_data = defaultdict(list) with open("../neg-exemplars-raw/exceptions.onlyValid.csv", "r") as full_data: data_reader = csv.DictReader(full_data) for sample in data_reader: labeled_data[sample["generic_new"]].append(sample["exemplar"]) print(f"{len(labeled_data)} generics loaded!") generics = list(labeled_data.keys()) # Evaluation Loop print("Beginning evaluation:") tie = 0 loss = 0 win = 0 with open(f"all_answers_{'rag' if rag else 'base'}_{'yn' if yn else 'tf'}.txt", 'w') as ans_file: for i in tqdm(range(1000), desc="Generic evaluation process"): sample = generics[i] for ext in ["All", "Not all"]: prompt = ext.lower() + " " + sample if yn: prompt = "Is it true that " + prompt[:-1].lower() + "?" #investigate if rag: response = query_engine.query(prompt) else: response = query_baseline(prompt, yn) # Record answer ans_file.write("INDEX: " + str(i) + '\n') ans_file.write("BASE INPUT: " + prompt + '\n') ans_file.write("RESPONSE: " + '\n' + str(response) + '\n\n') if yn: process = str(response).lower() false_count = process.count("no") - process.count("not") - process.count("now") - process.count("noc") - process.count("nor") - process.count("non") - process.count("nou") true_count = str(response).lower().count("yes") - str(response).lower().count("eyes") else: false_count = str(response).lower().count("false") true_count = str(response).lower().count("true") # print(false_count) # print(true_count) if ext == "All": good = false_count bad = true_count elif ext == "Not all": good = true_count bad = false_count ans_file.write("RESULT: ") if good > bad: win += 1 ans_file.write("WIN") elif bad > good: loss += 1 ans_file.write("LOSS") else: tie += 1 ans_file.write("TIE") ans_file.write('\n\n-------------------\n\n') print("Wins: ", win) print("Ties: ", tie) print("Loss: ", loss)

[((345, 416), 'openai.OpenAI', 'OpenAI', ([], {'base_url': '"""https://api.endpoints.anyscale.com/v1"""', 'api_key': '"""KEY"""'}), "(base_url='https://api.endpoints.anyscale.com/v1', api_key='KEY')\n", (351, 416), False, 'from openai import OpenAI\n'), ((2366, 2383), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (2377, 2383), False, 'from collections import defaultdict\n'), ((606, 628), 'model_context.get_anyscale_context', 'get_anyscale_context', ([], {}), '()\n', (626, 628), False, 'from model_context import get_anyscale_context\n'), ((633, 676), 'llama_index.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (659, 676), False, 'from llama_index import StorageContext, load_index_from_storage, set_global_service_context\n'), ((772, 829), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""vector-db-all"""'}), "(persist_dir='vector-db-all')\n", (800, 829), False, 'from llama_index import StorageContext, load_index_from_storage, set_global_service_context\n'), ((842, 936), 'llama_index.load_index_from_storage', 'load_index_from_storage', ([], {'service_context': 'service_context', 'storage_context': 'storage_context'}), '(service_context=service_context, storage_context=\n storage_context)\n', (865, 936), False, 'from llama_index import StorageContext, load_index_from_storage, set_global_service_context\n'), ((2480, 2505), 'csv.DictReader', 'csv.DictReader', (['full_data'], {}), '(full_data)\n', (2494, 2505), False, 'import csv\n'), ((2281, 2290), 'time.sleep', 'sleep', (['(10)'], {}), '(10)\n', (2286, 2290), False, 'from time import sleep\n')]

import os import glob import llama_index from llama_index.core import ServiceContext from llama_index.llms.anthropic import Anthropic from llama_index.core import SimpleDirectoryReader from llama_index.core.response_synthesizers import TreeSummarize # MODEL = "claude-3-opus-20240229" # MODEL = "claude-3-sonnet-20240229" MODEL = "claude-3-haiku-20240307" DATA_DIR = "data" SUMMARY_ROOT = "summaries" SUMMARY_DIR = os.path.join(SUMMARY_ROOT, MODEL).replace(":", "_") os.makedirs(SUMMARY_DIR, exist_ok=True) def saveText(path, text): "Save the given text to a file at the specified path." with open(path, "w") as f: f.write(text) def commentPaths(ticketNumber): "Returns a sorted list of file paths for the comments in Zendesk ticket `ticketNumber`." ticketDir = os.path.join(DATA_DIR, ticketNumber) return sorted(glob.glob(os.path.join(ticketDir, "*.txt"))) def summaryPath(ticketNumber): "Returns the file path for where we store the summary of Zendesk ticket `ticketNumber`." return os.path.join(SUMMARY_DIR, f"{ticketNumber}.txt") def totalSizeKB(paths): "Returns the total size in kilobytes of the files specified by `paths`." return sum(os.path.getsize(path) for path in paths) / 1024 def currentTime(): "Returns the current time in the format 'dd/mm/YYYY HH:MM:SS'." from datetime import datetime now = datetime.now() return now.strftime("%d/%m/%Y %H:%M:%S") llm = Anthropic(model=MODEL, max_tokens=1024) service_context = ServiceContext.from_defaults(llm=llm, embed_model="local") summarizer = TreeSummarize(service_context=service_context, verbose=False) SUMMARY_PROMPT = "The following text is a series of messages from a PaperCut support ticket. Summarise the whole conversation, including a list of particpants and who they work for, the problem or problems, the key events and date they occurred, and the current status of the ticket. Include any log lines from the messages." def summariseTicket(ticketNumber): "Summarizes the Zendesk ticket with the given `ticketNumber` and returns the summary text." input_files = commentPaths(ticketNumber) reader = SimpleDirectoryReader(input_files=input_files) docs = reader.load_data() texts = [doc.text for doc in docs] return summarizer.get_response(SUMMARY_PROMPT, texts) if __name__ == "__main__": import time print(f"MODEL={MODEL}") ticketNumbers = sorted(os.path.basename(path) for path in glob.glob(os.path.join(DATA_DIR, "*"))) ticketNumbers.sort(key=lambda k: (totalSizeKB(commentPaths(k)), k)) print(ticketNumbers) for i, ticketNumber in enumerate(ticketNumbers): paths = commentPaths(ticketNumber) print(f"{i:4}: {ticketNumber:8} {len(paths):3} comments {totalSizeKB(paths):7.3f} kb") t00 = time.time() summaries = {} durations = {} commentCounts = {} commentSizes = {} for i, ticketNumber in enumerate(ticketNumbers): commentCount = len(commentPaths(ticketNumber)) commentSize = totalSizeKB(commentPaths(ticketNumber)) print(f"{i:2}: ticketNumber={ticketNumber:8} {commentCount:3} comments {commentSize:7.3f} kb {currentTime()}", flush=True) if os.path.exists(summaryPath(ticketNumber)): print(f"Skipping ticket {ticketNumber}", flush=True) continue # Skip tickets that have already been summarised. t0 = time.time() summary = summariseTicket(ticketNumber) duration = time.time() - t0 description = f"{commentCount} comments {commentSize:7.3f} kb {duration:5.2f} sec summary={len(summary)}" print(f" {description}", flush=True) with open(summaryPath(ticketNumber), "w") as f: print(f"Summary: ticket {ticketNumber}: {description} -------------------------", file=f) print(summary, file=f) summaries[ticketNumber] = summary durations[ticketNumber] = duration commentCounts[ticketNumber] = commentCount commentSizes[ticketNumber] = commentSize duration = time.time() - t00 print("====================^^^====================") print(f"Duration: {duration:.2f} seconds") for i, ticketNumber in enumerate(ticketNumbers): commentCount = commentCounts[ticketNumber] commentSize = totalSizeKB(commentPaths(ticketNumber)) duration = durations[ticketNumber] print(f"{i:2}: {ticketNumber:8}: {commentCount:3} comments {commentSize:7.3f} kb {duration:5.2f} seconds")

[((470, 509), 'os.makedirs', 'os.makedirs', (['SUMMARY_DIR'], {'exist_ok': '(True)'}), '(SUMMARY_DIR, exist_ok=True)\n', (481, 509), False, 'import os\n'), ((1440, 1479), 'llama_index.llms.anthropic.Anthropic', 'Anthropic', ([], {'model': 'MODEL', 'max_tokens': '(1024)'}), '(model=MODEL, max_tokens=1024)\n', (1449, 1479), False, 'from llama_index.llms.anthropic import Anthropic\n'), ((1498, 1556), 'llama_index.core.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': '"""local"""'}), "(llm=llm, embed_model='local')\n", (1526, 1556), False, 'from llama_index.core import ServiceContext\n'), ((1570, 1631), 'llama_index.core.response_synthesizers.TreeSummarize', 'TreeSummarize', ([], {'service_context': 'service_context', 'verbose': '(False)'}), '(service_context=service_context, verbose=False)\n', (1583, 1631), False, 'from llama_index.core.response_synthesizers import TreeSummarize\n'), ((791, 827), 'os.path.join', 'os.path.join', (['DATA_DIR', 'ticketNumber'], {}), '(DATA_DIR, ticketNumber)\n', (803, 827), False, 'import os\n'), ((1027, 1075), 'os.path.join', 'os.path.join', (['SUMMARY_DIR', 'f"""{ticketNumber}.txt"""'], {}), "(SUMMARY_DIR, f'{ticketNumber}.txt')\n", (1039, 1075), False, 'import os\n'), ((1373, 1387), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1385, 1387), False, 'from datetime import datetime\n'), ((2149, 2195), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_files': 'input_files'}), '(input_files=input_files)\n', (2170, 2195), False, 'from llama_index.core import SimpleDirectoryReader\n'), ((2796, 2807), 'time.time', 'time.time', ([], {}), '()\n', (2805, 2807), False, 'import time\n'), ((417, 450), 'os.path.join', 'os.path.join', (['SUMMARY_ROOT', 'MODEL'], {}), '(SUMMARY_ROOT, MODEL)\n', (429, 450), False, 'import os\n'), ((3412, 3423), 'time.time', 'time.time', ([], {}), '()\n', (3421, 3423), False, 'import time\n'), ((4065, 4076), 'time.time', 'time.time', ([], {}), '()\n', (4074, 4076), False, 'import time\n'), ((856, 888), 'os.path.join', 'os.path.join', (['ticketDir', '"""*.txt"""'], {}), "(ticketDir, '*.txt')\n", (868, 888), False, 'import os\n'), ((2422, 2444), 'os.path.basename', 'os.path.basename', (['path'], {}), '(path)\n', (2438, 2444), False, 'import os\n'), ((3491, 3502), 'time.time', 'time.time', ([], {}), '()\n', (3500, 3502), False, 'import time\n'), ((1193, 1214), 'os.path.getsize', 'os.path.getsize', (['path'], {}), '(path)\n', (1208, 1214), False, 'import os\n'), ((2467, 2494), 'os.path.join', 'os.path.join', (['DATA_DIR', '"""*"""'], {}), "(DATA_DIR, '*')\n", (2479, 2494), False, 'import os\n')]

import streamlit as st import os import openai import llama_index from llama_index.llms import OpenAI from llama_index.indices.composability import ComposableGraph from llama_index.storage import StorageContext from llama_index import TreeIndex, SummaryIndex from llama_index.indices.loading import load_graph_from_storage from llama_index.indices.loading import load_graph_from_storage from llama_index.storage import StorageContext import streamlit as st import openai openai.api_key= st.secrets['OPENAI_API_KEY'] st.set_page_config(page_title="Chat with AAPL 23 10-Qs, powered by Munger", page_icon=":chart_with_upwards_trend:", layout="centered", initial_sidebar_state="auto", menu_items=None) st.title("Chat with Munger :chart_with_upwards_trend: :eyeglasses:") if "messages" not in st.session_state.keys(): # Initialize the chat messages history st.session_state.messages = [ {"role": "assistant", "content": "Ask me a question about Apple's 2023 financial documents!"} ] @st.cache_resource(show_spinner=False) def load_data(): with st.spinner(text="Loading and indexing the AAPL 2023 10-Q docs – hang tight! This should take 1-2 minutes."): # Create a storage context using the persist directory storage_context = StorageContext.from_defaults(persist_dir='./storage') # Load the graph from the storage context graph = load_graph_from_storage(storage_context, root_id="APPL-23") query_engine = graph.as_query_engine(child_branch_factor=1) return query_engine query_engine =load_data() if prompt := st.chat_input("Your question"): # Prompt for user input and save to chat history st.session_state.messages.append({"role": "user", "content": prompt}) for message in st.session_state.messages: # Display the prior chat messages with st.chat_message(message["role"]): st.write(message["content"]) # If last message is not from assistant, generate a new response if st.session_state.messages[-1]["role"] != "assistant": with st.chat_message("assistant"): with st.spinner("Thinking..."): response = query_engine.query(prompt) #ipdb.set_trace() st.write(response.response) #st.code(response.get_formatted_sources()) message = {"role": "assistant", "content": response.response} st.session_state.messages.append(message) # Add response to message history

[((520, 709), 'streamlit.set_page_config', 'st.set_page_config', ([], {'page_title': '"""Chat with AAPL 23 10-Qs, powered by Munger"""', 'page_icon': '""":chart_with_upwards_trend:"""', 'layout': '"""centered"""', 'initial_sidebar_state': '"""auto"""', 'menu_items': 'None'}), "(page_title='Chat with AAPL 23 10-Qs, powered by Munger',\n page_icon=':chart_with_upwards_trend:', layout='centered',\n initial_sidebar_state='auto', menu_items=None)\n", (538, 709), True, 'import streamlit as st\n'), ((702, 770), 'streamlit.title', 'st.title', (['"""Chat with Munger :chart_with_upwards_trend: :eyeglasses:"""'], {}), "('Chat with Munger :chart_with_upwards_trend: :eyeglasses:')\n", (710, 770), True, 'import streamlit as st\n'), ((1002, 1039), 'streamlit.cache_resource', 'st.cache_resource', ([], {'show_spinner': '(False)'}), '(show_spinner=False)\n', (1019, 1039), True, 'import streamlit as st\n'), ((793, 816), 'streamlit.session_state.keys', 'st.session_state.keys', ([], {}), '()\n', (814, 816), True, 'import streamlit as st\n'), ((1593, 1623), 'streamlit.chat_input', 'st.chat_input', (['"""Your question"""'], {}), "('Your question')\n", (1606, 1623), True, 'import streamlit as st\n'), ((1678, 1747), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (["{'role': 'user', 'content': prompt}"], {}), "({'role': 'user', 'content': prompt})\n", (1710, 1747), True, 'import streamlit as st\n'), ((1066, 1183), 'streamlit.spinner', 'st.spinner', ([], {'text': '"""Loading and indexing the AAPL 2023 10-Q docs – hang tight! This should take 1-2 minutes."""'}), "(text=\n 'Loading and indexing the AAPL 2023 10-Q docs – hang tight! This should take 1-2 minutes.'\n )\n", (1076, 1183), True, 'import streamlit as st\n'), ((1265, 1318), 'llama_index.storage.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""./storage"""'}), "(persist_dir='./storage')\n", (1293, 1318), False, 'from llama_index.storage import StorageContext\n'), ((1386, 1445), 'llama_index.indices.loading.load_graph_from_storage', 'load_graph_from_storage', (['storage_context'], {'root_id': '"""APPL-23"""'}), "(storage_context, root_id='APPL-23')\n", (1409, 1445), False, 'from llama_index.indices.loading import load_graph_from_storage\n'), ((1834, 1866), 'streamlit.chat_message', 'st.chat_message', (["message['role']"], {}), "(message['role'])\n", (1849, 1866), True, 'import streamlit as st\n'), ((1876, 1904), 'streamlit.write', 'st.write', (["message['content']"], {}), "(message['content'])\n", (1884, 1904), True, 'import streamlit as st\n'), ((2045, 2073), 'streamlit.chat_message', 'st.chat_message', (['"""assistant"""'], {}), "('assistant')\n", (2060, 2073), True, 'import streamlit as st\n'), ((2088, 2113), 'streamlit.spinner', 'st.spinner', (['"""Thinking..."""'], {}), "('Thinking...')\n", (2098, 2113), True, 'import streamlit as st\n'), ((2207, 2234), 'streamlit.write', 'st.write', (['response.response'], {}), '(response.response)\n', (2215, 2234), True, 'import streamlit as st\n'), ((2376, 2417), 'streamlit.session_state.messages.append', 'st.session_state.messages.append', (['message'], {}), '(message)\n', (2408, 2417), True, 'import streamlit as st\n')]

get_ipython().run_line_magic('pip', 'install llama-index-callbacks-wandb') get_ipython().run_line_magic('pip', 'install llama-index-llms-openai') import os from getpass import getpass if os.getenv("OPENAI_API_KEY") is None: os.environ["OPENAI_API_KEY"] = getpass( "Paste your OpenAI key from:" " https://platform.openai.com/account/api-keys\n" ) assert os.getenv("OPENAI_API_KEY", "").startswith( "sk-" ), "This doesn't look like a valid OpenAI API key" print("OpenAI API key configured") from llama_index.core.callbacks import CallbackManager from llama_index.core.callbacks import LlamaDebugHandler from llama_index.callbacks.wandb import WandbCallbackHandler from llama_index.core import ( VectorStoreIndex, SimpleDirectoryReader, SimpleKeywordTableIndex, StorageContext, ) from llama_index.llms.openai import OpenAI from llama_index.core import Settings Settings.llm = OpenAI(model="gpt-4", temperature=0) import llama_index.core from llama_index.core import set_global_handler set_global_handler("wandb", run_args={"project": "llamaindex"}) wandb_callback = llama_index.core.global_handler llama_debug = LlamaDebugHandler(print_trace_on_end=True) run_args = dict( project="llamaindex", ) wandb_callback = WandbCallbackHandler(run_args=run_args) Settings.callback_manager = CallbackManager([llama_debug, wandb_callback]) get_ipython().system("mkdir -p 'data/paul_graham/'") get_ipython().system("wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt' -O 'data/paul_graham/paul_graham_essay.txt'") docs = SimpleDirectoryReader("./data/paul_graham/").load_data() index = VectorStoreIndex.from_documents(docs) wandb_callback.persist_index(index, index_name="simple_vector_store") from llama_index.core import load_index_from_storage storage_context = wandb_callback.load_storage_context( artifact_url="ayut/llamaindex/simple_vector_store:v0" ) index = load_index_from_storage( storage_context, ) query_engine = index.as_query_engine() response = query_engine.query("What did the author do growing up?") print(response, sep="\n") wandb_callback.finish()

[((926, 962), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4"""', 'temperature': '(0)'}), "(model='gpt-4', temperature=0)\n", (932, 962), False, 'from llama_index.llms.openai import OpenAI\n'), ((1040, 1103), 'llama_index.core.set_global_handler', 'set_global_handler', (['"""wandb"""'], {'run_args': "{'project': 'llamaindex'}"}), "('wandb', run_args={'project': 'llamaindex'})\n", (1058, 1103), False, 'from llama_index.core import set_global_handler\n'), ((1170, 1212), 'llama_index.core.callbacks.LlamaDebugHandler', 'LlamaDebugHandler', ([], {'print_trace_on_end': '(True)'}), '(print_trace_on_end=True)\n', (1187, 1212), False, 'from llama_index.core.callbacks import LlamaDebugHandler\n'), ((1277, 1316), 'llama_index.callbacks.wandb.WandbCallbackHandler', 'WandbCallbackHandler', ([], {'run_args': 'run_args'}), '(run_args=run_args)\n', (1297, 1316), False, 'from llama_index.callbacks.wandb import WandbCallbackHandler\n'), ((1346, 1392), 'llama_index.core.callbacks.CallbackManager', 'CallbackManager', (['[llama_debug, wandb_callback]'], {}), '([llama_debug, wandb_callback])\n', (1361, 1392), False, 'from llama_index.core.callbacks import CallbackManager\n'), ((1716, 1753), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['docs'], {}), '(docs)\n', (1747, 1753), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, SimpleKeywordTableIndex, StorageContext\n'), ((2008, 2048), 'llama_index.core.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (2031, 2048), False, 'from llama_index.core import load_index_from_storage\n'), ((190, 217), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (199, 217), False, 'import os\n'), ((262, 357), 'getpass.getpass', 'getpass', (['"""Paste your OpenAI key from: https://platform.openai.com/account/api-keys\n"""'], {}), "(\n 'Paste your OpenAI key from: https://platform.openai.com/account/api-keys\\n'\n )\n", (269, 357), False, 'from getpass import getpass\n'), ((380, 411), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""', '""""""'], {}), "('OPENAI_API_KEY', '')\n", (389, 411), False, 'import os\n'), ((1649, 1693), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""./data/paul_graham/"""'], {}), "('./data/paul_graham/')\n", (1670, 1693), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, SimpleKeywordTableIndex, StorageContext\n')]

from langfuse import Langfuse from llama_index.llms.openai import OpenAI import llama_index.core llama_index.core.set_global_handler("langfuse") from llama_index.core.llms import ChatMessage import json from json_repair import repair_json import os langfuse = Langfuse() prompt = langfuse.get_prompt("extraction-prompt-1") with open("../data.json", "r") as f: input_text = f.read() data = json.loads(input_text) model = OpenAI(model="gpt-4-turbo-preview") # model = OpenAI() for chlen in data: # skip if file exists if os.path.exists(f'../terms-output/{chlen["article_num"]}.json'): print(f"chlen {chlen['article_num']} already exists") continue try: compiled_prompt = prompt.compile(input=chlen['text']) generation = langfuse.generation(input=chlen['text'], prompt=prompt,model=model.model) messages = [ ChatMessage(role="system", content="You are an API that must always respond with a json without any formatting."), ChatMessage(role="user", content=compiled_prompt), ] chat_completion = model.chat(messages) with open(f'../terms-output/{chlen["article_num"]}.json', 'w') as f: f.write(json.dumps(json.loads(repair_json(chat_completion.message.content)), ensure_ascii=False)) generation.end(output=chat_completion) print(f"chlen {chlen['article_num']} completed") except Exception as e: print(f"chlen {chlen['article_num']} failed with error: {e}")

[((261, 271), 'langfuse.Langfuse', 'Langfuse', ([], {}), '()\n', (269, 271), False, 'from langfuse import Langfuse\n'), ((433, 468), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4-turbo-preview"""'}), "(model='gpt-4-turbo-preview')\n", (439, 468), False, 'from llama_index.llms.openai import OpenAI\n'), ((400, 422), 'json.loads', 'json.loads', (['input_text'], {}), '(input_text)\n', (410, 422), False, 'import json\n'), ((536, 598), 'os.path.exists', 'os.path.exists', (['f"""../terms-output/{chlen[\'article_num\']}.json"""'], {}), '(f"../terms-output/{chlen[\'article_num\']}.json")\n', (550, 598), False, 'import os\n'), ((853, 976), 'llama_index.core.llms.ChatMessage', 'ChatMessage', ([], {'role': '"""system"""', 'content': '"""You are an API that must always respond with a json without any formatting."""'}), "(role='system', content=\n 'You are an API that must always respond with a json without any formatting.'\n )\n", (864, 976), False, 'from llama_index.core.llms import ChatMessage\n'), ((976, 1025), 'llama_index.core.llms.ChatMessage', 'ChatMessage', ([], {'role': '"""user"""', 'content': 'compiled_prompt'}), "(role='user', content=compiled_prompt)\n", (987, 1025), False, 'from llama_index.core.llms import ChatMessage\n'), ((1187, 1231), 'json_repair.repair_json', 'repair_json', (['chat_completion.message.content'], {}), '(chat_completion.message.content)\n', (1198, 1231), False, 'from json_repair import repair_json\n')]

import streamlit as st import llama_index from llama_index import StorageContext, load_index_from_storage from llama_index.query_engine import RetrieverQueryEngine from llama_index.storage.docstore import SimpleDocumentStore from llama_index.vector_stores import SimpleVectorStore from llama_index.storage.index_store import SimpleIndexStore from llama_index import KeywordTableIndex from llama_index.indices.keyword_table import SimpleKeywordTableIndex from llama_index import ResponseSynthesizer from llama_index.indices.postprocessor import SimilarityPostprocessor from llama_index.retrievers import VectorIndexRetriever from llama_index.retrievers import ListIndexRetriever from llama_index.retrievers import TreeRootRetriever from llama_index.indices.keyword_table.retrievers import KeywordTableGPTRetriever from llama_index.indices.keyword_table import GPTSimpleKeywordTableIndex from llama_index.indices.keyword_table.retrievers import KeywordTableRAKERetriever from llama_index.indices.keyword_table.retrievers import KeywordTableSimpleRetriever from llama_index import Prompt from llama_index import LLMPredictor from langchain.chat_models import ChatOpenAI from llama_index import ServiceContext def main(): st.title("Llama Index App") # Select indexes index_names = ["vector_store", "table", "tree", "list"] index_choices = st.multiselect("Select indexes", index_names) # Load indexes from storage contexts indices = [] for index_name in index_choices: storage_context = StorageContext.from_defaults( docstore=SimpleDocumentStore.from_persist_dir(persist_dir=index_name), vector_store=SimpleVectorStore.from_persist_dir(persist_dir=index_name), index_store=SimpleIndexStore.from_persist_dir(persist_dir=index_name), ) index = load_index_from_storage(storage_context) indices.append(index) # Prompt user for query query = st.text_input("Enter your query") # Query the indexes response = None for index in indices: TEMPLATE_STR = ( "We have provided context information below. \n" "---------------------\n" "{context_str}" "\n---------------------\n" "Given this information, please answer the question: {query_str}\n" ) QA_TEMPLATE = Prompt(TEMPLATE_STR) llm_predictor = LLMPredictor(llm=ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo", streaming=True)) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, chunk_size=1024) query_engine = index.as_query_engine( service_context=service_context, text_qa_template=QA_TEMPLATE, similarity_top_k=3, streaming=True, ) response = query_engine.query(query) st.subheader(f"Results from {index.__class__.__name__}") # Display the response if response: # formatted_sources = response.get_formatted_sources() st.text(response) print(response) if __name__ == "__main__": main() ###### working ########

[((1225, 1252), 'streamlit.title', 'st.title', (['"""Llama Index App"""'], {}), "('Llama Index App')\n", (1233, 1252), True, 'import streamlit as st\n'), ((1355, 1400), 'streamlit.multiselect', 'st.multiselect', (['"""Select indexes"""', 'index_names'], {}), "('Select indexes', index_names)\n", (1369, 1400), True, 'import streamlit as st\n'), ((1942, 1975), 'streamlit.text_input', 'st.text_input', (['"""Enter your query"""'], {}), "('Enter your query')\n", (1955, 1975), True, 'import streamlit as st\n'), ((1830, 1870), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (1853, 1870), False, 'from llama_index import StorageContext, load_index_from_storage\n'), ((2331, 2351), 'llama_index.Prompt', 'Prompt', (['TEMPLATE_STR'], {}), '(TEMPLATE_STR)\n', (2337, 2351), False, 'from llama_index import Prompt\n'), ((2490, 2564), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'chunk_size': '(1024)'}), '(llm_predictor=llm_predictor, chunk_size=1024)\n', (2518, 2564), False, 'from llama_index import ServiceContext\n'), ((2805, 2861), 'streamlit.subheader', 'st.subheader', (['f"""Results from {index.__class__.__name__}"""'], {}), "(f'Results from {index.__class__.__name__}')\n", (2817, 2861), True, 'import streamlit as st\n'), ((3003, 3020), 'streamlit.text', 'st.text', (['response'], {}), '(response)\n', (3010, 3020), True, 'import streamlit as st\n'), ((1574, 1634), 'llama_index.storage.docstore.SimpleDocumentStore.from_persist_dir', 'SimpleDocumentStore.from_persist_dir', ([], {'persist_dir': 'index_name'}), '(persist_dir=index_name)\n', (1610, 1634), False, 'from llama_index.storage.docstore import SimpleDocumentStore\n'), ((1661, 1719), 'llama_index.vector_stores.SimpleVectorStore.from_persist_dir', 'SimpleVectorStore.from_persist_dir', ([], {'persist_dir': 'index_name'}), '(persist_dir=index_name)\n', (1695, 1719), False, 'from llama_index.vector_stores import SimpleVectorStore\n'), ((1745, 1802), 'llama_index.storage.index_store.SimpleIndexStore.from_persist_dir', 'SimpleIndexStore.from_persist_dir', ([], {'persist_dir': 'index_name'}), '(persist_dir=index_name)\n', (1778, 1802), False, 'from llama_index.storage.index_store import SimpleIndexStore\n'), ((2393, 2462), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo"""', 'streaming': '(True)'}), "(temperature=0, model_name='gpt-3.5-turbo', streaming=True)\n", (2403, 2462), False, 'from langchain.chat_models import ChatOpenAI\n')]

from fastapi import FastAPI from fastapi.responses import JSONResponse, StreamingResponse from pydantic import BaseModel import os.path import llama_index from llama_index import ( VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate ) from llama_index.embeddings import HuggingFaceEmbedding from fastapi.middleware.cors import CORSMiddleware import logging import sys # Set global handler for LLaMA index llama_index.set_global_handler("simple") # Initialize FastAPI app app = FastAPI() # Define directory for persisting index PERSIST_DIR = "./storage" # Initialize embedding model embed_model = HuggingFaceEmbedding(model_name="OrdalieTech/Solon-embeddings-large-0.1") # Create service context with embedding model service_context = ServiceContext.from_defaults(embed_model=embed_model) set_global_service_context(service_context) # Load or create the index if not os.path.exists(PERSIST_DIR): documents = SimpleDirectoryReader("data").load_data() index = VectorStoreIndex.from_documents(documents) index.storage_context.persist(persist_dir=PERSIST_DIR) else: storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR) index = load_index_from_storage(storage_context) # Initialize query engine from index query_engine = index.as_query_engine(streaming=True, similarity_top_k=2) # Define custom prompt template qa_prompt_tmpl_str = ( "Context information is below.\n" "---------------------\n" "{context_str}\n" "---------------------\n" "Given the context information and not prior knowledge,Some rules to follow: 1. Avoid statements like 'Based on the context, ...' or 'The context information ...' or anything along those lines. " "answer the query in french and but remember you are chatbot trained on rh questions so always put that in perspective . you are named Rhym a chatbot created by the innovation team at BMCI \n" "Query: {query_str}\n" "Answer: " ) qa_prompt_tmpl = PromptTemplate(qa_prompt_tmpl_str) # Update query engine with custom prompt template query_engine.update_prompts( {"response_synthesizer:text_qa_template": qa_prompt_tmpl} ) # Define Pydantic model for query requests class Query(BaseModel): text: str @app.get("/query") async def query_index(query: str ): try: response_stream = query_engine.query(query) async def event_stream(): for text in response_stream.response_gen: yield f"data: {text}\n\n" # Send a special message or marker to indicate the end of the stream yield "data: END_OF_STREAM\n\n" return StreamingResponse(event_stream(), media_type="text/event-stream") except Exception as e: logging.error(f"Error during query processing: {str(e)}") return JSONResponse( status_code=503, content={"message": "LLM API is currently unavailable.", "error": str(e)} ) # Add CORS middleware to allow specific origins (or use '*' for all origins) origins = [ "*", # Allow all origins ] app.add_middleware( CORSMiddleware, allow_origins=origins, allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # ... [rest of your code] # The main function remains unchanged if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)

[((528, 568), 'llama_index.set_global_handler', 'llama_index.set_global_handler', (['"""simple"""'], {}), "('simple')\n", (558, 568), False, 'import llama_index\n'), ((601, 610), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (608, 610), False, 'from fastapi import FastAPI\n'), ((722, 795), 'llama_index.embeddings.HuggingFaceEmbedding', 'HuggingFaceEmbedding', ([], {'model_name': '"""OrdalieTech/Solon-embeddings-large-0.1"""'}), "(model_name='OrdalieTech/Solon-embeddings-large-0.1')\n", (742, 795), False, 'from llama_index.embeddings import HuggingFaceEmbedding\n'), ((861, 914), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'embed_model': 'embed_model'}), '(embed_model=embed_model)\n', (889, 914), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate\n'), ((915, 958), 'llama_index.set_global_service_context', 'set_global_service_context', (['service_context'], {}), '(service_context)\n', (941, 958), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate\n'), ((2076, 2110), 'llama_index.PromptTemplate', 'PromptTemplate', (['qa_prompt_tmpl_str'], {}), '(qa_prompt_tmpl_str)\n', (2090, 2110), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate\n'), ((1093, 1135), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (1124, 1135), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate\n'), ((1223, 1276), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'PERSIST_DIR'}), '(persist_dir=PERSIST_DIR)\n', (1251, 1276), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate\n'), ((1289, 1329), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (1312, 1329), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate\n'), ((3437, 3480), 'uvicorn.run', 'uvicorn.run', (['app'], {'host': '"""0.0.0.0"""', 'port': '(8000)'}), "(app, host='0.0.0.0', port=8000)\n", (3448, 3480), False, 'import uvicorn\n'), ((1039, 1068), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""data"""'], {}), "('data')\n", (1060, 1068), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, StorageContext, ServiceContext, load_index_from_storage, set_global_service_context, PromptTemplate\n')]

get_ipython().run_line_magic('pip', 'install llama-index-llms-openai') get_ipython().run_line_magic('pip', 'install llama-hub-llama-packs-tables-chain-of-table-base') get_ipython().system('wget "https://github.com/ppasupat/WikiTableQuestions/releases/download/v1.0.2/WikiTableQuestions-1.0.2-compact.zip" -O data.zip') get_ipython().system('unzip data.zip') import pandas as pd df = pd.read_csv("./WikiTableQuestions/csv/200-csv/3.csv") df from llama_index.packs.tables.chain_of_table.base import ( ChainOfTableQueryEngine, serialize_table, ) from llama_index.core.llama_pack import download_llama_pack download_llama_pack( "ChainOfTablePack", "./chain_of_table_pack", skip_load=True, ) from llama_index.llms.openai import OpenAI llm = OpenAI(model="gpt-4-1106-preview") import phoenix as px import llama_index.core px.launch_app() llama_index.core.set_global_handler("arize_phoenix") import pandas as pd df = pd.read_csv("~/Downloads/WikiTableQuestions/csv/200-csv/11.csv") df query_engine = ChainOfTableQueryEngine(df, llm=llm, verbose=True) response = query_engine.query("Who won best Director in the 1972 Academy Awards?") str(response.response) import pandas as pd df = pd.read_csv("./WikiTableQuestions/csv/200-csv/42.csv") df query_engine = ChainOfTableQueryEngine(df, llm=llm, verbose=True) response = query_engine.query("What was the precipitation in inches during June?") str(response) from llama_index.core import PromptTemplate from llama_index.core.query_pipeline import QueryPipeline prompt_str = """\ Here's a serialized table. {serialized_table} Given this table please answer the question: {question} Answer: """ prompt = PromptTemplate(prompt_str) prompt_c = prompt.as_query_component(partial={"serialized_table": serialize_table(df)}) qp = QueryPipeline(chain=[prompt_c, llm]) response = qp.run("What was the precipitation in inches during June?") print(str(response)) import pandas as pd df = pd.read_csv("./WikiTableQuestions/csv/203-csv/114.csv") df query_engine = ChainOfTableQueryEngine(df, llm=llm, verbose=True) response = query_engine.query("Which televised ABC game had the greatest attendance?") print(str(response)) from llama_index.core import PromptTemplate from llama_index.core.query_pipeline import QueryPipeline prompt_str = """\ Here's a serialized table. {serialized_table} Given this table please answer the question: {question} Answer: """ prompt = PromptTemplate(prompt_str) prompt_c = prompt.as_query_component(partial={"serialized_table": serialize_table(df)}) qp = QueryPipeline(chain=[prompt_c, llm]) response = qp.run("Which televised ABC game had the greatest attendance?") print(str(response))

[((389, 442), 'pandas.read_csv', 'pd.read_csv', (['"""./WikiTableQuestions/csv/200-csv/3.csv"""'], {}), "('./WikiTableQuestions/csv/200-csv/3.csv')\n", (400, 442), True, 'import pandas as pd\n'), ((622, 707), 'llama_index.core.llama_pack.download_llama_pack', 'download_llama_pack', (['"""ChainOfTablePack"""', '"""./chain_of_table_pack"""'], {'skip_load': '(True)'}), "('ChainOfTablePack', './chain_of_table_pack', skip_load=True\n )\n", (641, 707), False, 'from llama_index.core.llama_pack import download_llama_pack\n'), ((770, 804), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4-1106-preview"""'}), "(model='gpt-4-1106-preview')\n", (776, 804), False, 'from llama_index.llms.openai import OpenAI\n'), ((854, 869), 'phoenix.launch_app', 'px.launch_app', ([], {}), '()\n', (867, 869), True, 'import phoenix as px\n'), ((953, 1017), 'pandas.read_csv', 'pd.read_csv', (['"""~/Downloads/WikiTableQuestions/csv/200-csv/11.csv"""'], {}), "('~/Downloads/WikiTableQuestions/csv/200-csv/11.csv')\n", (964, 1017), True, 'import pandas as pd\n'), ((1040, 1090), 'llama_index.packs.tables.chain_of_table.base.ChainOfTableQueryEngine', 'ChainOfTableQueryEngine', (['df'], {'llm': 'llm', 'verbose': '(True)'}), '(df, llm=llm, verbose=True)\n', (1063, 1090), False, 'from llama_index.packs.tables.chain_of_table.base import ChainOfTableQueryEngine, serialize_table\n'), ((1230, 1284), 'pandas.read_csv', 'pd.read_csv', (['"""./WikiTableQuestions/csv/200-csv/42.csv"""'], {}), "('./WikiTableQuestions/csv/200-csv/42.csv')\n", (1241, 1284), True, 'import pandas as pd\n'), ((1307, 1357), 'llama_index.packs.tables.chain_of_table.base.ChainOfTableQueryEngine', 'ChainOfTableQueryEngine', (['df'], {'llm': 'llm', 'verbose': '(True)'}), '(df, llm=llm, verbose=True)\n', (1330, 1357), False, 'from llama_index.packs.tables.chain_of_table.base import ChainOfTableQueryEngine, serialize_table\n'), ((1708, 1734), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (1722, 1734), False, 'from llama_index.core import PromptTemplate\n'), ((1831, 1867), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[prompt_c, llm]'}), '(chain=[prompt_c, llm])\n', (1844, 1867), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((1989, 2044), 'pandas.read_csv', 'pd.read_csv', (['"""./WikiTableQuestions/csv/203-csv/114.csv"""'], {}), "('./WikiTableQuestions/csv/203-csv/114.csv')\n", (2000, 2044), True, 'import pandas as pd\n'), ((2065, 2115), 'llama_index.packs.tables.chain_of_table.base.ChainOfTableQueryEngine', 'ChainOfTableQueryEngine', (['df'], {'llm': 'llm', 'verbose': '(True)'}), '(df, llm=llm, verbose=True)\n', (2088, 2115), False, 'from llama_index.packs.tables.chain_of_table.base import ChainOfTableQueryEngine, serialize_table\n'), ((2475, 2501), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (2489, 2501), False, 'from llama_index.core import PromptTemplate\n'), ((2595, 2631), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[prompt_c, llm]'}), '(chain=[prompt_c, llm])\n', (2608, 2631), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((1801, 1820), 'llama_index.packs.tables.chain_of_table.base.serialize_table', 'serialize_table', (['df'], {}), '(df)\n', (1816, 1820), False, 'from llama_index.packs.tables.chain_of_table.base import ChainOfTableQueryEngine, serialize_table\n'), ((2568, 2587), 'llama_index.packs.tables.chain_of_table.base.serialize_table', 'serialize_table', (['df'], {}), '(df)\n', (2583, 2587), False, 'from llama_index.packs.tables.chain_of_table.base import ChainOfTableQueryEngine, serialize_table\n')]

from llama_hub.file.unstructured.base import UnstructuredReader from unstructured.partition.auto import partition from unstructured.documents.elements import NarrativeText import llama_index as li from pathlib import Path import openai import os import re import ast import json openai.api_key = 'your_key' os.environ['OPENAI_API_KEY'] = 'your_key' #Path to textbook pdf pdf = Path(f'data/ex_textbook.pdf') UnstructuredReader = li.download_loader("UnstructuredReader", refresh_cache=True, use_gpt_index_import=True) loader = UnstructuredReader() textbook = loader.load_data(file=pdf, split_documents=True) elements = partition(filename=pdf) #What you need to modify #Start of every chapter pattern1 = r"(\d+)\s+Chapter\s+(\d+):" #End of every chapter introduction pattern2 = r"^\d+[CE](?: [A-Z])+" #End of last chapter end = "Need to Know More?" #Tracking where chapters start/end chapter_found = {} chapter_starts = [] intros = [] for iteration, element in enumerate(textbook): match1 = re.search(pattern1, element.text) match2 = re.search(pattern2, element.text) if match1: chapter_number = match1.group(2) if chapter_number not in chapter_found: chapter_found[chapter_number] = True chapter_starts.append(iteration) intros.append(iteration) if match2: intros.append(iteration) #Finding where last chapter ends for x in textbook[chapter_starts[len(chapter_starts) - 1]:]: if x.text == end: chapter_starts.append(textbook.index(x)) #Collecting chapter summaries for GPT prompts summaries = [] iteration = 0 for x in intros[::2]: temp ='' for element in elements[x:intros[iteration+1]]: temp = temp + textbook[elements.index(element)].text + '\n' summaries.append(temp) iteration += 2 #Making dictionary with chapter as key and document objects as elements directory = {} chapter_num = 1 for x in range(len(chapter_starts) - 1): text = [] for element in elements[chapter_starts[x]:chapter_starts[x+1]]: if isinstance(element, NarrativeText): text.append(textbook[elements.index(element)]) directory['Chapter ' + str(chapter_num)] = text chapter_num += 1 #Combining all the narrative text of each chapter into one string and adding "This is Chapter 'x': " to the beginning and "This is the end of Chapter 'x'" to the end final=[] for chapter in directory: txt = '' for text in directory[chapter]: txt = txt + text.text directory[chapter][0].text = txt final.append(directory[chapter][0]) for iteration, text in enumerate(final): final[iteration].text = "This is Chapter " + str(iteration + 1) + ":\n" + text.text + "\nThis is the end of Chapter " + str(iteration + 1) node_parser = li.node_parser.SimpleNodeParser() nodes = node_parser.get_nodes_from_documents(final) test_index = li.GPTVectorStoreIndex(nodes=nodes, chunk_size_limit=512) query_engine = test_index.as_query_engine() def create_questions(num_chapters): form ="""[ { "question": , "choices": , "correct_answer_index": , "explanation": } ] """ final = [] for chapter in range(num_chapters): temp = [] chap_num = str(chapter + 1) summary = query_engine.query(f"""Elaborate on these key topics of chapter {chap_num} in detail: {summaries[chapter]} """ ) temp.append(str(summary)) response = query_engine.query(f""" CHAPTER {chap_num}: {str(summary)} Please generate SIX different multiple choice questions that covers all of the above information. Must be variety in the type of questions (scenario questions, definitions, comparison questions) and some must have multiple correct answers. Do NOT reference the text in the questions and explanations themselves. Do not repeat any questions. In the explanation, provide more insight and also the chapter that it comes from Return the result in the following JSON format: {form} """) temp.append(ast.literal_eval(str(response))) final.append(temp) return final questions = create_questions(len(chapter_starts) - 1) test = [] for chap in questions: for question in chap[1]: test.append(question) json_string = json.dumps(test, indent=4) # Write the JSON string to a file with open("website/ex_questions.json", "w") as json_file: json_file.write(json_string)

[((379, 408), 'pathlib.Path', 'Path', (['f"""data/ex_textbook.pdf"""'], {}), "(f'data/ex_textbook.pdf')\n", (383, 408), False, 'from pathlib import Path\n'), ((431, 522), 'llama_index.download_loader', 'li.download_loader', (['"""UnstructuredReader"""'], {'refresh_cache': '(True)', 'use_gpt_index_import': '(True)'}), "('UnstructuredReader', refresh_cache=True,\n use_gpt_index_import=True)\n", (449, 522), True, 'import llama_index as li\n'), ((528, 548), 'llama_hub.file.unstructured.base.UnstructuredReader', 'UnstructuredReader', ([], {}), '()\n', (546, 548), False, 'from llama_hub.file.unstructured.base import UnstructuredReader\n'), ((620, 643), 'unstructured.partition.auto.partition', 'partition', ([], {'filename': 'pdf'}), '(filename=pdf)\n', (629, 643), False, 'from unstructured.partition.auto import partition\n'), ((2783, 2816), 'llama_index.node_parser.SimpleNodeParser', 'li.node_parser.SimpleNodeParser', ([], {}), '()\n', (2814, 2816), True, 'import llama_index as li\n'), ((2882, 2939), 'llama_index.GPTVectorStoreIndex', 'li.GPTVectorStoreIndex', ([], {'nodes': 'nodes', 'chunk_size_limit': '(512)'}), '(nodes=nodes, chunk_size_limit=512)\n', (2904, 2939), True, 'import llama_index as li\n'), ((4304, 4330), 'json.dumps', 'json.dumps', (['test'], {'indent': '(4)'}), '(test, indent=4)\n', (4314, 4330), False, 'import json\n'), ((999, 1032), 're.search', 're.search', (['pattern1', 'element.text'], {}), '(pattern1, element.text)\n', (1008, 1032), False, 'import re\n'), ((1046, 1079), 're.search', 're.search', (['pattern2', 'element.text'], {}), '(pattern2, element.text)\n', (1055, 1079), False, 'import re\n')]

get_ipython().system('pip install llama-index') import os import openai os.environ["OPENAI_API_KEY"] = "sk-..." openai.api_key = os.environ["OPENAI_API_KEY"] import nltk nltk.download("stopwords") import llama_index.core import logging import sys logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) from llama_index.core import ( VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ) from IPython.display import Markdown, display get_ipython().system("mkdir -p 'data/paul_graham/'") get_ipython().system("wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt' -O 'data/paul_graham/paul_graham_essay.txt'") documents = SimpleDirectoryReader("./data/paul_graham/").load_data() index = VectorStoreIndex.from_documents(documents) index.set_index_id("vector_index") index.storage_context.persist("./storage") storage_context = StorageContext.from_defaults(persist_dir="storage") index = load_index_from_storage(storage_context, index_id="vector_index") query_engine = index.as_query_engine(response_mode="tree_summarize") response = query_engine.query("What did the author do growing up?") display(Markdown(f"<b>{response}</b>")) query_modes = [ "svm", "linear_regression", "logistic_regression", ] for query_mode in query_modes: query_engine = index.as_query_engine(vector_store_query_mode=query_mode) response = query_engine.query("What did the author do growing up?") print(f"Query mode: {query_mode}") display(Markdown(f"<b>{response}</b>")) display(Markdown(f"<b>{response}</b>")) print(response.source_nodes[0].text) from llama_index.core import QueryBundle query_bundle = QueryBundle( query_str="What did the author do growing up?", custom_embedding_strs=["The author grew up painting."], ) query_engine = index.as_query_engine() response = query_engine.query(query_bundle) display(Markdown(f"<b>{response}</b>")) query_engine = index.as_query_engine( vector_store_query_mode="mmr", vector_store_kwargs={"mmr_threshold": 0.2} ) response = query_engine.query("What did the author do growing up?") print(response.get_formatted_sources()) from llama_index.core import Document doc = Document(text="target", metadata={"tag": "target"}) index.insert(doc) from llama_index.core.vector_stores import ExactMatchFilter, MetadataFilters filters = MetadataFilters( filters=[ExactMatchFilter(key="tag", value="target")] ) retriever = index.as_retriever( similarity_top_k=20, filters=filters, ) source_nodes = retriever.retrieve("What did the author do growing up?") print(len(source_nodes)) print(source_nodes[0].text) print(source_nodes[0].metadata)

[((177, 203), 'nltk.download', 'nltk.download', (['"""stopwords"""'], {}), "('stopwords')\n", (190, 203), False, 'import nltk\n'), ((259, 317), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (278, 317), False, 'import logging\n'), ((895, 937), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (926, 937), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext\n'), ((1038, 1089), 'llama_index.core.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""storage"""'}), "(persist_dir='storage')\n", (1066, 1089), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext\n'), ((1098, 1163), 'llama_index.core.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {'index_id': '"""vector_index"""'}), "(storage_context, index_id='vector_index')\n", (1121, 1163), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext\n'), ((1835, 1954), 'llama_index.core.QueryBundle', 'QueryBundle', ([], {'query_str': '"""What did the author do growing up?"""', 'custom_embedding_strs': "['The author grew up painting.']"}), "(query_str='What did the author do growing up?',\n custom_embedding_strs=['The author grew up painting.'])\n", (1846, 1954), False, 'from llama_index.core import QueryBundle\n'), ((2367, 2418), 'llama_index.core.Document', 'Document', ([], {'text': '"""target"""', 'metadata': "{'tag': 'target'}"}), "(text='target', metadata={'tag': 'target'})\n", (2375, 2418), False, 'from llama_index.core import Document\n'), ((349, 389), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (370, 389), False, 'import logging\n'), ((1314, 1344), 'IPython.display.Markdown', 'Markdown', (['f"""<b>{response}</b>"""'], {}), "(f'<b>{response}</b>')\n", (1322, 1344), False, 'from IPython.display import Markdown, display\n'), ((1703, 1733), 'IPython.display.Markdown', 'Markdown', (['f"""<b>{response}</b>"""'], {}), "(f'<b>{response}</b>')\n", (1711, 1733), False, 'from IPython.display import Markdown, display\n'), ((2055, 2085), 'IPython.display.Markdown', 'Markdown', (['f"""<b>{response}</b>"""'], {}), "(f'<b>{response}</b>')\n", (2063, 2085), False, 'from IPython.display import Markdown, display\n'), ((318, 337), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (335, 337), False, 'import logging\n'), ((828, 872), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""./data/paul_graham/"""'], {}), "('./data/paul_graham/')\n", (849, 872), False, 'from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext\n'), ((1661, 1691), 'IPython.display.Markdown', 'Markdown', (['f"""<b>{response}</b>"""'], {}), "(f'<b>{response}</b>')\n", (1669, 1691), False, 'from IPython.display import Markdown, display\n'), ((2558, 2601), 'llama_index.core.vector_stores.ExactMatchFilter', 'ExactMatchFilter', ([], {'key': '"""tag"""', 'value': '"""target"""'}), "(key='tag', value='target')\n", (2574, 2601), False, 'from llama_index.core.vector_stores import ExactMatchFilter, MetadataFilters\n')]

import gradio as gr import os from datetime import datetime import logging import sys from llama_index import SimpleDirectoryReader import llama_index.readers.file.base import glob import numpy as np import soundfile as sf import shutil import openai import json import cv2 from llama_index import download_loader ImageCaptionReader = download_loader('ImageCaptionReader') openai.api_key = os.environ['OPENAI_API_KEY'] logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) # print('done processing import') with open('config.json', encoding='utf8') as f: config = json.load(f) def process_inputs(text: str, image: np.ndarray, video: str, audio: tuple, ): output = "" # # print('video', type(video), video) # # print('text', type(text), text) # # print('audio', type(audio), audio) # # print('image', type(image), image) if not text and image is not None and not video and audio is not None: return "Please upload at least one of the following: text, image, video, audio." timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") # Create a folder named 'media_files' if it doesn't exist os.makedirs(f"media_files/{timestamp}", exist_ok=True) if video: video_path = os.path.join("media_files", f"{timestamp}/video.mp4") # copy from "video" to "video_path" shutil.copyfile(video, video_path) # os.rename(video_path, video_path) ffmpeg_cmd = f'ffmpeg -i {video_path} -vf "select=not(mod(n\,100))" -vsync vfr media_files/{timestamp}/frame_%03d.jpg' os.system(ffmpeg_cmd) output += "Video processed and saved.\n" print("Video processed and saved.") # gr.Interface.update("Video saved.") if text: text_path = os.path.join("media_files", f"{timestamp}/text.txt") with open(text_path, "w", encoding='utf8') as f: f.write(text) output += "Text processed and saved: " + text + "\n" # print("Text processed and saved: " + text + "") # gr.Interface.update("Text processed and saved: " + "") if audio is not None: sr, audio = audio audio_path = os.path.join("media_files", f"{timestamp}/audio.mp3") sf.write(audio_path, audio, sr) output += "Audio processed and saved.\n" print("Audio processed and saved.") # gr.Interface.update("Audio saved.") if image is not None: image_path = os.path.join("media_files", f"{timestamp}/image.png") image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) cv2.imwrite(image_path, image) output += "Image processed and saved.\n" print("Image processed and saved.") # gr.Interface.update("Image saved.") root = f"media_files/{timestamp}" image_caption_prompt = "Question: Describe what you see in this image and if there are any dangers or emergencies there any dangers and how sever they are. Answer:" text_files = glob.glob(f'{root}/*.txt') text_content = '' if text_files: # print('processing text_files ...') text_content = SimpleDirectoryReader( input_files=text_files, file_extractor={ ".jpg": ImageCaptionReader(), ".png": ImageCaptionReader(), ".jpeg": ImageCaptionReader(), ".wav": llama_index.readers.file.video_audio_reader, ".mp4": llama_index.readers.file.video_audio_reader, } ).load_data() texts = [x.text for x in text_content] text = '\n\n'.join(texts) text_content = text.replace('"', "'").replace('\n', '. ') # print('done processing text_files') image_files = glob.glob(f'{root}/*.png') + glob.glob(f'{root}/*.jpg') image_content = '' if image_files: # print('processing image_files ...') image_content = SimpleDirectoryReader( input_files=image_files, file_extractor={ ".jpg": ImageCaptionReader(), ".png": ImageCaptionReader(), ".jpeg": ImageCaptionReader(), ".wav": llama_index.readers.file.video_audio_reader, ".mp4": llama_index.readers.file.video_audio_reader, } ).load_data() texts = [x.text for x in image_content] text = '\n\n'.join(texts) image_content = text.replace('"', "'").replace('\n', '. ') # print('done processing image_files') audio_files = glob.glob(f'{root}/*.mp3') audio_content = '' if audio_files: # print('processing audio_files ...') audio_content = SimpleDirectoryReader( input_files=audio_files, file_extractor={ ".jpg": ImageCaptionReader(), ".png": ImageCaptionReader(), ".jpeg": ImageCaptionReader(), ".mp3": llama_index.readers.file.video_audio_reader, ".mp4": llama_index.readers.file.video_audio_reader, } ).load_data() texts = [x.text for x in audio_content] text = '\n\n'.join(texts) audio_content = text.replace('"', "'").replace('\n', '. ') # print('done processing audio_files') video_files = glob.glob(f'{root}/*.mp4') video_content = '' if video_files: # print('processing video_files ...') video_content = SimpleDirectoryReader( input_files=video_files, file_extractor={ ".jpg": ImageCaptionReader(), ".png": ImageCaptionReader(), ".jpeg": ImageCaptionReader(), ".mp3": llama_index.readers.file.video_audio_reader, ".mp4": llama_index.readers.file.video_audio_reader, } ).load_data() texts = [x.text for x in video_content] text = '\n\n'.join(texts) video_content = text.replace('"', "'").replace('\n', '. ') # print('done processing video_files') ar2en = {v:k for (k,v) in config["en2ar"].items()} emergencies_en = [ar2en[k] for k in config['redirects']] system_prompt = f"""I want you to act as a 911 operator that understands Arabic. I will give you text and audio transcripts that the users upload in an emergency, and I need you to classify the different types of emergencies. The incoming information could be Arabic or English, and you must output only in English. The different types of emergencies are only one of {len(emergencies_en)}: {json.dumps(emergencies_en)} I will give you the information provided by the user bellow, and you should classify from the {len(emergencies_en)} types of emergencies. """ prompt = """ === User information for emergency """ if text_content: prompt += f'User text: "{text_content}"\n' if image_content: prompt += f'User uploaded an image of: "{image_content}"\n' if audio_content: prompt += f'User uploaded an audio, the text in that audio sounds like: "{audio_content} {video_content}" \n' prompt += """ === End of user information for emergency Now you must output only in JSON in the following format: {"emergency_class": string, "explaination_arabic": string} Note that "explaination_arabic" must be in Arabic. For the emergency_class, you must choose one of the following: """ + json.dumps(emergencies_en) # print('prompt', prompt) completion = openai.ChatCompletion.create( model="gpt-4", messages=[ {"role": "system", "content": system_prompt}, {"role": "user", "content": prompt}, ] ) # parse model JSON output content = completion.choices[0].message.content content = content.replace(",}", "}") # just in case # start from first "{" until the first "}" content = content[content.find("{") : content.find("}")+1] # print('ChatGPT response:', content) try: result = json.loads(content) except: result = { "emergency_class": "unknown", "explaination_arabic": "Could not parse output.: " + content } emergency_class_ar = config['en2ar'].get(result['emergency_class'], "غير معروف") redirects = config['redirects'].get(emergency_class_ar, ["<غير معروف>"]) output = f"""نوع الحالة: {emergency_class_ar} الجهات المسؤولة: - """ + ('\n - '.join(redirects)) + f"\n\nالشرح: {result['explaination_arabic']}" return output if output else "No input provided." video_input = gr.inputs.Video(optional=True, label="Input Video") text_input = gr.inputs.Textbox(lines=3, optional=True, label="Input Text") audio_input = gr.inputs.Audio(optional=True, label="Input Audio") image_input = gr.inputs.Image(optional=True, label="Input Image") output_text = gr.outputs.Textbox(label="Output Text") examples = [ # text_input, image_input, video_input, audio_input ["", None,"data/fire_at_gas_station.mp4", None,], ["", "data/small-car-accident.jpg", None, None], ["", "data/electrical-fire.jpg", None, None], ["", "data/major-car-accident.jpg", None, None], ["", "data/gettyimages-50908538-612x612.jpg", None, None], ["", None, None, "data/fire_at_gas_station.mp3",], ["السلام عليكم، أنا أتصل لأبلغ عن حريق كبير في مبنى سكني بشارع المنصور. يبدو أن النيران اندلعت في الطابق الثالث وتنتشر بسرورة. يرجى إرسال رجال الإطفاء فوراً", None, None, None], ["السلام عليكم، أنا أتصل لأبلغ عن حادثة تحرش حدثت لي في مترو الأنفاق بمحطة المرج. كان هناك رجل يلمسني بشكل غير لائق ويحاول مضايقتي. يرجى إرسال دورية أمنية للموقع فوراً", None, None, None], ["السلام عليكم، أنا أتصل لأبلغ عن سرقة تعرضت لها قبل قليل. شخصان قاما بسلب هاتفي الجوال ومحفظتي تحت تهديد السلاح. حدث ذلك في حي النزهة بالقرب من متجر السوبر ماركت. أرجو إرسال دورية أمنية وفتح تحقيق في الواقعة", None, None, None], ] iface = gr.Interface( fn=process_inputs, inputs=[text_input, image_input, video_input, audio_input], outputs=output_text, title="<img src='https://i.imgur.com/Qakrqvn.png' width='100' height='100'> منصة استجابة", description="تحديد نوع المخاطر والحالات الطارئة تلقائيا باستخدام الذكاء الاصطناعي,\nشبيها بتطبيق 'كلنا امن' بامكانك رفع نص او صور اومقطع او صوت وسيتم تحديد نوع الحالة والجهات المسؤولة عنها", examples=examples, cache_examples=True, ) # image = gr.Image("logo.png", style=(100, 100)) # iface.add(image) # "text-align: right;" # print('http://127.0.0.1:7860/?__theme=light') iface.launch( share=True, favicon_path='logo.png' )

[((337, 374), 'llama_index.download_loader', 'download_loader', (['"""ImageCaptionReader"""'], {}), "('ImageCaptionReader')\n", (352, 374), False, 'from llama_index import download_loader\n'), ((423, 481), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (442, 481), False, 'import logging\n'), ((8563, 8614), 'gradio.inputs.Video', 'gr.inputs.Video', ([], {'optional': '(True)', 'label': '"""Input Video"""'}), "(optional=True, label='Input Video')\n", (8578, 8614), True, 'import gradio as gr\n'), ((8628, 8689), 'gradio.inputs.Textbox', 'gr.inputs.Textbox', ([], {'lines': '(3)', 'optional': '(True)', 'label': '"""Input Text"""'}), "(lines=3, optional=True, label='Input Text')\n", (8645, 8689), True, 'import gradio as gr\n'), ((8704, 8755), 'gradio.inputs.Audio', 'gr.inputs.Audio', ([], {'optional': '(True)', 'label': '"""Input Audio"""'}), "(optional=True, label='Input Audio')\n", (8719, 8755), True, 'import gradio as gr\n'), ((8770, 8821), 'gradio.inputs.Image', 'gr.inputs.Image', ([], {'optional': '(True)', 'label': '"""Input Image"""'}), "(optional=True, label='Input Image')\n", (8785, 8821), True, 'import gradio as gr\n'), ((8837, 8876), 'gradio.outputs.Textbox', 'gr.outputs.Textbox', ([], {'label': '"""Output Text"""'}), "(label='Output Text')\n", (8855, 8876), True, 'import gradio as gr\n'), ((9894, 10355), 'gradio.Interface', 'gr.Interface', ([], {'fn': 'process_inputs', 'inputs': '[text_input, image_input, video_input, audio_input]', 'outputs': 'output_text', 'title': '"""<img src=\'https://i.imgur.com/Qakrqvn.png\' width=\'100\' height=\'100\'> منصة استجابة"""', 'description': '"""تحديد نوع المخاطر والحالات الطارئة تلقائيا باستخدام الذكاء الاصطناعي,\nشبيها بتطبيق \'كلنا امن\' بامكانك رفع نص او صور اومقطع او صوت وسيتم تحديد نوع الحالة والجهات المسؤولة عنها"""', 'examples': 'examples', 'cache_examples': '(True)'}), '(fn=process_inputs, inputs=[text_input, image_input,\n video_input, audio_input], outputs=output_text, title=\n "<img src=\'https://i.imgur.com/Qakrqvn.png\' width=\'100\' height=\'100\'> منصة استجابة"\n , description=\n """تحديد نوع المخاطر والحالات الطارئة تلقائيا باستخدام الذكاء الاصطناعي,\nشبيها بتطبيق \'كلنا امن\' بامكانك رفع نص او صور اومقطع او صوت وسيتم تحديد نوع الحالة والجهات المسؤولة عنها"""\n , examples=examples, cache_examples=True)\n', (9906, 10355), True, 'import gradio as gr\n'), ((513, 553), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (534, 553), False, 'import logging\n'), ((651, 663), 'json.load', 'json.load', (['f'], {}), '(f)\n', (660, 663), False, 'import json\n'), ((1216, 1270), 'os.makedirs', 'os.makedirs', (['f"""media_files/{timestamp}"""'], {'exist_ok': '(True)'}), "(f'media_files/{timestamp}', exist_ok=True)\n", (1227, 1270), False, 'import os\n'), ((3028, 3054), 'glob.glob', 'glob.glob', (['f"""{root}/*.txt"""'], {}), "(f'{root}/*.txt')\n", (3037, 3054), False, 'import glob\n'), ((4565, 4591), 'glob.glob', 'glob.glob', (['f"""{root}/*.mp3"""'], {}), "(f'{root}/*.mp3')\n", (4574, 4591), False, 'import glob\n'), ((5323, 5349), 'glob.glob', 'glob.glob', (['f"""{root}/*.mp4"""'], {}), "(f'{root}/*.mp4')\n", (5332, 5349), False, 'import glob\n'), ((7486, 7627), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': '"""gpt-4"""', 'messages': "[{'role': 'system', 'content': system_prompt}, {'role': 'user', 'content':\n prompt}]"}), "(model='gpt-4', messages=[{'role': 'system',\n 'content': system_prompt}, {'role': 'user', 'content': prompt}])\n", (7514, 7627), False, 'import openai\n'), ((482, 501), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (499, 501), False, 'import logging\n'), ((1308, 1361), 'os.path.join', 'os.path.join', (['"""media_files"""', 'f"""{timestamp}/video.mp4"""'], {}), "('media_files', f'{timestamp}/video.mp4')\n", (1320, 1361), False, 'import os\n'), ((1415, 1449), 'shutil.copyfile', 'shutil.copyfile', (['video', 'video_path'], {}), '(video, video_path)\n', (1430, 1449), False, 'import shutil\n'), ((1638, 1659), 'os.system', 'os.system', (['ffmpeg_cmd'], {}), '(ffmpeg_cmd)\n', (1647, 1659), False, 'import os\n'), ((1834, 1886), 'os.path.join', 'os.path.join', (['"""media_files"""', 'f"""{timestamp}/text.txt"""'], {}), "('media_files', f'{timestamp}/text.txt')\n", (1846, 1886), False, 'import os\n'), ((2228, 2281), 'os.path.join', 'os.path.join', (['"""media_files"""', 'f"""{timestamp}/audio.mp3"""'], {}), "('media_files', f'{timestamp}/audio.mp3')\n", (2240, 2281), False, 'import os\n'), ((2290, 2321), 'soundfile.write', 'sf.write', (['audio_path', 'audio', 'sr'], {}), '(audio_path, audio, sr)\n', (2298, 2321), True, 'import soundfile as sf\n'), ((2509, 2562), 'os.path.join', 'os.path.join', (['"""media_files"""', 'f"""{timestamp}/image.png"""'], {}), "('media_files', f'{timestamp}/image.png')\n", (2521, 2562), False, 'import os\n'), ((2579, 2617), 'cv2.cvtColor', 'cv2.cvtColor', (['image', 'cv2.COLOR_RGB2BGR'], {}), '(image, cv2.COLOR_RGB2BGR)\n', (2591, 2617), False, 'import cv2\n'), ((2626, 2656), 'cv2.imwrite', 'cv2.imwrite', (['image_path', 'image'], {}), '(image_path, image)\n', (2637, 2656), False, 'import cv2\n'), ((3778, 3804), 'glob.glob', 'glob.glob', (['f"""{root}/*.png"""'], {}), "(f'{root}/*.png')\n", (3787, 3804), False, 'import glob\n'), ((3807, 3833), 'glob.glob', 'glob.glob', (['f"""{root}/*.jpg"""'], {}), "(f'{root}/*.jpg')\n", (3816, 3833), False, 'import glob\n'), ((7410, 7436), 'json.dumps', 'json.dumps', (['emergencies_en'], {}), '(emergencies_en)\n', (7420, 7436), False, 'import json\n'), ((7998, 8017), 'json.loads', 'json.loads', (['content'], {}), '(content)\n', (8008, 8017), False, 'import json\n'), ((1109, 1123), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1121, 1123), False, 'from datetime import datetime\n'), ((6598, 6624), 'json.dumps', 'json.dumps', (['emergencies_en'], {}), '(emergencies_en)\n', (6608, 6624), False, 'import json\n')]

"""Download.""" import json import logging import os import subprocess import sys from enum import Enum from importlib import util from pathlib import Path from typing import Any, Dict, List, Optional, Union import pkg_resources import requests from pkg_resources import DistributionNotFound from llama_index.download.utils import ( get_exports, get_file_content, initialize_directory, rewrite_exports, ) LLAMA_HUB_CONTENTS_URL = f"https://raw.githubusercontent.com/run-llama/llama-hub/main" LLAMA_HUB_PATH = "/llama_hub" LLAMA_HUB_URL = LLAMA_HUB_CONTENTS_URL + LLAMA_HUB_PATH PATH_TYPE = Union[str, Path] logger = logging.getLogger(__name__) LLAMAHUB_ANALYTICS_PROXY_SERVER = "https://llamahub.ai/api/analytics/downloads" class MODULE_TYPE(str, Enum): LOADER = "loader" TOOL = "tool" LLAMAPACK = "llamapack" DATASETS = "datasets" def get_module_info( local_dir_path: PATH_TYPE, remote_dir_path: PATH_TYPE, module_class: str, refresh_cache: bool = False, library_path: str = "library.json", disable_library_cache: bool = False, ) -> Dict: """Get module info.""" if isinstance(local_dir_path, str): local_dir_path = Path(local_dir_path) local_library_path = f"{local_dir_path}/{library_path}" module_id = None # e.g. `web/simple_web` extra_files = [] # e.g. `web/simple_web/utils.py` # Check cache first if not refresh_cache and os.path.exists(local_library_path): with open(local_library_path) as f: library = json.load(f) if module_class in library: module_id = library[module_class]["id"] extra_files = library[module_class].get("extra_files", []) # Fetch up-to-date library from remote repo if module_id not found if module_id is None: library_raw_content, _ = get_file_content( str(remote_dir_path), f"/{library_path}" ) library = json.loads(library_raw_content) if module_class not in library: raise ValueError("Loader class name not found in library") module_id = library[module_class]["id"] extra_files = library[module_class].get("extra_files", []) # create cache dir if needed local_library_dir = os.path.dirname(local_library_path) if not disable_library_cache: if not os.path.exists(local_library_dir): os.makedirs(local_library_dir) # Update cache with open(local_library_path, "w") as f: f.write(library_raw_content) if module_id is None: raise ValueError("Loader class name not found in library") return { "module_id": module_id, "extra_files": extra_files, } def download_module_and_reqs( local_dir_path: PATH_TYPE, remote_dir_path: PATH_TYPE, module_id: str, extra_files: List[str], refresh_cache: bool = False, use_gpt_index_import: bool = False, base_file_name: str = "base.py", override_path: bool = False, ) -> None: """Load module.""" if isinstance(local_dir_path, str): local_dir_path = Path(local_dir_path) if override_path: module_path = str(local_dir_path) else: module_path = f"{local_dir_path}/{module_id}" if refresh_cache or not os.path.exists(module_path): os.makedirs(module_path, exist_ok=True) basepy_raw_content, _ = get_file_content( str(remote_dir_path), f"/{module_id}/{base_file_name}" ) if use_gpt_index_import: basepy_raw_content = basepy_raw_content.replace( "import llama_index", "import llama_index" ) basepy_raw_content = basepy_raw_content.replace( "from llama_index", "from llama_index" ) with open(f"{module_path}/{base_file_name}", "w") as f: f.write(basepy_raw_content) # Get content of extra files if there are any # and write them under the loader directory for extra_file in extra_files: extra_file_raw_content, _ = get_file_content( str(remote_dir_path), f"/{module_id}/{extra_file}" ) # If the extra file is an __init__.py file, we need to # add the exports to the __init__.py file in the modules directory if extra_file == "__init__.py": loader_exports = get_exports(extra_file_raw_content) existing_exports = [] init_file_path = local_dir_path / "__init__.py" # if the __init__.py file do not exists, we need to create it mode = "a+" if not os.path.exists(init_file_path) else "r+" with open(init_file_path, mode) as f: f.write(f"from .{module_id} import {', '.join(loader_exports)}") existing_exports = get_exports(f.read()) rewrite_exports(existing_exports + loader_exports, str(local_dir_path)) with open(f"{module_path}/{extra_file}", "w") as f: f.write(extra_file_raw_content) # install requirements requirements_path = f"{local_dir_path}/requirements.txt" if not os.path.exists(requirements_path): # NOTE: need to check the status code response_txt, status_code = get_file_content( str(remote_dir_path), f"/{module_id}/requirements.txt" ) if status_code == 200: with open(requirements_path, "w") as f: f.write(response_txt) # Install dependencies if there are any and not already installed if os.path.exists(requirements_path): try: requirements = pkg_resources.parse_requirements( Path(requirements_path).open() ) pkg_resources.require([str(r) for r in requirements]) except DistributionNotFound: subprocess.check_call( [sys.executable, "-m", "pip", "install", "-r", requirements_path] ) def download_llama_module( module_class: str, llama_hub_url: str = LLAMA_HUB_URL, refresh_cache: bool = False, custom_dir: Optional[str] = None, custom_path: Optional[str] = None, library_path: str = "library.json", base_file_name: str = "base.py", use_gpt_index_import: bool = False, disable_library_cache: bool = False, override_path: bool = False, skip_load: bool = False, ) -> Any: """Download a module from LlamaHub. Can be a loader, tool, pack, or more. Args: loader_class: The name of the llama module class you want to download, such as `GmailOpenAIAgentPack`. refresh_cache: If true, the local cache will be skipped and the loader will be fetched directly from the remote repo. custom_dir: Custom dir name to download loader into (under parent folder). custom_path: Custom dirpath to download loader into. library_path: File name of the library file. use_gpt_index_import: If true, the loader files will use llama_index as the base dependency. By default (False), the loader files use llama_index as the base dependency. NOTE: this is a temporary workaround while we fully migrate all usages to llama_index. is_dataset: whether or not downloading a LlamaDataset Returns: A Loader, A Pack, An Agent, or A Dataset """ # create directory / get path dirpath = initialize_directory(custom_path=custom_path, custom_dir=custom_dir) # fetch info from library.json file module_info = get_module_info( local_dir_path=dirpath, remote_dir_path=llama_hub_url, module_class=module_class, refresh_cache=refresh_cache, library_path=library_path, disable_library_cache=disable_library_cache, ) module_id = module_info["module_id"] extra_files = module_info["extra_files"] # download the module, install requirements download_module_and_reqs( local_dir_path=dirpath, remote_dir_path=llama_hub_url, module_id=module_id, extra_files=extra_files, refresh_cache=refresh_cache, use_gpt_index_import=use_gpt_index_import, base_file_name=base_file_name, override_path=override_path, ) if skip_load: return None # loads the module into memory if override_path: path = f"{dirpath}/{base_file_name}" spec = util.spec_from_file_location("custom_module", location=path) if spec is None: raise ValueError(f"Could not find file: {path}.") else: path = f"{dirpath}/{module_id}/{base_file_name}" spec = util.spec_from_file_location("custom_module", location=path) if spec is None: raise ValueError(f"Could not find file: {path}.") module = util.module_from_spec(spec) spec.loader.exec_module(module) # type: ignore return getattr(module, module_class) def track_download(module_class: str, module_type: str) -> None: """Tracks number of downloads via Llamahub proxy. Args: module_class: The name of the llama module being downloaded, e.g.,`GmailOpenAIAgentPack`. module_type: Can be "loader", "tool", "llamapack", or "datasets" """ try: requests.post( LLAMAHUB_ANALYTICS_PROXY_SERVER, json={"type": module_type, "plugin": module_class}, ) except Exception as e: logger.info(f"Error tracking downloads for {module_class} : {e}")

[((637, 664), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (654, 664), False, 'import logging\n'), ((5550, 5583), 'os.path.exists', 'os.path.exists', (['requirements_path'], {}), '(requirements_path)\n', (5564, 5583), False, 'import os\n'), ((7432, 7500), 'llama_index.download.utils.initialize_directory', 'initialize_directory', ([], {'custom_path': 'custom_path', 'custom_dir': 'custom_dir'}), '(custom_path=custom_path, custom_dir=custom_dir)\n', (7452, 7500), False, 'from llama_index.download.utils import get_exports, get_file_content, initialize_directory, rewrite_exports\n'), ((8830, 8857), 'importlib.util.module_from_spec', 'util.module_from_spec', (['spec'], {}), '(spec)\n', (8851, 8857), False, 'from importlib import util\n'), ((1197, 1217), 'pathlib.Path', 'Path', (['local_dir_path'], {}), '(local_dir_path)\n', (1201, 1217), False, 'from pathlib import Path\n'), ((1434, 1468), 'os.path.exists', 'os.path.exists', (['local_library_path'], {}), '(local_library_path)\n', (1448, 1468), False, 'import os\n'), ((1938, 1969), 'json.loads', 'json.loads', (['library_raw_content'], {}), '(library_raw_content)\n', (1948, 1969), False, 'import json\n'), ((2263, 2298), 'os.path.dirname', 'os.path.dirname', (['local_library_path'], {}), '(local_library_path)\n', (2278, 2298), False, 'import os\n'), ((3131, 3151), 'pathlib.Path', 'Path', (['local_dir_path'], {}), '(local_dir_path)\n', (3135, 3151), False, 'from pathlib import Path\n'), ((3347, 3386), 'os.makedirs', 'os.makedirs', (['module_path'], {'exist_ok': '(True)'}), '(module_path, exist_ok=True)\n', (3358, 3386), False, 'import os\n'), ((5139, 5172), 'os.path.exists', 'os.path.exists', (['requirements_path'], {}), '(requirements_path)\n', (5153, 5172), False, 'import os\n'), ((8438, 8498), 'importlib.util.spec_from_file_location', 'util.spec_from_file_location', (['"""custom_module"""'], {'location': 'path'}), "('custom_module', location=path)\n", (8466, 8498), False, 'from importlib import util\n'), ((8668, 8728), 'importlib.util.spec_from_file_location', 'util.spec_from_file_location', (['"""custom_module"""'], {'location': 'path'}), "('custom_module', location=path)\n", (8696, 8728), False, 'from importlib import util\n'), ((9280, 9382), 'requests.post', 'requests.post', (['LLAMAHUB_ANALYTICS_PROXY_SERVER'], {'json': "{'type': module_type, 'plugin': module_class}"}), "(LLAMAHUB_ANALYTICS_PROXY_SERVER, json={'type': module_type,\n 'plugin': module_class})\n", (9293, 9382), False, 'import requests\n'), ((1536, 1548), 'json.load', 'json.load', (['f'], {}), '(f)\n', (1545, 1548), False, 'import json\n'), ((3310, 3337), 'os.path.exists', 'os.path.exists', (['module_path'], {}), '(module_path)\n', (3324, 3337), False, 'import os\n'), ((4385, 4420), 'llama_index.download.utils.get_exports', 'get_exports', (['extra_file_raw_content'], {}), '(extra_file_raw_content)\n', (4396, 4420), False, 'from llama_index.download.utils import get_exports, get_file_content, initialize_directory, rewrite_exports\n'), ((2356, 2389), 'os.path.exists', 'os.path.exists', (['local_library_dir'], {}), '(local_library_dir)\n', (2370, 2389), False, 'import os\n'), ((2407, 2437), 'os.makedirs', 'os.makedirs', (['local_library_dir'], {}), '(local_library_dir)\n', (2418, 2437), False, 'import os\n'), ((5835, 5927), 'subprocess.check_call', 'subprocess.check_call', (["[sys.executable, '-m', 'pip', 'install', '-r', requirements_path]"], {}), "([sys.executable, '-m', 'pip', 'install', '-r',\n requirements_path])\n", (5856, 5927), False, 'import subprocess\n'), ((4620, 4650), 'os.path.exists', 'os.path.exists', (['init_file_path'], {}), '(init_file_path)\n', (4634, 4650), False, 'import os\n'), ((5675, 5698), 'pathlib.Path', 'Path', (['requirements_path'], {}), '(requirements_path)\n', (5679, 5698), False, 'from pathlib import Path\n')]

import os import openai import logging import sys import llama_index from llama_index import ( VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext, ) from llama_index.llms import OpenAI import chromadb from llama_index.vector_stores import ChromaVectorStore from llama_index.embeddings import OpenAIEmbedding from trulens_eval import Tru from llama_index.query_engine import CitationQueryEngine import json openai.api_key = os.environ["OPENAI_API_KEY"] CUSTOM_QUERY = "First greet yourself and Send me a summary of the file. In your summary, make sure to mention the file location and the data name, also to have 10 bullet points. Each bullet point should be on a new row. Try to incorporate few key points from all the text. Do it step by step:" list_of_indices = [] tru = Tru() tru.reset_database() logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) def create_index(directory, unique_folder_id): llm = OpenAI(temperature=0.1, model="gpt-4-vision-preview", max_tokens=512) prompt_helper = PromptHelper( context_window=4096, num_output=256, chunk_overlap_ratio=0.1, chunk_size_limit=None, ) service_context = ServiceContext.from_defaults(llm=llm, prompt_helper=prompt_helper) documents = SimpleDirectoryReader(input_dir=directory).load_data() index = VectorStoreIndex.from_documents(documents, service_context=service_context) index.set_index_id(create_dynamic_vector_ids(unique_folder_id)) index.storage_context.persist(create_dynamic_storage_contexts(unique_folder_id)) a = index.index_struct_cls # Chroma vector store for easy indexing and retrieval db = chromadb.PersistentClient(path="./chroma_db") chroma_collection = db.get_or_create_collection("investment_ai") chroma_vector_store = ChromaVectorStore(chroma_collection=chroma_collection) chroma_storage_context = StorageContext.from_defaults( vector_store=chroma_vector_store ) chroma_index = VectorStoreIndex.from_documents( documents, storage_context=chroma_storage_context, service_context=service_context, ) print(chroma_index.storage_context.graph_store.get) return index def auto_summarization(unique_folder_id): dynamic_storage_context = create_dynamic_storage_contexts(unique_folder_id) dynamic_vector_id = create_dynamic_vector_ids(unique_folder_id) storage_context = StorageContext.from_defaults(persist_dir=dynamic_storage_context) # load index index = load_index_from_storage(storage_context, index_id=dynamic_vector_id) query_engine = index.as_query_engine(response_mode="compact", verbose=True) response = query_engine.query(CUSTOM_QUERY) return str(response.response) return str(response.response) def ask_question(query, unique_folder_id): dynamic_storage_context = create_dynamic_storage_contexts(unique_folder_id) dynamic_vector_id = create_dynamic_vector_ids(unique_folder_id) # rebuild storage context storage_context = StorageContext.from_defaults(persist_dir=dynamic_storage_context) # load index index = llama_index.indices.loading.load_index_from_storage( storage_context, index_id=dynamic_vector_id ) query_engine = CitationQueryEngine.from_args( index, similarity_top_k=3, citation_chunk_size=512, streaming=True ) response_stream = query_engine.query( "When a question is asked always and if it is a greeting please answer accordingly.If question is not about given data, say you only answer about given data. If the question is about the given data please eloborate more on details and answer human-like according to this question: " + query ) return response_stream def create_dynamic_storage_contexts(unique_folder_id): return "./storage_" + str(unique_folder_id) def create_dynamic_vector_ids(unique_folder_id): return "vector_index_" + str(unique_folder_id)

[((879, 884), 'trulens_eval.Tru', 'Tru', ([], {}), '()\n', (882, 884), False, 'from trulens_eval import Tru\n'), ((907, 965), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (926, 965), False, 'import logging\n'), ((997, 1037), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (1018, 1037), False, 'import logging\n'), ((1098, 1167), 'llama_index.llms.OpenAI', 'OpenAI', ([], {'temperature': '(0.1)', 'model': '"""gpt-4-vision-preview"""', 'max_tokens': '(512)'}), "(temperature=0.1, model='gpt-4-vision-preview', max_tokens=512)\n", (1104, 1167), False, 'from llama_index.llms import OpenAI\n'), ((1188, 1289), 'llama_index.PromptHelper', 'PromptHelper', ([], {'context_window': '(4096)', 'num_output': '(256)', 'chunk_overlap_ratio': '(0.1)', 'chunk_size_limit': 'None'}), '(context_window=4096, num_output=256, chunk_overlap_ratio=0.1,\n chunk_size_limit=None)\n', (1200, 1289), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((1348, 1414), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'prompt_helper': 'prompt_helper'}), '(llm=llm, prompt_helper=prompt_helper)\n', (1376, 1414), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((1500, 1575), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (1531, 1575), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((1828, 1873), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""./chroma_db"""'}), "(path='./chroma_db')\n", (1853, 1873), False, 'import chromadb\n'), ((1970, 2024), 'llama_index.vector_stores.ChromaVectorStore', 'ChromaVectorStore', ([], {'chroma_collection': 'chroma_collection'}), '(chroma_collection=chroma_collection)\n', (1987, 2024), False, 'from llama_index.vector_stores import ChromaVectorStore\n'), ((2055, 2117), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'chroma_vector_store'}), '(vector_store=chroma_vector_store)\n', (2083, 2117), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((2152, 2272), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'storage_context': 'chroma_storage_context', 'service_context': 'service_context'}), '(documents, storage_context=\n chroma_storage_context, service_context=service_context)\n', (2183, 2272), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((2586, 2651), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'dynamic_storage_context'}), '(persist_dir=dynamic_storage_context)\n', (2614, 2651), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((2681, 2749), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {'index_id': 'dynamic_vector_id'}), '(storage_context, index_id=dynamic_vector_id)\n', (2704, 2749), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((3192, 3257), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'dynamic_storage_context'}), '(persist_dir=dynamic_storage_context)\n', (3220, 3257), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n'), ((3287, 3387), 'llama_index.indices.loading.load_index_from_storage', 'llama_index.indices.loading.load_index_from_storage', (['storage_context'], {'index_id': 'dynamic_vector_id'}), '(storage_context,\n index_id=dynamic_vector_id)\n', (3338, 3387), False, 'import llama_index\n'), ((3417, 3518), 'llama_index.query_engine.CitationQueryEngine.from_args', 'CitationQueryEngine.from_args', (['index'], {'similarity_top_k': '(3)', 'citation_chunk_size': '(512)', 'streaming': '(True)'}), '(index, similarity_top_k=3,\n citation_chunk_size=512, streaming=True)\n', (3446, 3518), False, 'from llama_index.query_engine import CitationQueryEngine\n'), ((966, 985), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (983, 985), False, 'import logging\n'), ((1432, 1474), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': 'directory'}), '(input_dir=directory)\n', (1453, 1474), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, LLMPredictor, PromptHelper, ServiceContext\n')]

import streamlit as st import llama_index from llama_index import StorageContext, load_index_from_storage from llama_index.query_engine import RetrieverQueryEngine from llama_index.storage.docstore import SimpleDocumentStore from llama_index.vector_stores import SimpleVectorStore from llama_index.storage.index_store import SimpleIndexStore from llama_index import KeywordTableIndex from llama_index.indices.keyword_table import SimpleKeywordTableIndex from llama_index import ResponseSynthesizer from llama_index.indices.postprocessor import SimilarityPostprocessor from llama_index.retrievers import VectorIndexRetriever from llama_index.retrievers import ListIndexRetriever from llama_index.retrievers import TreeRootRetriever from llama_index.indices.keyword_table.retrievers import KeywordTableGPTRetriever from llama_index.indices.keyword_table import GPTSimpleKeywordTableIndex from llama_index.indices.keyword_table.retrievers import KeywordTableRAKERetriever from llama_index.indices.keyword_table.retrievers import KeywordTableSimpleRetriever from llama_index import Prompt from llama_index import LLMPredictor from langchain.chat_models import ChatOpenAI from llama_index import ServiceContext print("1") storage_context_1 = StorageContext.from_defaults( docstore=SimpleDocumentStore.from_persist_dir(persist_dir="vector_store"), vector_store=SimpleVectorStore.from_persist_dir(persist_dir="vector_store"), index_store=SimpleIndexStore.from_persist_dir(persist_dir="vector_store"), ) storage_context_2 = StorageContext.from_defaults( docstore=SimpleDocumentStore.from_persist_dir(persist_dir="table"), vector_store=SimpleVectorStore.from_persist_dir(persist_dir="table"), index_store=SimpleIndexStore.from_persist_dir(persist_dir="table"), ) storage_context_3 = StorageContext.from_defaults( docstore=SimpleDocumentStore.from_persist_dir(persist_dir="tree"), vector_store=SimpleVectorStore.from_persist_dir(persist_dir="tree"), index_store=SimpleIndexStore.from_persist_dir(persist_dir="tree"), ) storage_context_4 = StorageContext.from_defaults( docstore=SimpleDocumentStore.from_persist_dir(persist_dir="list"), vector_store=SimpleVectorStore.from_persist_dir(persist_dir="list"), index_store=SimpleIndexStore.from_persist_dir(persist_dir="list"), ) print("2") from llama_index import load_index_from_storage, load_indices_from_storage, load_graph_from_storage indices1 = load_index_from_storage(storage_context_1) indices2 = load_index_from_storage(storage_context_2) indices3 = load_index_from_storage(storage_context_3) indices4 = load_index_from_storage(storage_context_4) # indices1 = load_index_from_storage(storage_context="vector_store") index = [indices1, indices2, indices3, indices4] print("3") print("4") from llama_index.indices.response import BaseResponseBuilder # configure response synthesizer response_synthesizer = ResponseSynthesizer.from_args( # node_postprocessors=[ # ] ) print("5") TEMPLATE_STR = ( "We have provided context information below. \n" "---------------------\n" "{context_str}" "\n---------------------\n" "Given this information, please answer the question: {query_str}\n" ) QA_TEMPLATE = Prompt(TEMPLATE_STR) llm_predictor = LLMPredictor(llm=ChatOpenAI(temperature=0, model_name="gpt-3.5-turbo", streaming=True)) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, chunk_size=1024) query_engine1 = indices3.as_query_engine(service_context=service_context, text_qa_template=QA_TEMPLATE, similarity_top_k=3, streaming=True, ) response = query_engine1.query('How much package has government of india announced?') # print("7") str(response) print(response) # response.source_nodes print(response.source_nodes) ########## working ##########

[((2439, 2481), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context_1'], {}), '(storage_context_1)\n', (2462, 2481), False, 'from llama_index import load_index_from_storage, load_indices_from_storage, load_graph_from_storage\n'), ((2493, 2535), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context_2'], {}), '(storage_context_2)\n', (2516, 2535), False, 'from llama_index import load_index_from_storage, load_indices_from_storage, load_graph_from_storage\n'), ((2547, 2589), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context_3'], {}), '(storage_context_3)\n', (2570, 2589), False, 'from llama_index import load_index_from_storage, load_indices_from_storage, load_graph_from_storage\n'), ((2601, 2643), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context_4'], {}), '(storage_context_4)\n', (2624, 2643), False, 'from llama_index import load_index_from_storage, load_indices_from_storage, load_graph_from_storage\n'), ((2909, 2940), 'llama_index.ResponseSynthesizer.from_args', 'ResponseSynthesizer.from_args', ([], {}), '()\n', (2938, 2940), False, 'from llama_index import ResponseSynthesizer\n'), ((3238, 3258), 'llama_index.Prompt', 'Prompt', (['TEMPLATE_STR'], {}), '(TEMPLATE_STR)\n', (3244, 3258), False, 'from llama_index import Prompt\n'), ((3383, 3457), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'chunk_size': '(1024)'}), '(llm_predictor=llm_predictor, chunk_size=1024)\n', (3411, 3457), False, 'from llama_index import ServiceContext\n'), ((1282, 1346), 'llama_index.storage.docstore.SimpleDocumentStore.from_persist_dir', 'SimpleDocumentStore.from_persist_dir', ([], {'persist_dir': '"""vector_store"""'}), "(persist_dir='vector_store')\n", (1318, 1346), False, 'from llama_index.storage.docstore import SimpleDocumentStore\n'), ((1365, 1427), 'llama_index.vector_stores.SimpleVectorStore.from_persist_dir', 'SimpleVectorStore.from_persist_dir', ([], {'persist_dir': '"""vector_store"""'}), "(persist_dir='vector_store')\n", (1399, 1427), False, 'from llama_index.vector_stores import SimpleVectorStore\n'), ((1445, 1506), 'llama_index.storage.index_store.SimpleIndexStore.from_persist_dir', 'SimpleIndexStore.from_persist_dir', ([], {'persist_dir': '"""vector_store"""'}), "(persist_dir='vector_store')\n", (1478, 1506), False, 'from llama_index.storage.index_store import SimpleIndexStore\n'), ((1574, 1631), 'llama_index.storage.docstore.SimpleDocumentStore.from_persist_dir', 'SimpleDocumentStore.from_persist_dir', ([], {'persist_dir': '"""table"""'}), "(persist_dir='table')\n", (1610, 1631), False, 'from llama_index.storage.docstore import SimpleDocumentStore\n'), ((1650, 1705), 'llama_index.vector_stores.SimpleVectorStore.from_persist_dir', 'SimpleVectorStore.from_persist_dir', ([], {'persist_dir': '"""table"""'}), "(persist_dir='table')\n", (1684, 1705), False, 'from llama_index.vector_stores import SimpleVectorStore\n'), ((1723, 1777), 'llama_index.storage.index_store.SimpleIndexStore.from_persist_dir', 'SimpleIndexStore.from_persist_dir', ([], {'persist_dir': '"""table"""'}), "(persist_dir='table')\n", (1756, 1777), False, 'from llama_index.storage.index_store import SimpleIndexStore\n'), ((1844, 1900), 'llama_index.storage.docstore.SimpleDocumentStore.from_persist_dir', 'SimpleDocumentStore.from_persist_dir', ([], {'persist_dir': '"""tree"""'}), "(persist_dir='tree')\n", (1880, 1900), False, 'from llama_index.storage.docstore import SimpleDocumentStore\n'), ((1919, 1973), 'llama_index.vector_stores.SimpleVectorStore.from_persist_dir', 'SimpleVectorStore.from_persist_dir', ([], {'persist_dir': '"""tree"""'}), "(persist_dir='tree')\n", (1953, 1973), False, 'from llama_index.vector_stores import SimpleVectorStore\n'), ((1991, 2044), 'llama_index.storage.index_store.SimpleIndexStore.from_persist_dir', 'SimpleIndexStore.from_persist_dir', ([], {'persist_dir': '"""tree"""'}), "(persist_dir='tree')\n", (2024, 2044), False, 'from llama_index.storage.index_store import SimpleIndexStore\n'), ((2111, 2167), 'llama_index.storage.docstore.SimpleDocumentStore.from_persist_dir', 'SimpleDocumentStore.from_persist_dir', ([], {'persist_dir': '"""list"""'}), "(persist_dir='list')\n", (2147, 2167), False, 'from llama_index.storage.docstore import SimpleDocumentStore\n'), ((2186, 2240), 'llama_index.vector_stores.SimpleVectorStore.from_persist_dir', 'SimpleVectorStore.from_persist_dir', ([], {'persist_dir': '"""list"""'}), "(persist_dir='list')\n", (2220, 2240), False, 'from llama_index.vector_stores import SimpleVectorStore\n'), ((2258, 2311), 'llama_index.storage.index_store.SimpleIndexStore.from_persist_dir', 'SimpleIndexStore.from_persist_dir', ([], {'persist_dir': '"""list"""'}), "(persist_dir='list')\n", (2291, 2311), False, 'from llama_index.storage.index_store import SimpleIndexStore\n'), ((3293, 3362), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'model_name': '"""gpt-3.5-turbo"""', 'streaming': '(True)'}), "(temperature=0, model_name='gpt-3.5-turbo', streaming=True)\n", (3303, 3362), False, 'from langchain.chat_models import ChatOpenAI\n')]

# https://www.youtube.com/watch?v=oDzWsynpOyI import logging import sys import os from dotenv import load_dotenv load_dotenv() from llama_index import ( VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document, ) import json import llama_index from llama_index.llms import AzureOpenAI from llama_index.node_parser import ( SentenceWindowNodeParser, HierarchicalNodeParser, get_leaf_nodes, ) from llama_index.text_splitter import SentenceSplitter from llama_index.embeddings import AzureOpenAIEmbedding, HuggingFaceEmbedding from llama_index.schema import MetadataMode from llama_index.postprocessor import ( MetadataReplacementPostProcessor, SimilarityPostprocessor, ) from llama_index import set_global_service_context from llama_index.llms.types import ChatMessage import chromadb from llama_index.vector_stores import ChromaVectorStore ### THE LLM api_key = os.getenv("AZURE_OPENAI_API_KEY") azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT") api_version = os.getenv("OPENAI_API_VERSION") llm = AzureOpenAI( engine="chat", temperature=0.1, api_key=api_key, azure_endpoint=azure_endpoint, api_version=api_version, ) embed_model = AzureOpenAIEmbedding( azure_deployment="embeddings", api_key=api_key, azure_endpoint=azure_endpoint, api_version=api_version, ) def _print_docs(docs): # inspect documents print("length of documents: ", str(len(docs))) print("-----") print(docs) print("-----Metadata-----") for doc in docs: print(doc.metadata) def _print_nodes(name, nodes): print("-----" + name + "-----") counter = 1 for node in nodes: print(f"-----Node {counter}") dict_node = dict(node) print(dict_node) counter += 1 print("-----") def _create_text_qa_template(): from llama_index.llms import ChatMessage, MessageRole from llama_index.prompts import ChatPromptTemplate # Text QA Prompt chat_text_qa_msgs = [ ChatMessage( role=MessageRole.SYSTEM, content=( "You are an helpful chat assistant. You are here to help the user.Answer must be in the original language." ), ), ChatMessage( role=MessageRole.USER, content=( "Context information is below.\n" "---------------------\n" "{context_str}\n" "---------------------\n" "Given the context information and not prior knowledge," "answer the question: {query_str}\n" ), ), ] text_qa_template = ChatPromptTemplate(chat_text_qa_msgs) return text_qa_template def _create_refine_template(): from llama_index.llms import ChatMessage, MessageRole from llama_index.prompts import ChatPromptTemplate # Refine Prompt chat_refine_msgs = [ ChatMessage( role=MessageRole.SYSTEM, content=("Always answer the question, even if the context isn't helpful."), ), ChatMessage( role=MessageRole.USER, content=( "We have the opportunity to refine the original answer " "(only if needed) with some more context below.\n" "------------\n" "{context_msg}\n" "------------\n" "Given the new context, refine the original answer to better " "answer the question: {query_str}. " "If the context isn't useful, output the original answer again.\n" "Original Answer: {existing_answer}" ), ), ] refine_template = ChatPromptTemplate(chat_refine_msgs) return refine_template def create_window_nodes(path="./sample-docs/"): # get the file documents = SimpleDirectoryReader(path).load_data() # _print_docs(documents) sentence_node_parser = SentenceWindowNodeParser.from_defaults( window_size=3, window_metadata_key="window", original_text_metadata_key="original_text", ) window_nodes = sentence_node_parser.get_nodes_from_documents(documents) # _print_nodes("WINDOW NODES", window_nodes) return window_nodes def create_base_nodes(path="./sample-docs/"): # get the file documents = SimpleDirectoryReader(path).load_data() # _print_docs(documents) base_node_parser = SentenceSplitter() base_nodes = base_node_parser.get_nodes_from_documents(documents) # _print_nodes("BASE NODES", base_nodes) return base_nodes def save_on_chroma_and_get_index(nodes, collection_name): ### CREATE THE VECTOR STORES ### SAVING VECTORS ON DISK db = chromadb.PersistentClient(path="./chroma_db") vector_collection = db.get_or_create_collection(collection_name) vector_store = ChromaVectorStore(chroma_collection=vector_collection) storage_context = StorageContext.from_defaults(vector_store=vector_store) ctx = ServiceContext.from_defaults( llm=llm, embed_model=embed_model, node_parser=nodes ) index = VectorStoreIndex( nodes, storage_context=storage_context, service_context=ctx ) return index def get_index(collection_name): db2 = chromadb.PersistentClient(path="./chroma_db") service_context = ServiceContext.from_defaults(embed_model=embed_model, llm=llm) collection = db2.get_or_create_collection(collection_name) vector_store = ChromaVectorStore(chroma_collection=collection) index = VectorStoreIndex.from_vector_store( vector_store, service_context=service_context, ) return index def run_window_index_sample(question): window_index = get_index("window-detrazioni") text_qa_template = _create_text_qa_template() refine_template = _create_refine_template() window_query_engine = window_index.as_query_engine( similarity_top_k=5, verbose=True, text_qa_template=text_qa_template, # refine_template=refine_template, node_postprocessor=MetadataReplacementPostProcessor( target_metadata_key="window", ) # node_postprocessors=[ # SimilarityPostprocessor(similarity_cutoff=0.7), # MetadataReplacementPostProcessor( # target_metadata_key="window", # ), # ], ) base_response = window_query_engine.query(question) print(base_response) def run_base_index_sample(question): base_index = get_index("base-detrazioni") text_qa_template = _create_text_qa_template() refine_template = _create_refine_template() # Query engine # base_query_engine = base_index.as_query_engine( # verbose=True, # text_qa_template=text_qa_template, # # refine_template=refine_template, # ) # chat engine base_query_engine = base_index.as_chat_engine() base_response = base_query_engine.chat(question) print(base_response) if __name__ == "__main__": logging.basicConfig(stream=sys.stdout, level=logging.INFO) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) # windows_node = create_window_nodes() # window_index = save_on_chroma_and_get_index(windows_node, "window-detrazioni") ### INFERENCE question = "question!!!" # window_index = run_window_index_sample(question=question) base_index = run_base_index_sample(question=question) # ### TODO : TO INVESTIGATE # ### SAVING INDEX DEFINITION ON DISK # ### this is useful to avoid having to recreate the index every time so we can save money # ### from embedding calls # window_index.storage_context.persist(persist_dir="./window-indexes") # base_index.storage_context.persist(persist_dir="./base-indexes") # ### RELOAD INDEXES FROM DISK # SC_retrieved_window = storage_context_window.from_defaults( # persist_dir="./window-indexes" # ) # SC_retrieved_base = storage_context_base.from_defaults(persist_dir="./base-indexes") # retrieved_window_index = load_index_from_storage(SC_retrieved_window) # retrieved_base_index = load_index_from_storage(SC_retrieved_base)

[((116, 129), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (127, 129), False, 'from dotenv import load_dotenv\n'), ((963, 996), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_API_KEY"""'], {}), "('AZURE_OPENAI_API_KEY')\n", (972, 996), False, 'import os\n'), ((1014, 1048), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_ENDPOINT"""'], {}), "('AZURE_OPENAI_ENDPOINT')\n", (1023, 1048), False, 'import os\n'), ((1063, 1094), 'os.getenv', 'os.getenv', (['"""OPENAI_API_VERSION"""'], {}), "('OPENAI_API_VERSION')\n", (1072, 1094), False, 'import os\n'), ((1102, 1223), 'llama_index.llms.AzureOpenAI', 'AzureOpenAI', ([], {'engine': '"""chat"""', 'temperature': '(0.1)', 'api_key': 'api_key', 'azure_endpoint': 'azure_endpoint', 'api_version': 'api_version'}), "(engine='chat', temperature=0.1, api_key=api_key, azure_endpoint\n =azure_endpoint, api_version=api_version)\n", (1113, 1223), False, 'from llama_index.llms import AzureOpenAI\n'), ((1258, 1386), 'llama_index.embeddings.AzureOpenAIEmbedding', 'AzureOpenAIEmbedding', ([], {'azure_deployment': '"""embeddings"""', 'api_key': 'api_key', 'azure_endpoint': 'azure_endpoint', 'api_version': 'api_version'}), "(azure_deployment='embeddings', api_key=api_key,\n azure_endpoint=azure_endpoint, api_version=api_version)\n", (1278, 1386), False, 'from llama_index.embeddings import AzureOpenAIEmbedding, HuggingFaceEmbedding\n'), ((2716, 2753), 'llama_index.prompts.ChatPromptTemplate', 'ChatPromptTemplate', (['chat_text_qa_msgs'], {}), '(chat_text_qa_msgs)\n', (2734, 2753), False, 'from llama_index.prompts import ChatPromptTemplate\n'), ((3774, 3810), 'llama_index.prompts.ChatPromptTemplate', 'ChatPromptTemplate', (['chat_refine_msgs'], {}), '(chat_refine_msgs)\n', (3792, 3810), False, 'from llama_index.prompts import ChatPromptTemplate\n'), ((4020, 4152), 'llama_index.node_parser.SentenceWindowNodeParser.from_defaults', 'SentenceWindowNodeParser.from_defaults', ([], {'window_size': '(3)', 'window_metadata_key': '"""window"""', 'original_text_metadata_key': '"""original_text"""'}), "(window_size=3, window_metadata_key=\n 'window', original_text_metadata_key='original_text')\n", (4058, 4152), False, 'from llama_index.node_parser import SentenceWindowNodeParser, HierarchicalNodeParser, get_leaf_nodes\n'), ((4505, 4523), 'llama_index.text_splitter.SentenceSplitter', 'SentenceSplitter', ([], {}), '()\n', (4521, 4523), False, 'from llama_index.text_splitter import SentenceSplitter\n'), ((4796, 4841), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""./chroma_db"""'}), "(path='./chroma_db')\n", (4821, 4841), False, 'import chromadb\n'), ((4931, 4985), 'llama_index.vector_stores.ChromaVectorStore', 'ChromaVectorStore', ([], {'chroma_collection': 'vector_collection'}), '(chroma_collection=vector_collection)\n', (4948, 4985), False, 'from llama_index.vector_stores import ChromaVectorStore\n'), ((5008, 5063), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (5036, 5063), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document\n'), ((5074, 5160), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': 'embed_model', 'node_parser': 'nodes'}), '(llm=llm, embed_model=embed_model, node_parser=\n nodes)\n', (5102, 5160), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document\n'), ((5183, 5260), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', (['nodes'], {'storage_context': 'storage_context', 'service_context': 'ctx'}), '(nodes, storage_context=storage_context, service_context=ctx)\n', (5199, 5260), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document\n'), ((5337, 5382), 'chromadb.PersistentClient', 'chromadb.PersistentClient', ([], {'path': '"""./chroma_db"""'}), "(path='./chroma_db')\n", (5362, 5382), False, 'import chromadb\n'), ((5405, 5467), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'embed_model': 'embed_model', 'llm': 'llm'}), '(embed_model=embed_model, llm=llm)\n', (5433, 5467), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document\n'), ((5551, 5598), 'llama_index.vector_stores.ChromaVectorStore', 'ChromaVectorStore', ([], {'chroma_collection': 'collection'}), '(chroma_collection=collection)\n', (5568, 5598), False, 'from llama_index.vector_stores import ChromaVectorStore\n'), ((5611, 5697), 'llama_index.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', (['vector_store'], {'service_context': 'service_context'}), '(vector_store, service_context=\n service_context)\n', (5645, 5697), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document\n'), ((7100, 7158), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (7119, 7158), False, 'import logging\n'), ((2067, 2230), 'llama_index.llms.ChatMessage', 'ChatMessage', ([], {'role': 'MessageRole.SYSTEM', 'content': '"""You are an helpful chat assistant. You are here to help the user.Answer must be in the original language."""'}), "(role=MessageRole.SYSTEM, content=\n 'You are an helpful chat assistant. You are here to help the user.Answer must be in the original language.'\n )\n", (2078, 2230), False, 'from llama_index.llms import ChatMessage, MessageRole\n'), ((2297, 2532), 'llama_index.llms.ChatMessage', 'ChatMessage', ([], {'role': 'MessageRole.USER', 'content': '"""Context information is below.\n---------------------\n{context_str}\n---------------------\nGiven the context information and not prior knowledge,answer the question: {query_str}\n"""'}), '(role=MessageRole.USER, content=\n """Context information is below.\n---------------------\n{context_str}\n---------------------\nGiven the context information and not prior knowledge,answer the question: {query_str}\n"""\n )\n', (2308, 2532), False, 'from llama_index.llms import ChatMessage, MessageRole\n'), ((2984, 3099), 'llama_index.llms.ChatMessage', 'ChatMessage', ([], {'role': 'MessageRole.SYSTEM', 'content': '"""Always answer the question, even if the context isn\'t helpful."""'}), '(role=MessageRole.SYSTEM, content=\n "Always answer the question, even if the context isn\'t helpful.")\n', (2995, 3099), False, 'from llama_index.llms import ChatMessage, MessageRole\n'), ((3141, 3533), 'llama_index.llms.ChatMessage', 'ChatMessage', ([], {'role': 'MessageRole.USER', 'content': '"""We have the opportunity to refine the original answer (only if needed) with some more context below.\n------------\n{context_msg}\n------------\nGiven the new context, refine the original answer to better answer the question: {query_str}. If the context isn\'t useful, output the original answer again.\nOriginal Answer: {existing_answer}"""'}), '(role=MessageRole.USER, content=\n """We have the opportunity to refine the original answer (only if needed) with some more context below.\n------------\n{context_msg}\n------------\nGiven the new context, refine the original answer to better answer the question: {query_str}. If the context isn\'t useful, output the original answer again.\nOriginal Answer: {existing_answer}"""\n )\n', (3152, 3533), False, 'from llama_index.llms import ChatMessage, MessageRole\n'), ((7194, 7234), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (7215, 7234), False, 'import logging\n'), ((3923, 3950), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['path'], {}), '(path)\n', (3944, 3950), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document\n'), ((4412, 4439), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['path'], {}), '(path)\n', (4433, 4439), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, StorageContext, ServiceContext, Document\n'), ((6143, 6205), 'llama_index.postprocessor.MetadataReplacementPostProcessor', 'MetadataReplacementPostProcessor', ([], {'target_metadata_key': '"""window"""'}), "(target_metadata_key='window')\n", (6175, 6205), False, 'from llama_index.postprocessor import MetadataReplacementPostProcessor, SimilarityPostprocessor\n'), ((7163, 7182), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (7180, 7182), False, 'import logging\n')]

from importlib import metadata from pathlib import WindowsPath from re import sub from llama_index import ( ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context, ) import llama_index from llama_index.embeddings import HuggingFaceEmbedding from llama_index.schema import TextNode, MetadataMode from llama_index.vector_stores import MilvusVectorStore from llama_index.readers import SimpleDirectoryReader from llama_index.node_parser import SentenceWindowNodeParser, SentenceSplitter, SimpleNodeParser from llama_index.postprocessor import ( SimilarityPostprocessor, MetadataReplacementPostProcessor, ) from milvus import default_server import os from typing import List, Dict, Any, Optional from chatbot.common import DATA_PATH, EMBEDDING_DIM, EMBEDDING_MODEL, SIMILARITY_SEARCH_THRESHOLD, path_leaf, subjects, PathSep, debug class AugmentedIngestPipeline: def __init__( self, data_dir_path: str, service_context: ServiceContext, ) -> None: self.data_dir = data_dir_path self.service_ctx = service_context self.embed_model = self.service_ctx.embed_model self.vector_indexes = {} self.metadata_fn = lambda x: {"title": x.replace("_", " ")} self.node_parser = SentenceWindowNodeParser.from_defaults( window_size=3, window_metadata_key="window", original_text_metadata_key="original_text", include_metadata=True, ) self.create = False def _load_data(self, path): docs = SimpleDirectoryReader( path, file_metadata=self.metadata_fn, filename_as_id=True ).load_data() return docs def _make_nodes(self, docs): nodes = self.node_parser.get_nodes_from_documents(docs, show_progress=debug) return nodes def _insert_into_vectorstore(self, subject, nodes, create=False): collection_name = f"augmentED_{subject}" vector_store = MilvusVectorStore( dim=EMBEDDING_DIM, host="127.0.0.1", port=default_server.listen_port, collection_name=collection_name, overwrite=create, ) storage_ctx = StorageContext.from_defaults(vector_store=vector_store) self.vector_indexes[subject] = VectorStoreIndex( nodes=nodes, service_context=self.service_ctx, storage_context=storage_ctx, ) def _load_vectorstore(self, subject): collection_name = f"augmentED_{subject}" vector_store = MilvusVectorStore( dim=EMBEDDING_DIM, host="127.0.0.1", port=default_server.listen_port, collection_name=collection_name, overwrite=False ) storage_ctx = StorageContext.from_defaults(vector_store=vector_store) self.vector_indexes[subject] = VectorStoreIndex.from_vector_store( vector_store=vector_store, service_context=self.service_ctx, storage_context=storage_ctx, ) def _get_subject_query_engine(self, subject): query_engine = self.vector_indexes[subject].as_query_engine( similarity_top_k=3, node_postprocessors=[ SimilarityPostprocessor(similarity_cutoff=SIMILARITY_SEARCH_THRESHOLD), MetadataReplacementPostProcessor(target_metadata_key="window") ], ) return query_engine def _get_subject_chat_engine(self, subject): query_engine = self.vector_indexes[subject].as_chat_engine( mode="context", similarity_top_k=2, node_postprocessors=[ SimilarityPostprocessor(similarity_cutoff=SIMILARITY_SEARCH_THRESHOLD), MetadataReplacementPostProcessor(target_metadata_key="window") ], ) return query_engine def run_pipeline(self, create=False): self.create = create if self.create: self.one_giant_index_nodes = [] self.all_docs = [] for subject in subjects: path = self.data_dir + PathSep + subjects[subject] docs = self._load_data(path) nodes = self._make_nodes(docs) self._insert_into_vectorstore(subject=subject, nodes=nodes) self.one_giant_index_nodes.extend(nodes) self.all_docs.extend(docs) self._insert_into_vectorstore( subject="OneGiantIndex", nodes=self.one_giant_index_nodes, create=self.create ) else: for subject in subjects: self._load_vectorstore(subject) self._load_vectorstore("OneGiantIndex") self.one_giant_index = self.vector_indexes["OneGiantIndex"] self.query_everything = self._get_subject_query_engine("OneGiantIndex") def search_one_giant_index( self, query, top_k=10, replace_with_meta=True, metadata_key="title", ): retr = self.one_giant_index.as_retriever( similarity_top_k=top_k, ) answers = retr.retrieve(query) if replace_with_meta: return list(set(map(lambda x: x.metadata[metadata_key], answers))) else: return list( map(lambda x: x.get_content(metadata_mode=MetadataMode.LLM), answers) ) def query_one_file(self,file_path): docs = SimpleDirectoryReader( input_files=[file_path], file_metadata=self.metadata_fn, filename_as_id=True ).load_data() nodes = self._make_nodes(docs) self._insert_into_vectorstore("UserUploadedDocument", nodes) self._insert_into_vectorstore("OneGiantIndex", nodes) return self._get_subject_query_engine("UserUploadedDocument") class SimpleIngestPipeline: def __init__( self, data_dir_path: str, service_context: ServiceContext, create=False ) -> None: self.data_dir = data_dir_path self.service_ctx = service_context self.embed_model = self.service_ctx.embed_model self.vector_indexes = {} self.metadata_fn = lambda x: {"title": path_leaf(x)} self.node_parser = SimpleNodeParser(chunk_size=512) self.create = create def _load_data(self, path): docs = SimpleDirectoryReader( path, file_metadata=self.metadata_fn, filename_as_id=True ).load_data() return docs def _make_nodes(self, docs): nodes = self.node_parser.get_nodes_from_documents(docs, show_progress=debug) return nodes def _insert_into_vectorstore(self, subject, nodes, create=False): collection_name = f"augmentED_{subject}" vector_store = MilvusVectorStore( dim=EMBEDDING_DIM, host="127.0.0.1", port=default_server.listen_port, collection_name=collection_name, overwrite=create, ) storage_ctx = StorageContext.from_defaults(vector_store=vector_store) self.vector_indexes[subject] = VectorStoreIndex( nodes=nodes, service_context=self.service_ctx, storage_context=storage_ctx, ) def _load_vectorstore(self, subject): collection_name = f"augmentED_{subject}" vector_store = MilvusVectorStore( dim=EMBEDDING_DIM, host="127.0.0.1", port=default_server.listen_port, collection_name=collection_name, overwrite=False ) storage_ctx = StorageContext.from_defaults(vector_store=vector_store) self.vector_indexes[subject] = VectorStoreIndex.from_vector_store( vector_store=vector_store, service_context=self.service_ctx, storage_context=storage_ctx, ) def _get_subject_query_engine(self, subject) -> Dict: query_engine = self.vector_indexes[subject].as_query_engine( similarity_top_k=3, node_postprocessors=[ MetadataReplacementPostProcessor(target_metadata_key="window") ], ) return query_engine def run_pipeline(self): if self.create: self.one_giant_index_nodes = [] self.all_docs = [] for subject in subjects: path = self.data_dir + PathSep + subjects[subject] docs = self._load_data(path) nodes = self._make_nodes(docs) self._insert_into_vectorstore(subject=subject, nodes=nodes) self.one_giant_index_nodes.extend(nodes) self.all_docs.extend(docs) self._insert_into_vectorstore( subject="OneGiantIndex", nodes=self.one_giant_index_nodes, create=self.create ) else: for subject in subjects: self._load_vectorstore(subject) self._load_vectorstore("OneGiantIndex") self.one_giant_index = self.vector_indexes["OneGiantIndex"] if __name__ == "__main__": pipe = AugmentedIngestPipeline( data_dir_path=DATA_PATH, service_context=ServiceContext.from_defaults( llm=None, embed_model=HuggingFaceEmbedding(EMBEDDING_MODEL) ), ) pipe.run_pipeline(create=True)

[((1300, 1460), 'llama_index.node_parser.SentenceWindowNodeParser.from_defaults', 'SentenceWindowNodeParser.from_defaults', ([], {'window_size': '(3)', 'window_metadata_key': '"""window"""', 'original_text_metadata_key': '"""original_text"""', 'include_metadata': '(True)'}), "(window_size=3, window_metadata_key=\n 'window', original_text_metadata_key='original_text', include_metadata=True\n )\n", (1338, 1460), False, 'from llama_index.node_parser import SentenceWindowNodeParser, SentenceSplitter, SimpleNodeParser\n'), ((2004, 2147), 'llama_index.vector_stores.MilvusVectorStore', 'MilvusVectorStore', ([], {'dim': 'EMBEDDING_DIM', 'host': '"""127.0.0.1"""', 'port': 'default_server.listen_port', 'collection_name': 'collection_name', 'overwrite': 'create'}), "(dim=EMBEDDING_DIM, host='127.0.0.1', port=default_server.\n listen_port, collection_name=collection_name, overwrite=create)\n", (2021, 2147), False, 'from llama_index.vector_stores import MilvusVectorStore\n'), ((2237, 2292), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (2265, 2292), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((2333, 2429), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', ([], {'nodes': 'nodes', 'service_context': 'self.service_ctx', 'storage_context': 'storage_ctx'}), '(nodes=nodes, service_context=self.service_ctx,\n storage_context=storage_ctx)\n', (2349, 2429), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((2588, 2730), 'llama_index.vector_stores.MilvusVectorStore', 'MilvusVectorStore', ([], {'dim': 'EMBEDDING_DIM', 'host': '"""127.0.0.1"""', 'port': 'default_server.listen_port', 'collection_name': 'collection_name', 'overwrite': '(False)'}), "(dim=EMBEDDING_DIM, host='127.0.0.1', port=default_server.\n listen_port, collection_name=collection_name, overwrite=False)\n", (2605, 2730), False, 'from llama_index.vector_stores import MilvusVectorStore\n'), ((2819, 2874), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (2847, 2874), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((2915, 3043), 'llama_index.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', ([], {'vector_store': 'vector_store', 'service_context': 'self.service_ctx', 'storage_context': 'storage_ctx'}), '(vector_store=vector_store,\n service_context=self.service_ctx, storage_context=storage_ctx)\n', (2949, 3043), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((6295, 6327), 'llama_index.node_parser.SimpleNodeParser', 'SimpleNodeParser', ([], {'chunk_size': '(512)'}), '(chunk_size=512)\n', (6311, 6327), False, 'from llama_index.node_parser import SentenceWindowNodeParser, SentenceSplitter, SimpleNodeParser\n'), ((6823, 6966), 'llama_index.vector_stores.MilvusVectorStore', 'MilvusVectorStore', ([], {'dim': 'EMBEDDING_DIM', 'host': '"""127.0.0.1"""', 'port': 'default_server.listen_port', 'collection_name': 'collection_name', 'overwrite': 'create'}), "(dim=EMBEDDING_DIM, host='127.0.0.1', port=default_server.\n listen_port, collection_name=collection_name, overwrite=create)\n", (6840, 6966), False, 'from llama_index.vector_stores import MilvusVectorStore\n'), ((7056, 7111), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (7084, 7111), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((7152, 7248), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', ([], {'nodes': 'nodes', 'service_context': 'self.service_ctx', 'storage_context': 'storage_ctx'}), '(nodes=nodes, service_context=self.service_ctx,\n storage_context=storage_ctx)\n', (7168, 7248), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((7407, 7549), 'llama_index.vector_stores.MilvusVectorStore', 'MilvusVectorStore', ([], {'dim': 'EMBEDDING_DIM', 'host': '"""127.0.0.1"""', 'port': 'default_server.listen_port', 'collection_name': 'collection_name', 'overwrite': '(False)'}), "(dim=EMBEDDING_DIM, host='127.0.0.1', port=default_server.\n listen_port, collection_name=collection_name, overwrite=False)\n", (7424, 7549), False, 'from llama_index.vector_stores import MilvusVectorStore\n'), ((7638, 7693), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (7666, 7693), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((7734, 7862), 'llama_index.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', ([], {'vector_store': 'vector_store', 'service_context': 'self.service_ctx', 'storage_context': 'storage_ctx'}), '(vector_store=vector_store,\n service_context=self.service_ctx, storage_context=storage_ctx)\n', (7768, 7862), False, 'from llama_index import ServiceContext, VectorStoreIndex, StorageContext, load_index_from_storage, global_service_context\n'), ((1586, 1671), 'llama_index.readers.SimpleDirectoryReader', 'SimpleDirectoryReader', (['path'], {'file_metadata': 'self.metadata_fn', 'filename_as_id': '(True)'}), '(path, file_metadata=self.metadata_fn, filename_as_id=True\n )\n', (1607, 1671), False, 'from llama_index.readers import SimpleDirectoryReader\n'), ((5516, 5620), 'llama_index.readers.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_files': '[file_path]', 'file_metadata': 'self.metadata_fn', 'filename_as_id': '(True)'}), '(input_files=[file_path], file_metadata=self.\n metadata_fn, filename_as_id=True)\n', (5537, 5620), False, 'from llama_index.readers import SimpleDirectoryReader\n'), ((6254, 6266), 'chatbot.common.path_leaf', 'path_leaf', (['x'], {}), '(x)\n', (6263, 6266), False, 'from chatbot.common import DATA_PATH, EMBEDDING_DIM, EMBEDDING_MODEL, SIMILARITY_SEARCH_THRESHOLD, path_leaf, subjects, PathSep, debug\n'), ((6405, 6490), 'llama_index.readers.SimpleDirectoryReader', 'SimpleDirectoryReader', (['path'], {'file_metadata': 'self.metadata_fn', 'filename_as_id': '(True)'}), '(path, file_metadata=self.metadata_fn, filename_as_id=True\n )\n', (6426, 6490), False, 'from llama_index.readers import SimpleDirectoryReader\n'), ((3289, 3359), 'llama_index.postprocessor.SimilarityPostprocessor', 'SimilarityPostprocessor', ([], {'similarity_cutoff': 'SIMILARITY_SEARCH_THRESHOLD'}), '(similarity_cutoff=SIMILARITY_SEARCH_THRESHOLD)\n', (3312, 3359), False, 'from llama_index.postprocessor import SimilarityPostprocessor, MetadataReplacementPostProcessor\n'), ((3377, 3439), 'llama_index.postprocessor.MetadataReplacementPostProcessor', 'MetadataReplacementPostProcessor', ([], {'target_metadata_key': '"""window"""'}), "(target_metadata_key='window')\n", (3409, 3439), False, 'from llama_index.postprocessor import SimilarityPostprocessor, MetadataReplacementPostProcessor\n'), ((3721, 3791), 'llama_index.postprocessor.SimilarityPostprocessor', 'SimilarityPostprocessor', ([], {'similarity_cutoff': 'SIMILARITY_SEARCH_THRESHOLD'}), '(similarity_cutoff=SIMILARITY_SEARCH_THRESHOLD)\n', (3744, 3791), False, 'from llama_index.postprocessor import SimilarityPostprocessor, MetadataReplacementPostProcessor\n'), ((3809, 3871), 'llama_index.postprocessor.MetadataReplacementPostProcessor', 'MetadataReplacementPostProcessor', ([], {'target_metadata_key': '"""window"""'}), "(target_metadata_key='window')\n", (3841, 3871), False, 'from llama_index.postprocessor import SimilarityPostprocessor, MetadataReplacementPostProcessor\n'), ((8117, 8179), 'llama_index.postprocessor.MetadataReplacementPostProcessor', 'MetadataReplacementPostProcessor', ([], {'target_metadata_key': '"""window"""'}), "(target_metadata_key='window')\n", (8149, 8179), False, 'from llama_index.postprocessor import SimilarityPostprocessor, MetadataReplacementPostProcessor\n'), ((9294, 9331), 'llama_index.embeddings.HuggingFaceEmbedding', 'HuggingFaceEmbedding', (['EMBEDDING_MODEL'], {}), '(EMBEDDING_MODEL)\n', (9314, 9331), False, 'from llama_index.embeddings import HuggingFaceEmbedding\n')]

get_ipython().run_line_magic('pip', 'install llama-hub-llama-packs-agents-llm-compiler-step') get_ipython().run_line_magic('pip', 'install llama-index-readers-wikipedia') get_ipython().run_line_magic('pip', 'install llama-index-llms-openai') import phoenix as px px.launch_app() import llama_index.core llama_index.core.set_global_handler("arize_phoenix") import nest_asyncio nest_asyncio.apply() from llama_index.packs.agents.llm_compiler.step import LLMCompilerAgentWorker from llama_index.core.llama_pack import download_llama_pack download_llama_pack( "LLMCompilerAgentPack", "./agent_pack", skip_load=True, ) from agent_pack.step import LLMCompilerAgentWorker import json from typing import Sequence, List from llama_index.llms.openai import OpenAI from llama_index.core.llms import ChatMessage from llama_index.core.tools import BaseTool, FunctionTool import nest_asyncio nest_asyncio.apply() def multiply(a: int, b: int) -> int: """Multiple two integers and returns the result integer""" return a * b multiply_tool = FunctionTool.from_defaults(fn=multiply) def add(a: int, b: int) -> int: """Add two integers and returns the result integer""" return a + b add_tool = FunctionTool.from_defaults(fn=add) tools = [multiply_tool, add_tool] multiply_tool.metadata.fn_schema_str from llama_index.core.agent import AgentRunner llm = OpenAI(model="gpt-4") callback_manager = llm.callback_manager agent_worker = LLMCompilerAgentWorker.from_tools( tools, llm=llm, verbose=True, callback_manager=callback_manager ) agent = AgentRunner(agent_worker, callback_manager=callback_manager) response = agent.chat("What is (121 * 3) + 42?") response agent.memory.get_all() get_ipython().system('pip install llama-index-readers-wikipedia') from llama_index.readers.wikipedia import WikipediaReader wiki_titles = ["Toronto", "Seattle", "Chicago", "Boston", "Miami"] city_docs = {} reader = WikipediaReader() for wiki_title in wiki_titles: docs = reader.load_data(pages=[wiki_title]) city_docs[wiki_title] = docs from llama_index.core import ServiceContext from llama_index.llms.openai import OpenAI from llama_index.core.callbacks import CallbackManager llm = OpenAI(temperature=0, model="gpt-4") service_context = ServiceContext.from_defaults(llm=llm) callback_manager = CallbackManager([]) from llama_index.core import load_index_from_storage, StorageContext from llama_index.core.node_parser import SentenceSplitter from llama_index.core.tools import QueryEngineTool, ToolMetadata from llama_index.core import VectorStoreIndex import os node_parser = SentenceSplitter() query_engine_tools = [] for idx, wiki_title in enumerate(wiki_titles): nodes = node_parser.get_nodes_from_documents(city_docs[wiki_title]) if not os.path.exists(f"./data/{wiki_title}"): vector_index = VectorStoreIndex( nodes, service_context=service_context, callback_manager=callback_manager ) vector_index.storage_context.persist(persist_dir=f"./data/{wiki_title}") else: vector_index = load_index_from_storage( StorageContext.from_defaults(persist_dir=f"./data/{wiki_title}"), service_context=service_context, callback_manager=callback_manager, ) vector_query_engine = vector_index.as_query_engine() query_engine_tools.append( QueryEngineTool( query_engine=vector_query_engine, metadata=ToolMetadata( name=f"vector_tool_{wiki_title}", description=( "Useful for questions related to specific aspects of" f" {wiki_title} (e.g. the history, arts and culture," " sports, demographics, or more)." ), ), ) ) from llama_index.core.agent import AgentRunner from llama_index.llms.openai import OpenAI llm = OpenAI(model="gpt-4") agent_worker = LLMCompilerAgentWorker.from_tools( query_engine_tools, llm=llm, verbose=True, callback_manager=callback_manager, ) agent = AgentRunner(agent_worker, callback_manager=callback_manager) response = agent.chat( "Tell me about the demographics of Miami, and compare that with the demographics of Chicago?" ) print(str(response)) response = agent.chat( "Is the climate of Chicago or Seattle better during the wintertime?" ) print(str(response))

[((266, 281), 'phoenix.launch_app', 'px.launch_app', ([], {}), '()\n', (279, 281), True, 'import phoenix as px\n'), ((385, 405), 'nest_asyncio.apply', 'nest_asyncio.apply', ([], {}), '()\n', (403, 405), False, 'import nest_asyncio\n'), ((549, 624), 'llama_index.core.llama_pack.download_llama_pack', 'download_llama_pack', (['"""LLMCompilerAgentPack"""', '"""./agent_pack"""'], {'skip_load': '(True)'}), "('LLMCompilerAgentPack', './agent_pack', skip_load=True)\n", (568, 624), False, 'from llama_index.core.llama_pack import download_llama_pack\n'), ((910, 930), 'nest_asyncio.apply', 'nest_asyncio.apply', ([], {}), '()\n', (928, 930), False, 'import nest_asyncio\n'), ((1069, 1108), 'llama_index.core.tools.FunctionTool.from_defaults', 'FunctionTool.from_defaults', ([], {'fn': 'multiply'}), '(fn=multiply)\n', (1095, 1108), False, 'from llama_index.core.tools import BaseTool, FunctionTool\n'), ((1231, 1265), 'llama_index.core.tools.FunctionTool.from_defaults', 'FunctionTool.from_defaults', ([], {'fn': 'add'}), '(fn=add)\n', (1257, 1265), False, 'from llama_index.core.tools import BaseTool, FunctionTool\n'), ((1398, 1419), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4"""'}), "(model='gpt-4')\n", (1404, 1419), False, 'from llama_index.llms.openai import OpenAI\n'), ((1479, 1581), 'agent_pack.step.LLMCompilerAgentWorker.from_tools', 'LLMCompilerAgentWorker.from_tools', (['tools'], {'llm': 'llm', 'verbose': '(True)', 'callback_manager': 'callback_manager'}), '(tools, llm=llm, verbose=True,\n callback_manager=callback_manager)\n', (1512, 1581), False, 'from agent_pack.step import LLMCompilerAgentWorker\n'), ((1592, 1652), 'llama_index.core.agent.AgentRunner', 'AgentRunner', (['agent_worker'], {'callback_manager': 'callback_manager'}), '(agent_worker, callback_manager=callback_manager)\n', (1603, 1652), False, 'from llama_index.core.agent import AgentRunner\n'), ((1966, 1983), 'llama_index.readers.wikipedia.WikipediaReader', 'WikipediaReader', ([], {}), '()\n', (1981, 1983), False, 'from llama_index.readers.wikipedia import WikipediaReader\n'), ((2248, 2284), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'model': '"""gpt-4"""'}), "(temperature=0, model='gpt-4')\n", (2254, 2284), False, 'from llama_index.llms.openai import OpenAI\n'), ((2303, 2340), 'llama_index.core.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm'}), '(llm=llm)\n', (2331, 2340), False, 'from llama_index.core import ServiceContext\n'), ((2360, 2379), 'llama_index.core.callbacks.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (2375, 2379), False, 'from llama_index.core.callbacks import CallbackManager\n'), ((2646, 2664), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {}), '()\n', (2662, 2664), False, 'from llama_index.core.node_parser import SentenceSplitter\n'), ((3946, 3967), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4"""'}), "(model='gpt-4')\n", (3952, 3967), False, 'from llama_index.llms.openai import OpenAI\n'), ((3983, 4098), 'agent_pack.step.LLMCompilerAgentWorker.from_tools', 'LLMCompilerAgentWorker.from_tools', (['query_engine_tools'], {'llm': 'llm', 'verbose': '(True)', 'callback_manager': 'callback_manager'}), '(query_engine_tools, llm=llm, verbose=True,\n callback_manager=callback_manager)\n', (4016, 4098), False, 'from agent_pack.step import LLMCompilerAgentWorker\n'), ((4122, 4182), 'llama_index.core.agent.AgentRunner', 'AgentRunner', (['agent_worker'], {'callback_manager': 'callback_manager'}), '(agent_worker, callback_manager=callback_manager)\n', (4133, 4182), False, 'from llama_index.core.agent import AgentRunner\n'), ((2822, 2860), 'os.path.exists', 'os.path.exists', (['f"""./data/{wiki_title}"""'], {}), "(f'./data/{wiki_title}')\n", (2836, 2860), False, 'import os\n'), ((2885, 2981), 'llama_index.core.VectorStoreIndex', 'VectorStoreIndex', (['nodes'], {'service_context': 'service_context', 'callback_manager': 'callback_manager'}), '(nodes, service_context=service_context, callback_manager=\n callback_manager)\n', (2901, 2981), False, 'from llama_index.core import VectorStoreIndex\n'), ((3150, 3214), 'llama_index.core.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'f"""./data/{wiki_title}"""'}), "(persist_dir=f'./data/{wiki_title}')\n", (3178, 3214), False, 'from llama_index.core import load_index_from_storage, StorageContext\n'), ((3499, 3705), 'llama_index.core.tools.ToolMetadata', 'ToolMetadata', ([], {'name': 'f"""vector_tool_{wiki_title}"""', 'description': 'f"""Useful for questions related to specific aspects of {wiki_title} (e.g. the history, arts and culture, sports, demographics, or more)."""'}), "(name=f'vector_tool_{wiki_title}', description=\n f'Useful for questions related to specific aspects of {wiki_title} (e.g. the history, arts and culture, sports, demographics, or more).'\n )\n", (3511, 3705), False, 'from llama_index.core.tools import QueryEngineTool, ToolMetadata\n')]

import os import hashlib from threading import Thread from pathlib import Path #import llama_index from openai import OpenAI import constants as c from llama_index import StorageContext, VectorStoreIndex, Document from llama_index.node_parser import SimpleNodeParser from llama_index import SimpleDirectoryReader c.Get_API() client = OpenAI() newdocspath = "" masterpath = "" basepath = "" persistpath = "" indexpath = "" class Document: __slots__ = ['text', 'doc_id', 'id_', 'hash'] def __init__(self, text: str, doc_id: str): self.text = text self.doc_id = doc_id self.id_ = doc_id self.hash = self.generate_hash(text) def generate_hash(self, text: str) -> str: return hashlib.sha256(text.encode()).hexdigest() def get_metadata_str(self, mode=None) -> str: return f"{self.doc_id}-{self.hash}" def get_content(self, metadata_mode=None) -> str: return self.text def index_document(doc: Document): print("index_document reached") index = VectorStoreIndex() index.add_document(doc) print("index doscument complete") def CreateUpdate_Index(basepath, masterdocs, newdocs, indexpath, action, tool ): print('Create/Update function running') # Check if index path directory is empty main_dir = "." indexes_dir = os.path.join(main_dir, "Indexes") chkindexpath = os.path.join(indexes_dir, tool) print('ckindexpath', chkindexpath) index_dir = Path(chkindexpath) print('index_dir',index_dir) is_empty =len(os.listdir(index_dir)) == 0 print('is empty', is_empty) if is_empty: print('Running creating index function') print(basepath, masterdocs, newdocs, index_dir, tool) Create_Index(basepath, masterdocs, newdocs, index_dir, tool ) else: print('Running updating index function') Update_Index(basepath, masterdocs, newdocs, index_dir) # print('Running creating index function') # print(basepath, masterdocs, newdocs, index_dir, tool) # Create_Index(basepath, masterdocs, newdocs, index_dir, tool ) def Create_Index(basepath: str, masterdocs: str, newdocs: str, indexpath: str, tool: str): print('Creating index') # Load documents docpath = masterdocs documents = SimpleDirectoryReader(input_dir=docpath).load_data() # Parse documents into nodes parser = SimpleNodeParser.from_defaults() nodes = parser.get_nodes_from_documents(documents) # Create index using nodes index = VectorStoreIndex(nodes=nodes) for doc in documents: index.insert(doc) # Persist index persist_path = os.path.join(basepath, indexpath) print('persist_path= ', persist_path) saveindexpath = persist_path index.storage_context.persist(saveindexpath) print('Index created and saved') # def Update_Index(basepath: str, masterdocs: str, newdocs: str, indexpath: str): # print("update index reached") # from llama_index import load_index_from_storage, Document # print('update_index indexpath', indexpath) # # try: # storage_context = StorageContext.from_defaults(persist_dir=indexpath) # new_index = load_index_from_storage(storage_context) # new_docs_dir = os.path.join(basepath, newdocs) # is_empty = len(os.listdir(newdocs)) == 0 # if not is_empty: # for filename in os.listdir(new_docs_dir): # path = os.path.join(new_docs_dir, filename) # with open(path) as f: # # Create document # text = f.read() # doc = Document(text, filename) # new_index.insert(doc) # storage_context.persist(new_index) # print("Update index completed") # except Exception as e: # print(e) def Update_Index(basepath: str, masterdocs: str, newdocs: str, indexpath: str): # Loading from disk from llama_index import StorageContext, load_index_from_storage from llama_index import PromptHelper, LLMPredictor, ServiceContext import openai openai.api_key = c.Get_API() is_empty =len(os.listdir(newdocs)) == 0 if not is_empty: storage_context = StorageContext.from_defaults(persist_dir=indexpath) index = load_index_from_storage(storage_context) new_docs_dir = os.path.join(basepath, newdocs) llm_predictor =LLMPredictor(llm=openai) max_input_size = 4096 num_outputs = 5000 max_chunk_overlap = 0.5 chunk_size_limit = 3900 prompt_helper = PromptHelper(max_input_size, num_outputs, max_chunk_overlap, chunk_size_limit=chunk_size_limit) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, prompt_helper=prompt_helper) reader = SimpleDirectoryReader(new_docs_dir) documents = reader.load_data() persist_path = persist_path = os.path.join(basepath, indexpath) for d in documents: index.insert(document = d, service_context = service_context) print(persist_path) storage_context.persist(persist_dir = persist_path) else: print('no new docs') def AskBuild(tool, choice): print("AskBuild reached : ", tool, choice) if choice == 'build': print("Askbuild build reached") main_dir = "." #train_dir = os.path.join(main_dir, "MyAI_Training_Docs") train_dir = ".//MyAI_Training_Docs//" train_path = os.path.join(train_dir, tool) master_dir = os.path.join(train_path, "Master") persistpath = 'Indexes//' + tool + '//' if tool == 'ai': doc_path = "ai" elif tool == 'gn': doc_path = "gn" newdocspath = train_path + "//Docs" masterpath = train_path + "//Master" print(tool, choice) print("PP: ", persistpath) print("nd: ", newdocspath) print("mp: ", masterpath) #print("bp: ", basepath) basepath = "" CreateUpdate_Index(basepath, masterpath, newdocspath, persistpath, choice, tool) print("Askbuild gn complete") elif choice == 'ask': print("Askbuild ask reached") persistpath = 'Indexes//' newdocspath = 'Docs' masterpath = 'Master' main_dir = "." basepath = os.path.join(main_dir, tool) indexpath = main_dir + '//Indexes//' + tool + '//' AskQuestion(indexpath, persistpath) print("Ask build ask complete") else: pass def AskQuestion(topic: str, action: str, question: str): from llama_index import load_index_from_storage print(topic) print("Ask question reached") indexpath = './/Indexes//' + topic + '//' print('indexpath= ', indexpath) print(os.listdir(indexpath)) storage_context = StorageContext.from_defaults(persist_dir=indexpath) new_index = load_index_from_storage(storage_context) new_query_engine = new_index.as_query_engine() while True: if question.lower() == "exit": break response = new_query_engine.query(question) print(response) print("AskQuestion complete") return response #AskBuild('gn', 'build')

[((314, 325), 'constants.Get_API', 'c.Get_API', ([], {}), '()\n', (323, 325), True, 'import constants as c\n'), ((335, 343), 'openai.OpenAI', 'OpenAI', ([], {}), '()\n', (341, 343), False, 'from openai import OpenAI\n'), ((1027, 1045), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', ([], {}), '()\n', (1043, 1045), False, 'from llama_index import StorageContext, VectorStoreIndex, Document\n'), ((1321, 1354), 'os.path.join', 'os.path.join', (['main_dir', '"""Indexes"""'], {}), "(main_dir, 'Indexes')\n", (1333, 1354), False, 'import os\n'), ((1374, 1405), 'os.path.join', 'os.path.join', (['indexes_dir', 'tool'], {}), '(indexes_dir, tool)\n', (1386, 1405), False, 'import os\n'), ((1461, 1479), 'pathlib.Path', 'Path', (['chkindexpath'], {}), '(chkindexpath)\n', (1465, 1479), False, 'from pathlib import Path\n'), ((2370, 2402), 'llama_index.node_parser.SimpleNodeParser.from_defaults', 'SimpleNodeParser.from_defaults', ([], {}), '()\n', (2400, 2402), False, 'from llama_index.node_parser import SimpleNodeParser\n'), ((2502, 2531), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', ([], {'nodes': 'nodes'}), '(nodes=nodes)\n', (2518, 2531), False, 'from llama_index import StorageContext, VectorStoreIndex, Document\n'), ((2624, 2657), 'os.path.join', 'os.path.join', (['basepath', 'indexpath'], {}), '(basepath, indexpath)\n', (2636, 2657), False, 'import os\n'), ((4102, 4113), 'constants.Get_API', 'c.Get_API', ([], {}), '()\n', (4111, 4113), True, 'import constants as c\n'), ((6806, 6857), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'indexpath'}), '(persist_dir=indexpath)\n', (6834, 6857), False, 'from llama_index import StorageContext, load_index_from_storage\n'), ((6874, 6914), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (6897, 6914), False, 'from llama_index import load_index_from_storage\n'), ((4207, 4258), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'indexpath'}), '(persist_dir=indexpath)\n', (4235, 4258), False, 'from llama_index import StorageContext, load_index_from_storage\n'), ((4275, 4315), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (4298, 4315), False, 'from llama_index import load_index_from_storage\n'), ((4339, 4370), 'os.path.join', 'os.path.join', (['basepath', 'newdocs'], {}), '(basepath, newdocs)\n', (4351, 4370), False, 'import os\n'), ((4394, 4418), 'llama_index.LLMPredictor', 'LLMPredictor', ([], {'llm': 'openai'}), '(llm=openai)\n', (4406, 4418), False, 'from llama_index import PromptHelper, LLMPredictor, ServiceContext\n'), ((4564, 4663), 'llama_index.PromptHelper', 'PromptHelper', (['max_input_size', 'num_outputs', 'max_chunk_overlap'], {'chunk_size_limit': 'chunk_size_limit'}), '(max_input_size, num_outputs, max_chunk_overlap,\n chunk_size_limit=chunk_size_limit)\n', (4576, 4663), False, 'from llama_index import PromptHelper, LLMPredictor, ServiceContext\n'), ((4687, 4778), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'prompt_helper': 'prompt_helper'}), '(llm_predictor=llm_predictor, prompt_helper=\n prompt_helper)\n', (4715, 4778), False, 'from llama_index import PromptHelper, LLMPredictor, ServiceContext\n'), ((4792, 4827), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['new_docs_dir'], {}), '(new_docs_dir)\n', (4813, 4827), False, 'from llama_index import SimpleDirectoryReader\n'), ((4905, 4938), 'os.path.join', 'os.path.join', (['basepath', 'indexpath'], {}), '(basepath, indexpath)\n', (4917, 4938), False, 'import os\n'), ((5468, 5497), 'os.path.join', 'os.path.join', (['train_dir', 'tool'], {}), '(train_dir, tool)\n', (5480, 5497), False, 'import os\n'), ((5519, 5553), 'os.path.join', 'os.path.join', (['train_path', '"""Master"""'], {}), "(train_path, 'Master')\n", (5531, 5553), False, 'import os\n'), ((6761, 6782), 'os.listdir', 'os.listdir', (['indexpath'], {}), '(indexpath)\n', (6771, 6782), False, 'import os\n'), ((1531, 1552), 'os.listdir', 'os.listdir', (['index_dir'], {}), '(index_dir)\n', (1541, 1552), False, 'import os\n'), ((2270, 2310), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': 'docpath'}), '(input_dir=docpath)\n', (2291, 2310), False, 'from llama_index import SimpleDirectoryReader\n'), ((4133, 4152), 'os.listdir', 'os.listdir', (['newdocs'], {}), '(newdocs)\n', (4143, 4152), False, 'import os\n'), ((6312, 6340), 'os.path.join', 'os.path.join', (['main_dir', 'tool'], {}), '(main_dir, tool)\n', (6324, 6340), False, 'import os\n')]

import logging from dataclasses import dataclass from typing import Any, List, Optional, cast import llama_index from llama_index.bridge.pydantic import BaseModel from llama_index.callbacks.base import CallbackManager from llama_index.core.embeddings.base import BaseEmbedding from llama_index.indices.prompt_helper import PromptHelper from llama_index.llm_predictor import LLMPredictor from llama_index.llm_predictor.base import BaseLLMPredictor, LLMMetadata from llama_index.llms.llm import LLM from llama_index.llms.utils import LLMType, resolve_llm from llama_index.logger import LlamaLogger from llama_index.node_parser.interface import NodeParser, TextSplitter from llama_index.node_parser.text.sentence import ( DEFAULT_CHUNK_SIZE, SENTENCE_CHUNK_OVERLAP, SentenceSplitter, ) from llama_index.prompts.base import BasePromptTemplate from llama_index.schema import TransformComponent from llama_index.types import PydanticProgramMode logger = logging.getLogger(__name__) def _get_default_node_parser( chunk_size: int = DEFAULT_CHUNK_SIZE, chunk_overlap: int = SENTENCE_CHUNK_OVERLAP, callback_manager: Optional[CallbackManager] = None, ) -> NodeParser: """Get default node parser.""" return SentenceSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager or CallbackManager(), ) def _get_default_prompt_helper( llm_metadata: LLMMetadata, context_window: Optional[int] = None, num_output: Optional[int] = None, ) -> PromptHelper: """Get default prompt helper.""" if context_window is not None: llm_metadata.context_window = context_window if num_output is not None: llm_metadata.num_output = num_output return PromptHelper.from_llm_metadata(llm_metadata=llm_metadata) class ServiceContextData(BaseModel): llm: dict llm_predictor: dict prompt_helper: dict embed_model: dict transformations: List[dict] @dataclass class ServiceContext: """Service Context container. The service context container is a utility container for LlamaIndex index and query classes. It contains the following: - llm_predictor: BaseLLMPredictor - prompt_helper: PromptHelper - embed_model: BaseEmbedding - node_parser: NodeParser - llama_logger: LlamaLogger (deprecated) - callback_manager: CallbackManager """ llm_predictor: BaseLLMPredictor prompt_helper: PromptHelper embed_model: BaseEmbedding transformations: List[TransformComponent] llama_logger: LlamaLogger callback_manager: CallbackManager @classmethod def from_defaults( cls, llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[Any] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # pydantic program mode (used if output_cls is specified) pydantic_program_mode: PydanticProgramMode = PydanticProgramMode.DEFAULT, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Create a ServiceContext from defaults. If an argument is specified, then use the argument value provided for that parameter. If an argument is not specified, then use the default value. You can change the base defaults by setting llama_index.global_service_context to a ServiceContext object with your desired settings. Args: llm_predictor (Optional[BaseLLMPredictor]): LLMPredictor prompt_helper (Optional[PromptHelper]): PromptHelper embed_model (Optional[BaseEmbedding]): BaseEmbedding or "local" (use local model) node_parser (Optional[NodeParser]): NodeParser llama_logger (Optional[LlamaLogger]): LlamaLogger (deprecated) chunk_size (Optional[int]): chunk_size callback_manager (Optional[CallbackManager]): CallbackManager system_prompt (Optional[str]): System-wide prompt to be prepended to all input prompts, used to guide system "decision making" query_wrapper_prompt (Optional[BasePromptTemplate]): A format to wrap passed-in input queries. Deprecated Args: chunk_size_limit (Optional[int]): renamed to chunk_size """ from llama_index.embeddings.utils import EmbedType, resolve_embed_model embed_model = cast(EmbedType, embed_model) if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size instead" ) chunk_size = chunk_size_limit if llama_index.global_service_context is not None: return cls.from_service_context( llama_index.global_service_context, llm=llm, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, text_splitter=text_splitter, llama_logger=llama_logger, callback_manager=callback_manager, context_window=context_window, chunk_size=chunk_size, chunk_size_limit=chunk_size_limit, chunk_overlap=chunk_overlap, num_output=num_output, system_prompt=system_prompt, query_wrapper_prompt=query_wrapper_prompt, transformations=transformations, ) callback_manager = callback_manager or CallbackManager([]) if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm.system_prompt = llm.system_prompt or system_prompt llm.query_wrapper_prompt = llm.query_wrapper_prompt or query_wrapper_prompt llm.pydantic_program_mode = ( llm.pydantic_program_mode or pydantic_program_mode ) if llm_predictor is not None: print("LLMPredictor is deprecated, please use LLM instead.") llm_predictor = llm_predictor or LLMPredictor( llm=llm, pydantic_program_mode=pydantic_program_mode ) if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # NOTE: embed model should be a transformation, but the way the service # context works, we can't put in there yet. embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or [node_parser] llama_logger = llama_logger or LlamaLogger() return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @classmethod def from_service_context( cls, service_context: "ServiceContext", llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[Any] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Instantiate a new service context using a previous as the defaults.""" from llama_index.embeddings.utils import EmbedType, resolve_embed_model embed_model = cast(EmbedType, embed_model) if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size", DeprecationWarning, ) chunk_size = chunk_size_limit callback_manager = callback_manager or service_context.callback_manager if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or service_context.llm_predictor if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # default to using the embed model passed from the service context if embed_model == "default": embed_model = service_context.embed_model embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or service_context.prompt_helper if context_window is not None or num_output is not None: prompt_helper = _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) transformations = transformations or [] node_parser_found = False for transform in service_context.transformations: if isinstance(transform, NodeParser): node_parser_found = True node_parser = transform break if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") if not node_parser_found: node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or service_context.transformations llama_logger = llama_logger or service_context.llama_logger return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @property def llm(self) -> LLM: return self.llm_predictor.llm @property def node_parser(self) -> NodeParser: """Get the node parser.""" for transform in self.transformations: if isinstance(transform, NodeParser): return transform raise ValueError("No node parser found.") def to_dict(self) -> dict: """Convert service context to dict.""" llm_dict = self.llm_predictor.llm.to_dict() llm_predictor_dict = self.llm_predictor.to_dict() embed_model_dict = self.embed_model.to_dict() prompt_helper_dict = self.prompt_helper.to_dict() tranform_list_dict = [x.to_dict() for x in self.transformations] return ServiceContextData( llm=llm_dict, llm_predictor=llm_predictor_dict, prompt_helper=prompt_helper_dict, embed_model=embed_model_dict, transformations=tranform_list_dict, ).dict() @classmethod def from_dict(cls, data: dict) -> "ServiceContext": from llama_index.embeddings.loading import load_embed_model from llama_index.extractors.loading import load_extractor from llama_index.llm_predictor.loading import load_predictor from llama_index.node_parser.loading import load_parser service_context_data = ServiceContextData.parse_obj(data) llm_predictor = load_predictor(service_context_data.llm_predictor) embed_model = load_embed_model(service_context_data.embed_model) prompt_helper = PromptHelper.from_dict(service_context_data.prompt_helper) transformations: List[TransformComponent] = [] for transform in service_context_data.transformations: try: transformations.append(load_parser(transform)) except ValueError: transformations.append(load_extractor(transform)) return cls.from_defaults( llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, transformations=transformations, ) def set_global_service_context(service_context: Optional[ServiceContext]) -> None: """Helper function to set the global service context.""" llama_index.global_service_context = service_context

[((962, 989), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (979, 989), False, 'import logging\n'), ((1764, 1821), 'llama_index.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', ([], {'llm_metadata': 'llm_metadata'}), '(llm_metadata=llm_metadata)\n', (1794, 1821), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((5128, 5156), 'typing.cast', 'cast', (['EmbedType', 'embed_model'], {}), '(EmbedType, embed_model)\n', (5132, 5156), False, 'from typing import Any, List, Optional, cast\n'), ((7575, 7607), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (7594, 7607), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((10019, 10047), 'typing.cast', 'cast', (['EmbedType', 'embed_model'], {}), '(EmbedType, embed_model)\n', (10023, 10047), False, 'from typing import Any, List, Optional, cast\n'), ((11263, 11295), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (11282, 11295), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((14437, 14487), 'llama_index.llm_predictor.loading.load_predictor', 'load_predictor', (['service_context_data.llm_predictor'], {}), '(service_context_data.llm_predictor)\n', (14451, 14487), False, 'from llama_index.llm_predictor.loading import load_predictor\n'), ((14511, 14561), 'llama_index.embeddings.loading.load_embed_model', 'load_embed_model', (['service_context_data.embed_model'], {}), '(service_context_data.embed_model)\n', (14527, 14561), False, 'from llama_index.embeddings.loading import load_embed_model\n'), ((14587, 14645), 'llama_index.indices.prompt_helper.PromptHelper.from_dict', 'PromptHelper.from_dict', (['service_context_data.prompt_helper'], {}), '(service_context_data.prompt_helper)\n', (14609, 14645), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((6319, 6338), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (6334, 6338), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((6506, 6522), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (6517, 6522), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((6954, 7020), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm', 'pydantic_program_mode': 'pydantic_program_mode'}), '(llm=llm, pydantic_program_mode=pydantic_program_mode)\n', (6966, 7020), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((8483, 8496), 'llama_index.logger.LlamaLogger', 'LlamaLogger', ([], {}), '()\n', (8494, 8496), False, 'from llama_index.logger import LlamaLogger\n'), ((10558, 10574), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (10569, 10574), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((10603, 10624), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (10615, 10624), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((1363, 1380), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', ([], {}), '()\n', (1378, 1380), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((14821, 14843), 'llama_index.node_parser.loading.load_parser', 'load_parser', (['transform'], {}), '(transform)\n', (14832, 14843), False, 'from llama_index.node_parser.loading import load_parser\n'), ((14915, 14940), 'llama_index.extractors.loading.load_extractor', 'load_extractor', (['transform'], {}), '(transform)\n', (14929, 14940), False, 'from llama_index.extractors.loading import load_extractor\n')]

import os from getpass import getpass if os.getenv("OPENAI_API_KEY") is None: os.environ["OPENAI_API_KEY"] = getpass( "Paste your OpenAI key from:" " https://platform.openai.com/account/api-keys\n" ) assert os.getenv("OPENAI_API_KEY", "").startswith( "sk-" ), "This doesn't look like a valid OpenAI API key" print("OpenAI API key configured") get_ipython().run_line_magic('pip', 'install -q html2text llama-index pandas pyarrow tqdm') get_ipython().run_line_magic('pip', 'install -q llama-index-readers-web') get_ipython().run_line_magic('pip', 'install -q llama-index-callbacks-openinference') import hashlib import json from pathlib import Path import os import textwrap from typing import List, Union import llama_index.core from llama_index.readers.web import SimpleWebPageReader from llama_index.core import VectorStoreIndex from llama_index.core.node_parser import SentenceSplitter from llama_index.core.callbacks import CallbackManager from llama_index.callbacks.openinference import OpenInferenceCallbackHandler from llama_index.callbacks.openinference.base import ( as_dataframe, QueryData, NodeData, ) from llama_index.core.node_parser import SimpleNodeParser import pandas as pd from tqdm import tqdm documents = SimpleWebPageReader().load_data( [ "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt" ] ) print(documents[0].text) parser = SentenceSplitter() nodes = parser.get_nodes_from_documents(documents) print(nodes[0].text) callback_handler = OpenInferenceCallbackHandler() callback_manager = CallbackManager([callback_handler]) llama_index.core.Settings.callback_manager = callback_manager index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() max_characters_per_line = 80 queries = [ "What did Paul Graham do growing up?", "When and how did Paul Graham's mother die?", "What, in Paul Graham's opinion, is the most distinctive thing about YC?", "When and how did Paul Graham meet Jessica Livingston?", "What is Bel, and when and where was it written?", ] for query in queries: response = query_engine.query(query) print("Query") print("=====") print(textwrap.fill(query, max_characters_per_line)) print() print("Response") print("========") print(textwrap.fill(str(response), max_characters_per_line)) print() query_data_buffer = callback_handler.flush_query_data_buffer() query_dataframe = as_dataframe(query_data_buffer) query_dataframe class ParquetCallback: def __init__( self, data_path: Union[str, Path], max_buffer_length: int = 1000 ): self._data_path = Path(data_path) self._data_path.mkdir(parents=True, exist_ok=False) self._max_buffer_length = max_buffer_length self._batch_index = 0 def __call__( self, query_data_buffer: List[QueryData], node_data_buffer: List[NodeData], ) -> None: if len(query_data_buffer) >= self._max_buffer_length: query_dataframe = as_dataframe(query_data_buffer) file_path = self._data_path / f"log-{self._batch_index}.parquet" query_dataframe.to_parquet(file_path) self._batch_index += 1 query_data_buffer.clear() # ⚠️ clear the buffer or it will keep growing forever! node_data_buffer.clear() # didn't log node_data_buffer, but still need to clear it data_path = "data" parquet_writer = ParquetCallback( data_path=data_path, max_buffer_length=1, ) callback_handler = OpenInferenceCallbackHandler(callback=parquet_writer) callback_manager = CallbackManager([callback_handler]) llama_index.core.Settings.callback_manager = callback_manager index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() for query in tqdm(queries): query_engine.query(query) query_dataframes = [] for file_name in os.listdir(data_path): file_path = os.path.join(data_path, file_name) query_dataframes.append(pd.read_parquet(file_path)) query_dataframe = pd.concat(query_dataframes) query_dataframe

[((1483, 1501), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {}), '()\n', (1499, 1501), False, 'from llama_index.core.node_parser import SentenceSplitter\n'), ((1596, 1626), 'llama_index.callbacks.openinference.OpenInferenceCallbackHandler', 'OpenInferenceCallbackHandler', ([], {}), '()\n', (1624, 1626), False, 'from llama_index.callbacks.openinference import OpenInferenceCallbackHandler\n'), ((1646, 1681), 'llama_index.core.callbacks.CallbackManager', 'CallbackManager', (['[callback_handler]'], {}), '([callback_handler])\n', (1661, 1681), False, 'from llama_index.core.callbacks import CallbackManager\n'), ((1755, 1797), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (1786, 1797), False, 'from llama_index.core import VectorStoreIndex\n'), ((2546, 2577), 'llama_index.callbacks.openinference.base.as_dataframe', 'as_dataframe', (['query_data_buffer'], {}), '(query_data_buffer)\n', (2558, 2577), False, 'from llama_index.callbacks.openinference.base import as_dataframe, QueryData, NodeData\n'), ((3641, 3694), 'llama_index.callbacks.openinference.OpenInferenceCallbackHandler', 'OpenInferenceCallbackHandler', ([], {'callback': 'parquet_writer'}), '(callback=parquet_writer)\n', (3669, 3694), False, 'from llama_index.callbacks.openinference import OpenInferenceCallbackHandler\n'), ((3714, 3749), 'llama_index.core.callbacks.CallbackManager', 'CallbackManager', (['[callback_handler]'], {}), '([callback_handler])\n', (3729, 3749), False, 'from llama_index.core.callbacks import CallbackManager\n'), ((3821, 3863), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (3852, 3863), False, 'from llama_index.core import VectorStoreIndex\n'), ((3917, 3930), 'tqdm.tqdm', 'tqdm', (['queries'], {}), '(queries)\n', (3921, 3930), False, 'from tqdm import tqdm\n'), ((4004, 4025), 'os.listdir', 'os.listdir', (['data_path'], {}), '(data_path)\n', (4014, 4025), False, 'import os\n'), ((4152, 4179), 'pandas.concat', 'pd.concat', (['query_dataframes'], {}), '(query_dataframes)\n', (4161, 4179), True, 'import pandas as pd\n'), ((42, 69), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (51, 69), False, 'import os\n'), ((114, 209), 'getpass.getpass', 'getpass', (['"""Paste your OpenAI key from: https://platform.openai.com/account/api-keys\n"""'], {}), "(\n 'Paste your OpenAI key from: https://platform.openai.com/account/api-keys\\n'\n )\n", (121, 209), False, 'from getpass import getpass\n'), ((4043, 4077), 'os.path.join', 'os.path.join', (['data_path', 'file_name'], {}), '(data_path, file_name)\n', (4055, 4077), False, 'import os\n'), ((232, 263), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""', '""""""'], {}), "('OPENAI_API_KEY', '')\n", (241, 263), False, 'import os\n'), ((1275, 1296), 'llama_index.readers.web.SimpleWebPageReader', 'SimpleWebPageReader', ([], {}), '()\n', (1294, 1296), False, 'from llama_index.readers.web import SimpleWebPageReader\n'), ((2282, 2327), 'textwrap.fill', 'textwrap.fill', (['query', 'max_characters_per_line'], {}), '(query, max_characters_per_line)\n', (2295, 2327), False, 'import textwrap\n'), ((2745, 2760), 'pathlib.Path', 'Path', (['data_path'], {}), '(data_path)\n', (2749, 2760), False, 'from pathlib import Path\n'), ((4106, 4132), 'pandas.read_parquet', 'pd.read_parquet', (['file_path'], {}), '(file_path)\n', (4121, 4132), True, 'import pandas as pd\n'), ((3129, 3160), 'llama_index.callbacks.openinference.base.as_dataframe', 'as_dataframe', (['query_data_buffer'], {}), '(query_data_buffer)\n', (3141, 3160), False, 'from llama_index.callbacks.openinference.base import as_dataframe, QueryData, NodeData\n')]

import os import hashlib from threading import Thread from pathlib import Path #import llama_index from openai import OpenAI import constants as c c.Get_API() client = OpenAI() newdocspath = "" masterpath = "" basepath = "" persistpath = "" # test class Document: __slots__ = ['text', 'doc_id', 'id_', 'hash'] def __init__(self, text: str, doc_id: str): self.text = text self.doc_id = doc_id self.id_ = doc_id self.hash = self.generate_hash(text) def generate_hash(self, text: str) -> str: return hashlib.sha256(text.encode()).hexdigest() def get_metadata_str(self, mode=None) -> str: return f"{self.doc_id}-{self.hash}" def get_content(self, metadata_mode=None) -> str: return self.text def index_document(doc: Document): print("index_document reached") index = VectorStoreIndex() index.add_document(doc) print("index doscument complete") def CreateUpdate_Index(basepath, masterdocs, newdocs, indexpath, action, tool ): print('Create/Update function running') # Ask questions until user exits while True: # Check if index path directory is empty chkindexpath = "Z:\\MyChatBot_v1.0\\"+ tool + "\\index\\" print(chkindexpath) index_dir = Path(chkindexpath) is_empty = len(os.listdir(index_dir)) == 0 if is_empty: print('Running creating index function') Create_Index(basepath, masterdocs, newdocs, indexpath, tool ) else: print('Running updating index function') Update_Index(basepath, masterdocs, newdocs, indexpath) def Create_Index(basepath: str, masterdocs: str, newdocs: str, indexpath: str, tool): print('Creating index') from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document # Specify the input_dir path docpath = masterdocs documents = SimpleDirectoryReader(input_dir=docpath).load_data() # Create an index from the documents index = VectorStoreIndex.from_documents(documents) # Persist index to disk saveindexpath = basepath + indexpath index.storage_context.persist(saveindexpath) print('Index created and saved') docs_dir = os.path.join("Z:\\MyAI_Training_Docs\\", tool, "_Training_Docs\\docs") doc_paths = Path(docs_dir).glob("*") num_nodes = 8 nodes = [BaseNode() for _ in range(num_nodes)] index = VectorStoreIndex(nodes=nodes) threads = [] for path in doc_paths: with open(path) as f: text = f.read() doc = Document(text, path.name) thread = Thread(target=index_document, args=(doc,)) threads.append(thread) thread.start() for thread in threads: thread.join() storage_context = StorageContext(indexdir=indexpath) storage_context.persist(index) print("Create index complete") def Update_Index(basepath: str, masterdocs: str, newdocs: str, indexpath: str): print("update index reached") import os from llama_index import load_index_from_storage storage_context = StorageContext.from_defaults(indexpath) index = load_index_from_storage(storage_context) new_docs_dir = os.path.join(basepath, newdocs) for filename in os.listdir(new_docs_dir): path = os.path.join(new_docs_dir, filename) with open(path) as f: text = f.read() doc = Document(text, filename) index.add_document(doc) storage_context.persist(index) print("Update index completed") def AskBuild(tool, choice): print("AskBuild reached : ", tool, choice) if choice == 'build': print("Askbuild build reached") basepath = 'Z:\\MyAI_Training_Docs\\' persistpath = 'Index\\Index\\' if tool == 'ai': doc_path = "AI" elif tool == 'gn': doc_path = "GN" newdocspath = basepath + doc_path + "_Training_Docs\\Docs" masterpath = basepath + doc_path + "_Training_Docs\\Master" print(tool, choice) print("PP: ", persistpath) print("nd: ", newdocspath) print("mp: ", masterpath) print("bp: ", basepath) CreateUpdate_Index(basepath, masterpath, newdocspath, persistpath, choice, tool) print("Askbuild GN complete") elif choice == 'ask': print("Askbuild ask reached") persistpath = 'Index\\Index\\' newdocspath = 'Docs' masterpath = 'Master' basepath = 'Z:\\MyChatBot_v1.0\\' + tool + '\\' AskQuestion(basepath, persistpath) print("Ask build ask complete") else: pass def AskQuestion(indexpath: str): print("Ask question reached") storage_context = StorageContext.from_defaults(indexpath) index = load_index_from_storage(storage_context) while True: question = input("Enter question: ") if question.lower() == "exit": break response = index.query(question) print(response) print("AskQuestion complete")

[((147, 158), 'constants.Get_API', 'c.Get_API', ([], {}), '()\n', (156, 158), True, 'import constants as c\n'), ((168, 176), 'openai.OpenAI', 'OpenAI', ([], {}), '()\n', (174, 176), False, 'from openai import OpenAI\n'), ((854, 872), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', ([], {}), '()\n', (870, 872), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((2052, 2094), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (2083, 2094), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((2268, 2338), 'os.path.join', 'os.path.join', (['"""Z:\\\\MyAI_Training_Docs\\\\"""', 'tool', '"""_Training_Docs\\\\docs"""'], {}), "('Z:\\\\MyAI_Training_Docs\\\\', tool, '_Training_Docs\\\\docs')\n", (2280, 2338), False, 'import os\n'), ((2462, 2491), 'llama_index.VectorStoreIndex', 'VectorStoreIndex', ([], {'nodes': 'nodes'}), '(nodes=nodes)\n', (2478, 2491), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((2822, 2856), 'llama_index.StorageContext', 'StorageContext', ([], {'indexdir': 'indexpath'}), '(indexdir=indexpath)\n', (2836, 2856), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((3131, 3170), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', (['indexpath'], {}), '(indexpath)\n', (3159, 3170), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((3183, 3223), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (3206, 3223), False, 'from llama_index import load_index_from_storage\n'), ((3244, 3275), 'os.path.join', 'os.path.join', (['basepath', 'newdocs'], {}), '(basepath, newdocs)\n', (3256, 3275), False, 'import os\n'), ((3296, 3320), 'os.listdir', 'os.listdir', (['new_docs_dir'], {}), '(new_docs_dir)\n', (3306, 3320), False, 'import os\n'), ((4751, 4790), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', (['indexpath'], {}), '(indexpath)\n', (4779, 4790), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((4803, 4843), 'llama_index.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (4826, 4843), False, 'from llama_index import load_index_from_storage\n'), ((1282, 1300), 'pathlib.Path', 'Path', (['chkindexpath'], {}), '(chkindexpath)\n', (1286, 1300), False, 'from pathlib import Path\n'), ((2609, 2634), 'llama_index.Document', 'Document', (['text', 'path.name'], {}), '(text, path.name)\n', (2617, 2634), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((2652, 2694), 'threading.Thread', 'Thread', ([], {'target': 'index_document', 'args': '(doc,)'}), '(target=index_document, args=(doc,))\n', (2658, 2694), False, 'from threading import Thread\n'), ((3337, 3373), 'os.path.join', 'os.path.join', (['new_docs_dir', 'filename'], {}), '(new_docs_dir, filename)\n', (3349, 3373), False, 'import os\n'), ((3446, 3470), 'llama_index.Document', 'Document', (['text', 'filename'], {}), '(text, filename)\n', (3454, 3470), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((1945, 1985), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': 'docpath'}), '(input_dir=docpath)\n', (1966, 1985), False, 'from llama_index import StorageContext, VectorStoreIndex, SimpleDirectoryReader, load_index_from_storage, Document\n'), ((2355, 2369), 'pathlib.Path', 'Path', (['docs_dir'], {}), '(docs_dir)\n', (2359, 2369), False, 'from pathlib import Path\n'), ((1324, 1345), 'os.listdir', 'os.listdir', (['index_dir'], {}), '(index_dir)\n', (1334, 1345), False, 'import os\n')]

import dataclasses import logging from dataclasses import dataclass from typing import Optional from llama_index.bridge.langchain import BaseLanguageModel import llama_index from llama_index.callbacks.base import CallbackManager from llama_index.embeddings.base import BaseEmbedding from llama_index.embeddings.openai import OpenAIEmbedding from llama_index.indices.prompt_helper import PromptHelper from llama_index.langchain_helpers.chain_wrapper import LLMPredictor from llama_index.llm_predictor.base import BaseLLMPredictor, LLMMetadata from llama_index.logger import LlamaLogger from llama_index.node_parser.interface import NodeParser from llama_index.node_parser.simple import SimpleNodeParser logger = logging.getLogger(__name__) def _get_default_node_parser( chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, callback_manager: Optional[CallbackManager] = None, ) -> NodeParser: """Get default node parser.""" return SimpleNodeParser.from_defaults( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) def _get_default_prompt_helper( llm_metadata: LLMMetadata, context_window: Optional[int] = None, num_output: Optional[int] = None, ) -> PromptHelper: """Get default prompt helper.""" if context_window is not None: llm_metadata = dataclasses.replace(llm_metadata, context_window=context_window) if num_output is not None: llm_metadata = dataclasses.replace(llm_metadata, num_output=num_output) return PromptHelper.from_llm_metadata(llm_metadata=llm_metadata) @dataclass class ServiceContext: """Service Context container. The service context container is a utility container for LlamaIndex index and query classes. It contains the following: - llm_predictor: BaseLLMPredictor - prompt_helper: PromptHelper - embed_model: BaseEmbedding - node_parser: NodeParser - llama_logger: LlamaLogger (deprecated) - callback_manager: CallbackManager """ llm_predictor: BaseLLMPredictor prompt_helper: PromptHelper embed_model: BaseEmbedding node_parser: NodeParser llama_logger: LlamaLogger callback_manager: CallbackManager @classmethod def from_defaults( cls, llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[BaseLanguageModel] = None, prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[BaseEmbedding] = None, node_parser: Optional[NodeParser] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Create a ServiceContext from defaults. If an argument is specified, then use the argument value provided for that parameter. If an argument is not specified, then use the default value. You can change the base defaults by setting llama_index.global_service_context to a ServiceContext object with your desired settings. Args: llm_predictor (Optional[BaseLLMPredictor]): LLMPredictor prompt_helper (Optional[PromptHelper]): PromptHelper embed_model (Optional[BaseEmbedding]): BaseEmbedding node_parser (Optional[NodeParser]): NodeParser llama_logger (Optional[LlamaLogger]): LlamaLogger (deprecated) chunk_size (Optional[int]): chunk_size callback_manager (Optional[CallbackManager]): CallbackManager Deprecated Args: chunk_size_limit (Optional[int]): renamed to chunk_size """ if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size instead" ) chunk_size = chunk_size_limit if llama_index.global_service_context is not None: return cls.from_service_context( llama_index.global_service_context, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, llama_logger=llama_logger, callback_manager=callback_manager, chunk_size=chunk_size, chunk_size_limit=chunk_size_limit, ) callback_manager = callback_manager or CallbackManager([]) if llm is not None: if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or LLMPredictor() llm_predictor.callback_manager = callback_manager # NOTE: the embed_model isn't used in all indices embed_model = embed_model or OpenAIEmbedding() embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.get_llm_metadata(), context_window=context_window, num_output=num_output, ) node_parser = node_parser or _get_default_node_parser( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) llama_logger = llama_logger or LlamaLogger() return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @classmethod def from_service_context( cls, service_context: "ServiceContext", llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[BaseLanguageModel] = None, prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[BaseEmbedding] = None, node_parser: Optional[NodeParser] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Instantiate a new service context using a previous as the defaults.""" if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size", DeprecationWarning, ) chunk_size = chunk_size_limit callback_manager = callback_manager or service_context.callback_manager if llm is not None: if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or service_context.llm_predictor llm_predictor.callback_manager = callback_manager # NOTE: the embed_model isn't used in all indices embed_model = embed_model or service_context.embed_model embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.get_llm_metadata(), context_window=context_window, num_output=num_output, ) node_parser = node_parser or service_context.node_parser if chunk_size is not None or chunk_overlap is not None: node_parser = _get_default_node_parser( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) llama_logger = llama_logger or service_context.llama_logger return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) def set_global_service_context(service_context: Optional[ServiceContext]) -> None: """Helper function to set the global service context.""" llama_index.global_service_context = service_context

[((714, 741), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (731, 741), False, 'import logging\n'), ((972, 1094), 'llama_index.node_parser.simple.SimpleNodeParser.from_defaults', 'SimpleNodeParser.from_defaults', ([], {'chunk_size': 'chunk_size', 'chunk_overlap': 'chunk_overlap', 'callback_manager': 'callback_manager'}), '(chunk_size=chunk_size, chunk_overlap=\n chunk_overlap, callback_manager=callback_manager)\n', (1002, 1094), False, 'from llama_index.node_parser.simple import SimpleNodeParser\n'), ((1567, 1624), 'llama_index.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', ([], {'llm_metadata': 'llm_metadata'}), '(llm_metadata=llm_metadata)\n', (1597, 1624), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((1380, 1444), 'dataclasses.replace', 'dataclasses.replace', (['llm_metadata'], {'context_window': 'context_window'}), '(llm_metadata, context_window=context_window)\n', (1399, 1444), False, 'import dataclasses\n'), ((1499, 1555), 'dataclasses.replace', 'dataclasses.replace', (['llm_metadata'], {'num_output': 'num_output'}), '(llm_metadata, num_output=num_output)\n', (1518, 1555), False, 'import dataclasses\n'), ((4767, 4786), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (4782, 4786), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((4963, 4984), 'llama_index.langchain_helpers.chain_wrapper.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (4975, 4984), False, 'from llama_index.langchain_helpers.chain_wrapper import LLMPredictor\n'), ((5026, 5040), 'llama_index.langchain_helpers.chain_wrapper.LLMPredictor', 'LLMPredictor', ([], {}), '()\n', (5038, 5040), False, 'from llama_index.langchain_helpers.chain_wrapper import LLMPredictor\n'), ((5195, 5212), 'llama_index.embeddings.openai.OpenAIEmbedding', 'OpenAIEmbedding', ([], {}), '()\n', (5210, 5212), False, 'from llama_index.embeddings.openai import OpenAIEmbedding\n'), ((5723, 5736), 'llama_index.logger.LlamaLogger', 'LlamaLogger', ([], {}), '()\n', (5734, 5736), False, 'from llama_index.logger import LlamaLogger\n'), ((7442, 7463), 'llama_index.langchain_helpers.chain_wrapper.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (7454, 7463), False, 'from llama_index.langchain_helpers.chain_wrapper import LLMPredictor\n')]

import llama_index.core llama_index.core.set_global_handler("simple") from llama_index.core import SimpleDirectoryReader from llama_index.core.node_parser import SimpleFileNodeParser from llama_index.core import VectorStoreIndex #Loading documents = SimpleDirectoryReader("dataset/txt").load_data() print(documents[0]) #parser = SimpleFileNodeParser() #nodes = parser.get_nodes_from_documents(documents) #print(nodes[0]) #Index index = VectorStoreIndex.from_documents(documents) print(index) #Querying query_engine = index.as_query_engine() print(query_engine) response = query_engine.query("What is AIGC?") print(response) #Agent from llama_index.core.indices.query.query_transform.base import StepDecomposeQueryTransform from llama_index.core.query_engine import MultiStepQueryEngine from llama_index.core.query_engine import SubQuestionQueryEngine DEFAULT_STEP_DECOMPOSE_QUERY_TRANSFORM_TMPL = ( "The original question is as follows: {query_str}\n" "We have an opportunity to answer some, or all of the question from a " "knowledge source. " "Context information for the knowledge source is provided below, as " "well as previous reasoning steps.\n" "Given the context and previous reasoning, return a question that can " "be answered from " "the context. This question can be the same as the original question, " "or this question can represent a subcomponent of the overall question." "It should not be irrelevant to the original question.\n" "If we cannot extract more information from the context, provide 'None' " "as the answer. " "Some examples are given below: " "\n\n" "Question: How many Grand Slam titles does the winner of the 2020 Australian " "Open have?\n" "Knowledge source context: Provides names of the winners of the 2020 " "Australian Open\n" "Previous reasoning: None\n" "Next question: Who was the winner of the 2020 Australian Open? " "\n\n" "Question: Who was the winner of the 2020 Australian Open?\n" "Knowledge source context: Provides names of the winners of the 2020 " "Australian Open\n" "Previous reasoning: None.\n" "New question: Who was the winner of the 2020 Australian Open? " "\n\n" "Question: How many Grand Slam titles does the winner of the 2020 Australian " "Open have?\n" "Knowledge source context: Provides information about the winners of the 2020 " "Australian Open\n" "Previous reasoning:\n" "- Who was the winner of the 2020 Australian Open? \n" "- The winner of the 2020 Australian Open was Novak Djokovic.\n" "New question: None" "\n\n" "Question: How many Grand Slam titles does the winner of the 2020 Australian " "Open have?\n" "Knowledge source context: Provides information about the winners of the 2020 " "Australian Open - includes biographical information for each winner\n" "Previous reasoning:\n" "- Who was the winner of the 2020 Australian Open? \n" "- The winner of the 2020 Australian Open was Novak Djokovic.\n" "New question: How many Grand Slam titles does Novak Djokovic have? " "\n\n" "Question: {query_str}\n" "Knowledge source context: {context_str}\n" "Previous reasoning: {prev_reasoning}\n" "New question: " ) print(DEFAULT_STEP_DECOMPOSE_QUERY_TRANSFORM_TMPL)

[((445, 487), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (476, 487), False, 'from llama_index.core import VectorStoreIndex\n'), ((257, 293), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""dataset/txt"""'], {}), "('dataset/txt')\n", (278, 293), False, 'from llama_index.core import SimpleDirectoryReader\n')]

get_ipython().run_line_magic('pip', 'install llama-index-embeddings-openai') get_ipython().run_line_magic('pip', 'install llama-index-postprocessor-cohere-rerank') get_ipython().run_line_magic('pip', 'install llama-index-llms-openai') import phoenix as px px.launch_app() import llama_index.core llama_index.core.set_global_handler("arize_phoenix") from llama_index.llms.openai import OpenAI from llama_index.embeddings.openai import OpenAIEmbedding from llama_index.core import Settings Settings.llm = OpenAI(model="gpt-3.5-turbo") Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small") from llama_index.core import SimpleDirectoryReader reader = SimpleDirectoryReader("../data/paul_graham") docs = reader.load_data() import os from llama_index.core import ( StorageContext, VectorStoreIndex, load_index_from_storage, ) if not os.path.exists("storage"): index = VectorStoreIndex.from_documents(docs) index.set_index_id("vector_index") index.storage_context.persist("./storage") else: storage_context = StorageContext.from_defaults(persist_dir="storage") index = load_index_from_storage(storage_context, index_id="vector_index") from llama_index.core.query_pipeline import QueryPipeline from llama_index.core import PromptTemplate prompt_str = "Please generate related movies to {movie_name}" prompt_tmpl = PromptTemplate(prompt_str) llm = OpenAI(model="gpt-3.5-turbo") p = QueryPipeline(chain=[prompt_tmpl, llm], verbose=True) output = p.run(movie_name="The Departed") print(str(output)) from typing import List from pydantic import BaseModel, Field from llama_index.core.output_parsers import PydanticOutputParser class Movie(BaseModel): """Object representing a single movie.""" name: str = Field(..., description="Name of the movie.") year: int = Field(..., description="Year of the movie.") class Movies(BaseModel): """Object representing a list of movies.""" movies: List[Movie] = Field(..., description="List of movies.") llm = OpenAI(model="gpt-3.5-turbo") output_parser = PydanticOutputParser(Movies) json_prompt_str = """\ Please generate related movies to {movie_name}. Output with the following JSON format: """ json_prompt_str = output_parser.format(json_prompt_str) json_prompt_tmpl = PromptTemplate(json_prompt_str) p = QueryPipeline(chain=[json_prompt_tmpl, llm, output_parser], verbose=True) output = p.run(movie_name="Toy Story") output prompt_str = "Please generate related movies to {movie_name}" prompt_tmpl = PromptTemplate(prompt_str) prompt_str2 = """\ Here's some text: {text} Can you rewrite this with a summary of each movie? """ prompt_tmpl2 = PromptTemplate(prompt_str2) llm = OpenAI(model="gpt-3.5-turbo") llm_c = llm.as_query_component(streaming=True) p = QueryPipeline( chain=[prompt_tmpl, llm_c, prompt_tmpl2, llm_c], verbose=True ) output = p.run(movie_name="The Dark Knight") for o in output: print(o.delta, end="") p = QueryPipeline( chain=[ json_prompt_tmpl, llm.as_query_component(streaming=True), output_parser, ], verbose=True, ) output = p.run(movie_name="Toy Story") print(output) from llama_index.postprocessor.cohere_rerank import CohereRerank prompt_str1 = "Please generate a concise question about Paul Graham's life regarding the following topic {topic}" prompt_tmpl1 = PromptTemplate(prompt_str1) prompt_str2 = ( "Please write a passage to answer the question\n" "Try to include as many key details as possible.\n" "\n" "\n" "{query_str}\n" "\n" "\n" 'Passage:"""\n' ) prompt_tmpl2 = PromptTemplate(prompt_str2) llm = OpenAI(model="gpt-3.5-turbo") retriever = index.as_retriever(similarity_top_k=5) p = QueryPipeline( chain=[prompt_tmpl1, llm, prompt_tmpl2, llm, retriever], verbose=True ) nodes = p.run(topic="college") len(nodes) from llama_index.postprocessor.cohere_rerank import CohereRerank from llama_index.core.response_synthesizers import TreeSummarize prompt_str = "Please generate a question about Paul Graham's life regarding the following topic {topic}" prompt_tmpl = PromptTemplate(prompt_str) llm = OpenAI(model="gpt-3.5-turbo") retriever = index.as_retriever(similarity_top_k=3) reranker = CohereRerank() summarizer = TreeSummarize(llm=llm) p = QueryPipeline(verbose=True) p.add_modules( { "llm": llm, "prompt_tmpl": prompt_tmpl, "retriever": retriever, "summarizer": summarizer, "reranker": reranker, } ) p.add_link("prompt_tmpl", "llm") p.add_link("llm", "retriever") p.add_link("retriever", "reranker", dest_key="nodes") p.add_link("llm", "reranker", dest_key="query_str") p.add_link("reranker", "summarizer", dest_key="nodes") p.add_link("llm", "summarizer", dest_key="query_str") print(summarizer.as_query_component().input_keys) from pyvis.network import Network net = Network(notebook=True, cdn_resources="in_line", directed=True) net.from_nx(p.dag) net.show("rag_dag.html") response = p.run(topic="YC") print(str(response)) response = await p.arun(topic="YC") print(str(response)) from llama_index.postprocessor.cohere_rerank import CohereRerank from llama_index.core.response_synthesizers import TreeSummarize from llama_index.core.query_pipeline import InputComponent retriever = index.as_retriever(similarity_top_k=5) summarizer = TreeSummarize(llm=OpenAI(model="gpt-3.5-turbo")) reranker = CohereRerank() p = QueryPipeline(verbose=True) p.add_modules( { "input": InputComponent(), "retriever": retriever, "summarizer": summarizer, } ) p.add_link("input", "retriever") p.add_link("input", "summarizer", dest_key="query_str") p.add_link("retriever", "summarizer", dest_key="nodes") output = p.run(input="what did the author do in YC") print(str(output)) from llama_index.core.query_pipeline import ( CustomQueryComponent, InputKeys, OutputKeys, ) from typing import Dict, Any from llama_index.core.llms.llm import LLM from pydantic import Field class RelatedMovieComponent(CustomQueryComponent): """Related movie component.""" llm: LLM = Field(..., description="OpenAI LLM") def _validate_component_inputs( self, input: Dict[str, Any] ) -> Dict[str, Any]: """Validate component inputs during run_component.""" return input @property def _input_keys(self) -> set: """Input keys dict.""" return {"movie"} @property def _output_keys(self) -> set: return {"output"} def _run_component(self, **kwargs) -> Dict[str, Any]: """Run the component.""" prompt_str = "Please generate related movies to {movie_name}" prompt_tmpl = PromptTemplate(prompt_str) p = QueryPipeline(chain=[prompt_tmpl, llm]) return {"output": p.run(movie_name=kwargs["movie"])} llm = OpenAI(model="gpt-3.5-turbo") component = RelatedMovieComponent(llm=llm) prompt_str = """\ Here's some text: {text} Can you rewrite this in the voice of Shakespeare? """ prompt_tmpl = PromptTemplate(prompt_str) p = QueryPipeline(chain=[component, prompt_tmpl, llm], verbose=True) output = p.run(movie="Love Actually") print(str(output))

[((259, 274), 'phoenix.launch_app', 'px.launch_app', ([], {}), '()\n', (272, 274), True, 'import phoenix as px\n'), ((510, 539), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (516, 539), False, 'from llama_index.llms.openai import OpenAI\n'), ((563, 610), 'llama_index.embeddings.openai.OpenAIEmbedding', 'OpenAIEmbedding', ([], {'model': '"""text-embedding-3-small"""'}), "(model='text-embedding-3-small')\n", (578, 610), False, 'from llama_index.embeddings.openai import OpenAIEmbedding\n'), ((674, 718), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""../data/paul_graham"""'], {}), "('../data/paul_graham')\n", (695, 718), False, 'from llama_index.core import SimpleDirectoryReader\n'), ((1374, 1400), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (1388, 1400), False, 'from llama_index.core import PromptTemplate\n'), ((1407, 1436), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (1413, 1436), False, 'from llama_index.llms.openai import OpenAI\n'), ((1442, 1495), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[prompt_tmpl, llm]', 'verbose': '(True)'}), '(chain=[prompt_tmpl, llm], verbose=True)\n', (1455, 1495), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((2038, 2067), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (2044, 2067), False, 'from llama_index.llms.openai import OpenAI\n'), ((2084, 2112), 'llama_index.core.output_parsers.PydanticOutputParser', 'PydanticOutputParser', (['Movies'], {}), '(Movies)\n', (2104, 2112), False, 'from llama_index.core.output_parsers import PydanticOutputParser\n'), ((2305, 2336), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['json_prompt_str'], {}), '(json_prompt_str)\n', (2319, 2336), False, 'from llama_index.core import PromptTemplate\n'), ((2342, 2415), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[json_prompt_tmpl, llm, output_parser]', 'verbose': '(True)'}), '(chain=[json_prompt_tmpl, llm, output_parser], verbose=True)\n', (2355, 2415), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((2544, 2570), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (2558, 2570), False, 'from llama_index.core import PromptTemplate\n'), ((2687, 2714), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str2'], {}), '(prompt_str2)\n', (2701, 2714), False, 'from llama_index.core import PromptTemplate\n'), ((2721, 2750), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (2727, 2750), False, 'from llama_index.llms.openai import OpenAI\n'), ((2803, 2879), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[prompt_tmpl, llm_c, prompt_tmpl2, llm_c]', 'verbose': '(True)'}), '(chain=[prompt_tmpl, llm_c, prompt_tmpl2, llm_c], verbose=True)\n', (2816, 2879), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((3388, 3415), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str1'], {}), '(prompt_str1)\n', (3402, 3415), False, 'from llama_index.core import PromptTemplate\n'), ((3635, 3662), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str2'], {}), '(prompt_str2)\n', (3649, 3662), False, 'from llama_index.core import PromptTemplate\n'), ((3670, 3699), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (3676, 3699), False, 'from llama_index.llms.openai import OpenAI\n'), ((3755, 3843), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[prompt_tmpl1, llm, prompt_tmpl2, llm, retriever]', 'verbose': '(True)'}), '(chain=[prompt_tmpl1, llm, prompt_tmpl2, llm, retriever],\n verbose=True)\n', (3768, 3843), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((4145, 4171), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (4159, 4171), False, 'from llama_index.core import PromptTemplate\n'), ((4178, 4207), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (4184, 4207), False, 'from llama_index.llms.openai import OpenAI\n'), ((4270, 4284), 'llama_index.postprocessor.cohere_rerank.CohereRerank', 'CohereRerank', ([], {}), '()\n', (4282, 4284), False, 'from llama_index.postprocessor.cohere_rerank import CohereRerank\n'), ((4298, 4320), 'llama_index.core.response_synthesizers.TreeSummarize', 'TreeSummarize', ([], {'llm': 'llm'}), '(llm=llm)\n', (4311, 4320), False, 'from llama_index.core.response_synthesizers import TreeSummarize\n'), ((4327, 4354), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'verbose': '(True)'}), '(verbose=True)\n', (4340, 4354), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((4913, 4975), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'cdn_resources': '"""in_line"""', 'directed': '(True)'}), "(notebook=True, cdn_resources='in_line', directed=True)\n", (4920, 4975), False, 'from pyvis.network import Network\n'), ((5451, 5465), 'llama_index.postprocessor.cohere_rerank.CohereRerank', 'CohereRerank', ([], {}), '()\n', (5463, 5465), False, 'from llama_index.postprocessor.cohere_rerank import CohereRerank\n'), ((5472, 5499), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'verbose': '(True)'}), '(verbose=True)\n', (5485, 5499), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((6893, 6922), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (6899, 6922), False, 'from llama_index.llms.openai import OpenAI\n'), ((7080, 7106), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (7094, 7106), False, 'from llama_index.core import PromptTemplate\n'), ((7112, 7176), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[component, prompt_tmpl, llm]', 'verbose': '(True)'}), '(chain=[component, prompt_tmpl, llm], verbose=True)\n', (7125, 7176), False, 'from llama_index.core.query_pipeline import QueryPipeline\n'), ((871, 896), 'os.path.exists', 'os.path.exists', (['"""storage"""'], {}), "('storage')\n", (885, 896), False, 'import os\n'), ((910, 947), 'llama_index.core.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['docs'], {}), '(docs)\n', (941, 947), False, 'from llama_index.core import StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((1062, 1113), 'llama_index.core.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""storage"""'}), "(persist_dir='storage')\n", (1090, 1113), False, 'from llama_index.core import StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((1126, 1191), 'llama_index.core.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {'index_id': '"""vector_index"""'}), "(storage_context, index_id='vector_index')\n", (1149, 1191), False, 'from llama_index.core import StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((1780, 1824), 'pydantic.Field', 'Field', (['...'], {'description': '"""Name of the movie."""'}), "(..., description='Name of the movie.')\n", (1785, 1824), False, 'from pydantic import Field\n'), ((1841, 1885), 'pydantic.Field', 'Field', (['...'], {'description': '"""Year of the movie."""'}), "(..., description='Year of the movie.')\n", (1846, 1885), False, 'from pydantic import Field\n'), ((1988, 2029), 'pydantic.Field', 'Field', (['...'], {'description': '"""List of movies."""'}), "(..., description='List of movies.')\n", (1993, 2029), False, 'from pydantic import Field\n'), ((6161, 6197), 'pydantic.Field', 'Field', (['...'], {'description': '"""OpenAI LLM"""'}), "(..., description='OpenAI LLM')\n", (6166, 6197), False, 'from pydantic import Field\n'), ((5409, 5438), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (5415, 5438), False, 'from llama_index.llms.openai import OpenAI\n'), ((5538, 5554), 'llama_index.core.query_pipeline.InputComponent', 'InputComponent', ([], {}), '()\n', (5552, 5554), False, 'from llama_index.core.query_pipeline import InputComponent\n'), ((6744, 6770), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (6758, 6770), False, 'from llama_index.core import PromptTemplate\n'), ((6783, 6822), 'llama_index.core.query_pipeline.QueryPipeline', 'QueryPipeline', ([], {'chain': '[prompt_tmpl, llm]'}), '(chain=[prompt_tmpl, llm])\n', (6796, 6822), False, 'from llama_index.core.query_pipeline import QueryPipeline\n')]

import logging from dataclasses import dataclass from typing import Optional import llama_index from llama_index.bridge.pydantic import BaseModel from llama_index.callbacks.base import CallbackManager from llama_index.embeddings.base import BaseEmbedding from llama_index.embeddings.utils import EmbedType, resolve_embed_model from llama_index.indices.prompt_helper import PromptHelper from llama_index.llm_predictor import LLMPredictor from llama_index.llm_predictor.base import BaseLLMPredictor, LLMMetadata from llama_index.llms.base import LLM from llama_index.llms.utils import LLMType, resolve_llm from llama_index.logger import LlamaLogger from llama_index.node_parser.interface import NodeParser from llama_index.node_parser.sentence_window import SentenceWindowNodeParser from llama_index.node_parser.simple import SimpleNodeParser from llama_index.prompts.base import BasePromptTemplate from llama_index.text_splitter.types import TextSplitter logger = logging.getLogger(__name__) def _get_default_node_parser( chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, callback_manager: Optional[CallbackManager] = None, ) -> NodeParser: """Get default node parser.""" return SimpleNodeParser.from_defaults( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) def _get_default_prompt_helper( llm_metadata: LLMMetadata, context_window: Optional[int] = None, num_output: Optional[int] = None, ) -> PromptHelper: """Get default prompt helper.""" if context_window is not None: llm_metadata.context_window = context_window if num_output is not None: llm_metadata.num_output = num_output return PromptHelper.from_llm_metadata(llm_metadata=llm_metadata) class ServiceContextData(BaseModel): llm: dict llm_predictor: dict prompt_helper: dict embed_model: dict node_parser: dict text_splitter: Optional[dict] metadata_extractor: Optional[dict] extractors: Optional[list] @dataclass class ServiceContext: """Service Context container. The service context container is a utility container for LlamaIndex index and query classes. It contains the following: - llm_predictor: BaseLLMPredictor - prompt_helper: PromptHelper - embed_model: BaseEmbedding - node_parser: NodeParser - llama_logger: LlamaLogger (deprecated) - callback_manager: CallbackManager """ llm_predictor: BaseLLMPredictor prompt_helper: PromptHelper embed_model: BaseEmbedding node_parser: NodeParser llama_logger: LlamaLogger callback_manager: CallbackManager @classmethod def from_defaults( cls, llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[EmbedType] = "default", node_parser: Optional[NodeParser] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Create a ServiceContext from defaults. If an argument is specified, then use the argument value provided for that parameter. If an argument is not specified, then use the default value. You can change the base defaults by setting llama_index.global_service_context to a ServiceContext object with your desired settings. Args: llm_predictor (Optional[BaseLLMPredictor]): LLMPredictor prompt_helper (Optional[PromptHelper]): PromptHelper embed_model (Optional[BaseEmbedding]): BaseEmbedding or "local" (use local model) node_parser (Optional[NodeParser]): NodeParser llama_logger (Optional[LlamaLogger]): LlamaLogger (deprecated) chunk_size (Optional[int]): chunk_size callback_manager (Optional[CallbackManager]): CallbackManager system_prompt (Optional[str]): System-wide prompt to be prepended to all input prompts, used to guide system "decision making" query_wrapper_prompt (Optional[BasePromptTemplate]): A format to wrap passed-in input queries. Deprecated Args: chunk_size_limit (Optional[int]): renamed to chunk_size """ if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size instead" ) chunk_size = chunk_size_limit if llama_index.global_service_context is not None: return cls.from_service_context( llama_index.global_service_context, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, llama_logger=llama_logger, callback_manager=callback_manager, chunk_size=chunk_size, chunk_size_limit=chunk_size_limit, ) callback_manager = callback_manager or CallbackManager([]) if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm_predictor = llm_predictor or LLMPredictor(llm=llm) if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) node_parser = node_parser or _get_default_node_parser( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) llama_logger = llama_logger or LlamaLogger() return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @classmethod def from_service_context( cls, service_context: "ServiceContext", llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[EmbedType] = "default", node_parser: Optional[NodeParser] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Instantiate a new service context using a previous as the defaults.""" if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size", DeprecationWarning, ) chunk_size = chunk_size_limit callback_manager = callback_manager or service_context.callback_manager if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or service_context.llm_predictor if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # default to using the embed model passed from the service context if embed_model == "default": embed_model = service_context.embed_model embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or service_context.prompt_helper if context_window is not None or num_output is not None: prompt_helper = _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) node_parser = node_parser or service_context.node_parser if chunk_size is not None or chunk_overlap is not None: node_parser = _get_default_node_parser( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) llama_logger = llama_logger or service_context.llama_logger return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @property def llm(self) -> LLM: if not isinstance(self.llm_predictor, LLMPredictor): raise ValueError("llm_predictor must be an instance of LLMPredictor") return self.llm_predictor.llm def to_dict(self) -> dict: """Convert service context to dict.""" llm_dict = self.llm_predictor.llm.to_dict() llm_predictor_dict = self.llm_predictor.to_dict() embed_model_dict = self.embed_model.to_dict() prompt_helper_dict = self.prompt_helper.to_dict() node_parser_dict = self.node_parser.to_dict() metadata_extractor_dict = None extractor_dicts = None text_splitter_dict = None if isinstance(self.node_parser, SimpleNodeParser) and isinstance( self.node_parser.text_splitter, TextSplitter ): text_splitter_dict = self.node_parser.text_splitter.to_dict() if isinstance(self.node_parser, (SimpleNodeParser, SentenceWindowNodeParser)): if self.node_parser.metadata_extractor: metadata_extractor_dict = self.node_parser.metadata_extractor.to_dict() extractor_dicts = [] for extractor in self.node_parser.metadata_extractor.extractors: extractor_dicts.append(extractor.to_dict()) return ServiceContextData( llm=llm_dict, llm_predictor=llm_predictor_dict, prompt_helper=prompt_helper_dict, embed_model=embed_model_dict, node_parser=node_parser_dict, text_splitter=text_splitter_dict, metadata_extractor=metadata_extractor_dict, extractors=extractor_dicts, ).dict() @classmethod def from_dict(cls, data: dict) -> "ServiceContext": from llama_index.embeddings.loading import load_embed_model from llama_index.llm_predictor.loading import load_predictor from llama_index.llms.loading import load_llm from llama_index.node_parser.extractors.loading import load_extractor from llama_index.node_parser.loading import load_parser from llama_index.text_splitter.loading import load_text_splitter service_context_data = ServiceContextData.parse_obj(data) llm = load_llm(service_context_data.llm) llm_predictor = load_predictor(service_context_data.llm_predictor, llm=llm) embed_model = load_embed_model(service_context_data.embed_model) prompt_helper = PromptHelper.from_dict(service_context_data.prompt_helper) extractors = None if service_context_data.extractors: extractors = [] for extractor_dict in service_context_data.extractors: extractors.append(load_extractor(extractor_dict, llm=llm)) metadata_extractor = None if service_context_data.metadata_extractor: metadata_extractor = load_extractor( service_context_data.metadata_extractor, extractors=extractors, ) text_splitter = None if service_context_data.text_splitter: text_splitter = load_text_splitter(service_context_data.text_splitter) node_parser = load_parser( service_context_data.node_parser, text_splitter=text_splitter, metadata_extractor=metadata_extractor, ) return cls.from_defaults( llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, ) def set_global_service_context(service_context: Optional[ServiceContext]) -> None: """Helper function to set the global service context.""" llama_index.global_service_context = service_context

[((965, 992), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (982, 992), False, 'import logging\n'), ((1223, 1345), 'llama_index.node_parser.simple.SimpleNodeParser.from_defaults', 'SimpleNodeParser.from_defaults', ([], {'chunk_size': 'chunk_size', 'chunk_overlap': 'chunk_overlap', 'callback_manager': 'callback_manager'}), '(chunk_size=chunk_size, chunk_overlap=\n chunk_overlap, callback_manager=callback_manager)\n', (1253, 1345), False, 'from llama_index.node_parser.simple import SimpleNodeParser\n'), ((1748, 1805), 'llama_index.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', ([], {'llm_metadata': 'llm_metadata'}), '(llm_metadata=llm_metadata)\n', (1778, 1805), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((6295, 6327), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (6314, 6327), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((9351, 9383), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (9370, 9383), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((12743, 12777), 'llama_index.llms.loading.load_llm', 'load_llm', (['service_context_data.llm'], {}), '(service_context_data.llm)\n', (12751, 12777), False, 'from llama_index.llms.loading import load_llm\n'), ((12802, 12861), 'llama_index.llm_predictor.loading.load_predictor', 'load_predictor', (['service_context_data.llm_predictor'], {'llm': 'llm'}), '(service_context_data.llm_predictor, llm=llm)\n', (12816, 12861), False, 'from llama_index.llm_predictor.loading import load_predictor\n'), ((12885, 12935), 'llama_index.embeddings.loading.load_embed_model', 'load_embed_model', (['service_context_data.embed_model'], {}), '(service_context_data.embed_model)\n', (12901, 12935), False, 'from llama_index.embeddings.loading import load_embed_model\n'), ((12961, 13019), 'llama_index.indices.prompt_helper.PromptHelper.from_dict', 'PromptHelper.from_dict', (['service_context_data.prompt_helper'], {}), '(service_context_data.prompt_helper)\n', (12983, 13019), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((13690, 13807), 'llama_index.node_parser.loading.load_parser', 'load_parser', (['service_context_data.node_parser'], {'text_splitter': 'text_splitter', 'metadata_extractor': 'metadata_extractor'}), '(service_context_data.node_parser, text_splitter=text_splitter,\n metadata_extractor=metadata_extractor)\n', (13701, 13807), False, 'from llama_index.node_parser.loading import load_parser\n'), ((5628, 5647), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (5643, 5647), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((5815, 5831), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (5826, 5831), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((5873, 5894), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (5885, 5894), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((6828, 6841), 'llama_index.logger.LlamaLogger', 'LlamaLogger', ([], {}), '()\n', (6839, 6841), False, 'from llama_index.logger import LlamaLogger\n'), ((8646, 8662), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (8657, 8662), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((8691, 8712), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (8703, 8712), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((13381, 13459), 'llama_index.node_parser.extractors.loading.load_extractor', 'load_extractor', (['service_context_data.metadata_extractor'], {'extractors': 'extractors'}), '(service_context_data.metadata_extractor, extractors=extractors)\n', (13395, 13459), False, 'from llama_index.node_parser.extractors.loading import load_extractor\n'), ((13612, 13666), 'llama_index.text_splitter.loading.load_text_splitter', 'load_text_splitter', (['service_context_data.text_splitter'], {}), '(service_context_data.text_splitter)\n', (13630, 13666), False, 'from llama_index.text_splitter.loading import load_text_splitter\n'), ((13220, 13259), 'llama_index.node_parser.extractors.loading.load_extractor', 'load_extractor', (['extractor_dict'], {'llm': 'llm'}), '(extractor_dict, llm=llm)\n', (13234, 13259), False, 'from llama_index.node_parser.extractors.loading import load_extractor\n')]

from urllib import response import llama_index from pathlib import Path from typing import Annotated, List from fastapi.responses import StreamingResponse from fastapi import ( File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status ) from llama_index import StorageContext, VectorStoreIndex, SummaryIndex from llama_index.selectors.llm_selectors import LLMSingleSelector from llama_index.llms.types import MessageRole, ChatMessage from llama_index.retrievers import VectorIndexRetriever, SummaryIndexEmbeddingRetriever, RouterRetriever from llama_index.tools import RetrieverTool from llama_index.chat_engine import ContextChatEngine from llama_index.memory import ChatMemoryBuffer from llama_index.vector_stores import ( MetadataFilter, MetadataFilters, FilterOperator ) from llama_index.callbacks import CallbackManager, LlamaDebugHandler from app.utils.json_to import json_to_model from app.utils.index import get_index from app.utils.auth import decode_access_token from app.utils.fs import get_s3_fs, get_s3_boto_client from app.db.pg_vector import get_vector_store_singleton from app.db.crud import get_documents, create_documents, delete_document, is_user_existed from app.pydantic_models.chat import ChatData from app.orm_models import Document from app.core.ingest import ingest_user_documents from app.prompts.system import LLM_SYSTEM_MESSAGE from app.prompts.selector import MULTI_SELECT_PROMPT_TEMPLATE, SINGLE_SELECTOR_PROMPT_TEMPLATE chat_router = r = APIRouter() @r.post("") async def chat( request: Request, # Note: To support clients sending a JSON object using content-type "text/plain", # we need to use Depends(json_to_model(_ChatData)) here data: Annotated[ChatData, Depends(json_to_model(ChatData))], index: Annotated[dict, Depends(get_index)], token_payload: Annotated[dict, Depends(decode_access_token)] ): # logger = logging.getLogger("uvicorn") user_id = token_payload["user_id"] # Only need to retrieve indices from the current user. filters = MetadataFilters( filters=[ MetadataFilter( key="user_id", operator=FilterOperator.EQ, value=user_id), ] ) # check preconditions and get last message if len(data.messages) == 0: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="No messages provided", ) lastMessage = data.messages.pop() if lastMessage.role != MessageRole.USER: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="Last message must be from user", ) # convert messages coming from the request to type ChatMessage messages = [ ChatMessage( role=m.role, content=m.content, ) for m in data.messages ] # query chat engine # system_message = ( # "You are a professional job candidate who will answer the recruiter question using the context information." # "If the question is out of scope, kindly apologize and refuse to answer." # ) # Callbacks for observability. # TODO: this is not working. llama_debug = LlamaDebugHandler(print_trace_on_end=True) callback_manager = CallbackManager([llama_debug]) vs_retriever = VectorIndexRetriever( index=index["vector"], similarity_top_k=3, filters=filters, ) summary_retriever = SummaryIndexEmbeddingRetriever( index=index["summary"], similarity_top_k=3, ) vs_tool = RetrieverTool.from_defaults( retriever=vs_retriever, description="Useful for retrieving specific context from uploaded documents." ) summary_tool = RetrieverTool.from_defaults( retriever=summary_retriever, description="Useful to retrieve all context from uploaded documents and summary tasks. Don't use if the question only requires more specific context." ) # TODO: correct the prompt used by LLM to use router retriever. retriever = RouterRetriever( selector=LLMSingleSelector.from_defaults( # prompt_template_str=SINGLE_SELECTOR_PROMPT_TEMPLATE ), retriever_tools=[vs_tool, summary_tool] ) chat_engine = ContextChatEngine( retriever=vs_retriever, llm=llama_index.global_service_context.llm, memory=ChatMemoryBuffer.from_defaults(token_limit=4096), prefix_messages=[ChatMessage( role="system", content=LLM_SYSTEM_MESSAGE)], callback_manager=callback_manager, ) print(chat_engine._retriever.get_prompts()) response = chat_engine.stream_chat(lastMessage.content, messages) # stream response async def event_generator(): for token in response.response_gen: # If client closes connection, stop sending events if await request.is_disconnected(): break yield token return StreamingResponse(event_generator(), media_type="text/plain") @r.post("/upload/single") async def upload( description: Annotated[str, Form()], question: Annotated[str, Form()], file: Annotated[UploadFile, File()], token_payload: Annotated[dict, Depends(decode_access_token)] ) -> Document: vector_store = await get_vector_store_singleton() user_id = token_payload["user_id"] user_s3_folder = Path(f"talking-resume/{user_id}") nodes = [] # Have to use boto because I don't know how to write temporary file to s3 using f3fs. s3 = get_s3_boto_client() doc = Document( s3_path=f"{user_id}/{file.filename}", is_active=True, description=description, question=question, user_id=user_id, ) # Create new record in db. doc_in_db = create_documents([doc])[0] doc_uuid = str(doc_in_db.id) # Save the document to S3. s3.upload_fileobj( file.file, "talking-resume", doc.s3_path, ) nodes = ingest_user_documents( doc_uuid, f"talking-resume/{doc.s3_path}", doc.description, doc.question, doc.user_id ) # Save documents indices and embeddings. s3 = get_s3_fs() persist_dir = None if await is_user_existed(user_id): persist_dir = f"talking-resume/{user_id}" storage_context = StorageContext.from_defaults( vector_store=vector_store, persist_dir=persist_dir, fs=s3) # Vector store index. vector_index = VectorStoreIndex.from_documents( documents=nodes, storage_context=storage_context, show_progress=True) vector_index.set_index_id(f'vector_{user_id}') vector_index.storage_context.persist(persist_dir=user_s3_folder, fs=s3) # Summary index. summary_index = SummaryIndex.from_documents( documents=nodes, storage_context=storage_context, show_progress=True) summary_index.set_index_id(f'summary_{user_id}') summary_index.storage_context.persist(persist_dir=user_s3_folder, fs=s3) return doc_in_db @r.get("/upload") def get_upload( user_id: str, token_payload: Annotated[dict, Depends(decode_access_token)] ) -> List[Document]: documents = get_documents(user_id) for document in documents: s3 = get_s3_boto_client() s3_url = s3.generate_presigned_url( "get_object", Params={ "Bucket": "talking-resume", "Key": document.s3_path, "ResponseContentDisposition": "inline", "ResponseContentType": "application/pdf"}) document.s3_url = s3_url return documents @r.delete("/upload") async def delete_upload( document_id: str, user_id: str, ) -> None: await delete_document(document_id, user_id) @r.post("/upload/multiple") async def upload( descriptions: Annotated[List[str], Form()], questions: Annotated[List[str], Form()], files: Annotated[List[UploadFile], File()], token_payload: Annotated[dict, Depends(decode_access_token)] ) -> List[Document]: vector_store = await get_vector_store_singleton() user_id = token_payload["user_id"] user_s3_folder = Path(f"talking-resume/{user_id}") # TODO: smartly remove or inactivate documents instead of full deletion. # if await is_user_existed(user_id): # await delete_all_documents_from_user(user_id) # Have to use boto because I don't know how to write temporary file to s3 using f3fs. s3 = get_s3_boto_client() nodes = [] docs = [] for user_document, description, question in zip(files, descriptions, questions): doc = Document( s3_path=f"{user_id}/{user_document.filename}", is_active=True, description=description, question=question, user_id=user_id, ) # Save the document to S3. s3.upload_fileobj( user_document.file, "talking-resume", doc.s3_path, ) nodes.extend(ingest_user_documents( f"talking-resume/{doc.s3_path}", doc.description, doc.question, doc.user_id)) docs.append(doc) # Save documents indices and embeddings. s3 = get_s3_fs() storage_context = StorageContext.from_defaults( vector_store=vector_store, fs=s3) # Vector store index. vector_index = VectorStoreIndex.from_documents( documents=nodes, storage_context=storage_context) vector_index.set_index_id(user_id) vector_index.storage_context.persist(persist_dir=user_s3_folder, fs=s3) # Create new record in db. docs = create_documents(docs) return docs

[((1534, 1545), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (1543, 1545), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((3266, 3308), 'llama_index.callbacks.LlamaDebugHandler', 'LlamaDebugHandler', ([], {'print_trace_on_end': '(True)'}), '(print_trace_on_end=True)\n', (3283, 3308), False, 'from llama_index.callbacks import CallbackManager, LlamaDebugHandler\n'), ((3332, 3362), 'llama_index.callbacks.CallbackManager', 'CallbackManager', (['[llama_debug]'], {}), '([llama_debug])\n', (3347, 3362), False, 'from llama_index.callbacks import CallbackManager, LlamaDebugHandler\n'), ((3383, 3468), 'llama_index.retrievers.VectorIndexRetriever', 'VectorIndexRetriever', ([], {'index': "index['vector']", 'similarity_top_k': '(3)', 'filters': 'filters'}), "(index=index['vector'], similarity_top_k=3, filters=filters\n )\n", (3403, 3468), False, 'from llama_index.retrievers import VectorIndexRetriever, SummaryIndexEmbeddingRetriever, RouterRetriever\n'), ((3519, 3593), 'llama_index.retrievers.SummaryIndexEmbeddingRetriever', 'SummaryIndexEmbeddingRetriever', ([], {'index': "index['summary']", 'similarity_top_k': '(3)'}), "(index=index['summary'], similarity_top_k=3)\n", (3549, 3593), False, 'from llama_index.retrievers import VectorIndexRetriever, SummaryIndexEmbeddingRetriever, RouterRetriever\n'), ((3632, 3767), 'llama_index.tools.RetrieverTool.from_defaults', 'RetrieverTool.from_defaults', ([], {'retriever': 'vs_retriever', 'description': '"""Useful for retrieving specific context from uploaded documents."""'}), "(retriever=vs_retriever, description=\n 'Useful for retrieving specific context from uploaded documents.')\n", (3659, 3767), False, 'from llama_index.tools import RetrieverTool\n'), ((3804, 4022), 'llama_index.tools.RetrieverTool.from_defaults', 'RetrieverTool.from_defaults', ([], {'retriever': 'summary_retriever', 'description': '"""Useful to retrieve all context from uploaded documents and summary tasks. Don\'t use if the question only requires more specific context."""'}), '(retriever=summary_retriever, description=\n "Useful to retrieve all context from uploaded documents and summary tasks. Don\'t use if the question only requires more specific context."\n )\n', (3831, 4022), False, 'from llama_index.tools import RetrieverTool\n'), ((5459, 5492), 'pathlib.Path', 'Path', (['f"""talking-resume/{user_id}"""'], {}), "(f'talking-resume/{user_id}')\n", (5463, 5492), False, 'from pathlib import Path\n'), ((5608, 5628), 'app.utils.fs.get_s3_boto_client', 'get_s3_boto_client', ([], {}), '()\n', (5626, 5628), False, 'from app.utils.fs import get_s3_fs, get_s3_boto_client\n'), ((5639, 5767), 'app.orm_models.Document', 'Document', ([], {'s3_path': 'f"""{user_id}/{file.filename}"""', 'is_active': '(True)', 'description': 'description', 'question': 'question', 'user_id': 'user_id'}), "(s3_path=f'{user_id}/{file.filename}', is_active=True, description=\n description, question=question, user_id=user_id)\n", (5647, 5767), False, 'from app.orm_models import Document\n'), ((6056, 6169), 'app.core.ingest.ingest_user_documents', 'ingest_user_documents', (['doc_uuid', 'f"""talking-resume/{doc.s3_path}"""', 'doc.description', 'doc.question', 'doc.user_id'], {}), "(doc_uuid, f'talking-resume/{doc.s3_path}', doc.\n description, doc.question, doc.user_id)\n", (6077, 6169), False, 'from app.core.ingest import ingest_user_documents\n'), ((6266, 6277), 'app.utils.fs.get_s3_fs', 'get_s3_fs', ([], {}), '()\n', (6275, 6277), False, 'from app.utils.fs import get_s3_fs, get_s3_boto_client\n'), ((6413, 6505), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store', 'persist_dir': 'persist_dir', 'fs': 's3'}), '(vector_store=vector_store, persist_dir=\n persist_dir, fs=s3)\n', (6441, 6505), False, 'from llama_index import StorageContext, VectorStoreIndex, SummaryIndex\n'), ((6571, 6677), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', ([], {'documents': 'nodes', 'storage_context': 'storage_context', 'show_progress': '(True)'}), '(documents=nodes, storage_context=\n storage_context, show_progress=True)\n', (6602, 6677), False, 'from llama_index import StorageContext, VectorStoreIndex, SummaryIndex\n'), ((6851, 6953), 'llama_index.SummaryIndex.from_documents', 'SummaryIndex.from_documents', ([], {'documents': 'nodes', 'storage_context': 'storage_context', 'show_progress': '(True)'}), '(documents=nodes, storage_context=\n storage_context, show_progress=True)\n', (6878, 6953), False, 'from llama_index import StorageContext, VectorStoreIndex, SummaryIndex\n'), ((7266, 7288), 'app.db.crud.get_documents', 'get_documents', (['user_id'], {}), '(user_id)\n', (7279, 7288), False, 'from app.db.crud import get_documents, create_documents, delete_document, is_user_existed\n'), ((8235, 8268), 'pathlib.Path', 'Path', (['f"""talking-resume/{user_id}"""'], {}), "(f'talking-resume/{user_id}')\n", (8239, 8268), False, 'from pathlib import Path\n'), ((8544, 8564), 'app.utils.fs.get_s3_boto_client', 'get_s3_boto_client', ([], {}), '()\n', (8562, 8564), False, 'from app.utils.fs import get_s3_fs, get_s3_boto_client\n'), ((9271, 9282), 'app.utils.fs.get_s3_fs', 'get_s3_fs', ([], {}), '()\n', (9280, 9282), False, 'from app.utils.fs import get_s3_fs, get_s3_boto_client\n'), ((9305, 9367), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store', 'fs': 's3'}), '(vector_store=vector_store, fs=s3)\n', (9333, 9367), False, 'from llama_index import StorageContext, VectorStoreIndex, SummaryIndex\n'), ((9423, 9509), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', ([], {'documents': 'nodes', 'storage_context': 'storage_context'}), '(documents=nodes, storage_context=\n storage_context)\n', (9454, 9509), False, 'from llama_index import StorageContext, VectorStoreIndex, SummaryIndex\n'), ((9672, 9694), 'app.db.crud.create_documents', 'create_documents', (['docs'], {}), '(docs)\n', (9688, 9694), False, 'from app.db.crud import get_documents, create_documents, delete_document, is_user_existed\n'), ((2361, 2451), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': 'status.HTTP_400_BAD_REQUEST', 'detail': '"""No messages provided"""'}), "(status_code=status.HTTP_400_BAD_REQUEST, detail=\n 'No messages provided')\n", (2374, 2451), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((2579, 2679), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': 'status.HTTP_400_BAD_REQUEST', 'detail': '"""Last message must be from user"""'}), "(status_code=status.HTTP_400_BAD_REQUEST, detail=\n 'Last message must be from user')\n", (2592, 2679), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((2802, 2845), 'llama_index.llms.types.ChatMessage', 'ChatMessage', ([], {'role': 'm.role', 'content': 'm.content'}), '(role=m.role, content=m.content)\n', (2813, 2845), False, 'from llama_index.llms.types import MessageRole, ChatMessage\n'), ((5370, 5398), 'app.db.pg_vector.get_vector_store_singleton', 'get_vector_store_singleton', ([], {}), '()\n', (5396, 5398), False, 'from app.db.pg_vector import get_vector_store_singleton\n'), ((5857, 5880), 'app.db.crud.create_documents', 'create_documents', (['[doc]'], {}), '([doc])\n', (5873, 5880), False, 'from app.db.crud import get_documents, create_documents, delete_document, is_user_existed\n'), ((6314, 6338), 'app.db.crud.is_user_existed', 'is_user_existed', (['user_id'], {}), '(user_id)\n', (6329, 6338), False, 'from app.db.crud import get_documents, create_documents, delete_document, is_user_existed\n'), ((7333, 7353), 'app.utils.fs.get_s3_boto_client', 'get_s3_boto_client', ([], {}), '()\n', (7351, 7353), False, 'from app.utils.fs import get_s3_fs, get_s3_boto_client\n'), ((7808, 7845), 'app.db.crud.delete_document', 'delete_document', (['document_id', 'user_id'], {}), '(document_id, user_id)\n', (7823, 7845), False, 'from app.db.crud import get_documents, create_documents, delete_document, is_user_existed\n'), ((8146, 8174), 'app.db.pg_vector.get_vector_store_singleton', 'get_vector_store_singleton', ([], {}), '()\n', (8172, 8174), False, 'from app.db.pg_vector import get_vector_store_singleton\n'), ((8693, 8829), 'app.orm_models.Document', 'Document', ([], {'s3_path': 'f"""{user_id}/{user_document.filename}"""', 'is_active': '(True)', 'description': 'description', 'question': 'question', 'user_id': 'user_id'}), "(s3_path=f'{user_id}/{user_document.filename}', is_active=True,\n description=description, question=question, user_id=user_id)\n", (8701, 8829), False, 'from app.orm_models import Document\n'), ((4154, 4187), 'llama_index.selectors.llm_selectors.LLMSingleSelector.from_defaults', 'LLMSingleSelector.from_defaults', ([], {}), '()\n', (4185, 4187), False, 'from llama_index.selectors.llm_selectors import LLMSingleSelector\n'), ((4455, 4503), 'llama_index.memory.ChatMemoryBuffer.from_defaults', 'ChatMemoryBuffer.from_defaults', ([], {'token_limit': '(4096)'}), '(token_limit=4096)\n', (4485, 4503), False, 'from llama_index.memory import ChatMemoryBuffer\n'), ((9078, 9181), 'app.core.ingest.ingest_user_documents', 'ingest_user_documents', (['f"""talking-resume/{doc.s3_path}"""', 'doc.description', 'doc.question', 'doc.user_id'], {}), "(f'talking-resume/{doc.s3_path}', doc.description, doc\n .question, doc.user_id)\n", (9099, 9181), False, 'from app.core.ingest import ingest_user_documents\n'), ((1836, 1854), 'fastapi.Depends', 'Depends', (['get_index'], {}), '(get_index)\n', (1843, 1854), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((1892, 1920), 'fastapi.Depends', 'Depends', (['decode_access_token'], {}), '(decode_access_token)\n', (1899, 1920), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((2128, 2200), 'llama_index.vector_stores.MetadataFilter', 'MetadataFilter', ([], {'key': '"""user_id"""', 'operator': 'FilterOperator.EQ', 'value': 'user_id'}), "(key='user_id', operator=FilterOperator.EQ, value=user_id)\n", (2142, 2200), False, 'from llama_index.vector_stores import MetadataFilter, MetadataFilters, FilterOperator\n'), ((4530, 4584), 'llama_index.llms.types.ChatMessage', 'ChatMessage', ([], {'role': '"""system"""', 'content': 'LLM_SYSTEM_MESSAGE'}), "(role='system', content=LLM_SYSTEM_MESSAGE)\n", (4541, 4584), False, 'from llama_index.llms.types import MessageRole, ChatMessage\n'), ((5177, 5183), 'fastapi.Form', 'Form', ([], {}), '()\n', (5181, 5183), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((5215, 5221), 'fastapi.Form', 'Form', ([], {}), '()\n', (5219, 5221), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((5256, 5262), 'fastapi.File', 'File', ([], {}), '()\n', (5260, 5262), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((5300, 5328), 'fastapi.Depends', 'Depends', (['decode_access_token'], {}), '(decode_access_token)\n', (5307, 5328), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((7199, 7227), 'fastapi.Depends', 'Depends', (['decode_access_token'], {}), '(decode_access_token)\n', (7206, 7227), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((7933, 7939), 'fastapi.Form', 'Form', ([], {}), '()\n', (7937, 7939), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((7978, 7984), 'fastapi.Form', 'Form', ([], {}), '()\n', (7982, 7984), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((8026, 8032), 'fastapi.File', 'File', ([], {}), '()\n', (8030, 8032), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((8070, 8098), 'fastapi.Depends', 'Depends', (['decode_access_token'], {}), '(decode_access_token)\n', (8077, 8098), False, 'from fastapi import File, Form, UploadFile, APIRouter, Depends, HTTPException, Request, status\n'), ((1782, 1805), 'app.utils.json_to.json_to_model', 'json_to_model', (['ChatData'], {}), '(ChatData)\n', (1795, 1805), False, 'from app.utils.json_to import json_to_model\n')]

import utils import os import requests import llama_index import torch import llama_cpp from llama_index import SimpleDirectoryReader from llama_index import Document from llama_index import VectorStoreIndex from llama_index import ServiceContext from llama_index import LLMPredictor # Paramas llama = True ### Get data dirpath = 'related_works/Cloud_VM/' filename = dirpath + 'ey.pdf' url = 'https://assets.ey.com/content/dam/ey-sites/ey-com/nl_nl/topics/jaarverslag/downloads-pdfs/2022-2023/ey-nl-financial-statements-2023-en.pdf' if not os.path.exists(filename): print(f"Downloading {filename} from {url}...") response = requests.get(url) with open(dirpath + 'ey.pdf', 'wb') as f: f.write(response.content) documents = SimpleDirectoryReader( input_files=[filename] ).load_data() ### Print data print(type(documents), "\n") print(len(documents), "\n") print(type(documents[0])) print(documents[0]) ### Create doc object document = Document(text="\n\n".join([doc.text for doc in documents])) ### load model model_name_or_path = "TheBloke/Llama-2-13B-chat-GGML" model_basename = "llama-2-13b-chat.ggmlv3.q5_1.bin" # the model is in bin format from huggingface_hub import hf_hub_download model_path = hf_hub_download(repo_id=model_name_or_path, filename=model_basename) if llama: # GPU from llama_cpp import Llama llm = None llm = Llama( model_path=model_path, n_threads=2, # CPU cores n_batch=512, # Should be between 1 and n_ctx, consider the amount of VRAM in your GPU. n_gpu_layers=43, # Change this value based on your model and your GPU VRAM pool. n_ctx=4096, # Context window ) else: from transformers import LlamaTokenizer, LlamaForCausalLM tokenizer = LlamaTokenizer.from_pretrained('ChanceFocus/finma-7b-full') llm = LlamaForCausalLM.from_pretrained('ChanceFocus/finma-7b-full', device_map='auto') ##### The replicate endpoint from llama_index.llms import Replicate from llama_index import ServiceContext, set_global_service_context from llama_index.llms.llama_utils import ( messages_to_prompt, completion_to_prompt, ) LLAMA_13B_V2_CHAT = "a16z-infra/llama13b-v2-chat:df7690f1994d94e96ad9d568eac121aecf50684a0b0963b25a41cc40061269e5" # inject custom system prompt into llama-2 def custom_completion_to_prompt(completion: str) -> str: return completion_to_prompt( completion, system_prompt=( "You are a Q&A assistant. Your goal is to answer questions as " "accurately as possible is the instructions and context provided." ), ) llm = Replicate( model=LLAMA_13B_V2_CHAT, temperature=0.01, # override max tokens since it's interpreted # as context window instead of max tokens context_window=4096, # override completion representation for llama 2 completion_to_prompt=custom_completion_to_prompt, # if using llama 2 for data agents, also override the message representation messages_to_prompt=messages_to_prompt, ) service_context = ServiceContext.from_defaults( llm=llm, embed_model="local:BAAI/bge-small-en-v1.5" ) index = VectorStoreIndex.from_documents([document], service_context=service_context) query_engine = index.as_query_engine() response = query_engine.query( "What actions is Ernst & Young Global Limited taking to address climate change issues?" ) print(str(response)) # ## Evaluation setup using TruLens eval_questions = [] with open('eval_questions.txt', 'r') as file: for line in file: # Remove newline character and convert to integer item = line.strip() print(item) eval_questions.append(item) # You can try your own question: new_question = "What is the right AI job for me?" eval_questions.append(new_question) print(eval_questions) from trulens_eval import Tru tru = Tru() tru.reset_database() from utils import get_prebuilt_trulens_recorder tru_recorder = get_prebuilt_trulens_recorder(query_engine, app_id="Direct Query Engine") with tru_recorder as recording: for question in eval_questions: response = query_engine.query(question) records, feedback = tru.get_records_and_feedback(app_ids=[]) records.head() # launches on http://localhost:8501/ tru.run_dashboard() # ## Advanced RAG pipeline # ### 1. Sentence Window retrieval from utils import build_sentence_window_index sentence_index = build_sentence_window_index( document, llm, embed_model="local:BAAI/bge-small-en-v1.5", save_dir="sentence_index" ) from utils import get_sentence_window_query_engine sentence_window_engine = get_sentence_window_query_engine(sentence_index) window_response = sentence_window_engine.query( "how do I get started on a personal project in AI?" ) print(str(window_response)) tru.reset_database() tru_recorder_sentence_window = get_prebuilt_trulens_recorder( sentence_window_engine, app_id = "Sentence Window Query Engine" ) for question in eval_questions: with tru_recorder_sentence_window as recording: response = sentence_window_engine.query(question) print(question) print(str(response)) tru.get_leaderboard(app_ids=[]) # launches on http://localhost:8501/ tru.run_dashboard() # ### 2. Auto-merging retrieval from utils import build_automerging_index automerging_index = build_automerging_index( documents, llm, embed_model="local:BAAI/bge-small-en-v1.5", save_dir="merging_index" ) from utils import get_automerging_query_engine automerging_query_engine = get_automerging_query_engine( automerging_index, ) auto_merging_response = automerging_query_engine.query( "How do I build a portfolio of AI projects?" ) print(str(auto_merging_response)) tru.reset_database() tru_recorder_automerging = get_prebuilt_trulens_recorder(automerging_query_engine, app_id="Automerging Query Engine") for question in eval_questions: with tru_recorder_automerging as recording: response = automerging_query_engine.query(question) print(question) print(response) tru.get_leaderboard(app_ids=[]) # launches on http://localhost:8501/ tru.run_dashboard()

[((1239, 1307), 'huggingface_hub.hf_hub_download', 'hf_hub_download', ([], {'repo_id': 'model_name_or_path', 'filename': 'model_basename'}), '(repo_id=model_name_or_path, filename=model_basename)\n', (1254, 1307), False, 'from huggingface_hub import hf_hub_download\n'), ((2628, 2799), 'llama_index.llms.Replicate', 'Replicate', ([], {'model': 'LLAMA_13B_V2_CHAT', 'temperature': '(0.01)', 'context_window': '(4096)', 'completion_to_prompt': 'custom_completion_to_prompt', 'messages_to_prompt': 'messages_to_prompt'}), '(model=LLAMA_13B_V2_CHAT, temperature=0.01, context_window=4096,\n completion_to_prompt=custom_completion_to_prompt, messages_to_prompt=\n messages_to_prompt)\n', (2637, 2799), False, 'from llama_index.llms import Replicate\n'), ((3062, 3148), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': '"""local:BAAI/bge-small-en-v1.5"""'}), "(llm=llm, embed_model=\n 'local:BAAI/bge-small-en-v1.5')\n", (3090, 3148), False, 'from llama_index import ServiceContext, set_global_service_context\n'), ((3158, 3234), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['[document]'], {'service_context': 'service_context'}), '([document], service_context=service_context)\n', (3189, 3234), False, 'from llama_index import VectorStoreIndex\n'), ((3909, 3914), 'trulens_eval.Tru', 'Tru', ([], {}), '()\n', (3912, 3914), False, 'from trulens_eval import Tru\n'), ((4002, 4075), 'utils.get_prebuilt_trulens_recorder', 'get_prebuilt_trulens_recorder', (['query_engine'], {'app_id': '"""Direct Query Engine"""'}), "(query_engine, app_id='Direct Query Engine')\n", (4031, 4075), False, 'from utils import get_prebuilt_trulens_recorder\n'), ((4503, 4621), 'utils.build_sentence_window_index', 'build_sentence_window_index', (['document', 'llm'], {'embed_model': '"""local:BAAI/bge-small-en-v1.5"""', 'save_dir': '"""sentence_index"""'}), "(document, llm, embed_model=\n 'local:BAAI/bge-small-en-v1.5', save_dir='sentence_index')\n", (4530, 4621), False, 'from utils import build_sentence_window_index\n'), ((4713, 4761), 'utils.get_sentence_window_query_engine', 'get_sentence_window_query_engine', (['sentence_index'], {}), '(sentence_index)\n', (4745, 4761), False, 'from utils import get_sentence_window_query_engine\n'), ((4951, 5048), 'utils.get_prebuilt_trulens_recorder', 'get_prebuilt_trulens_recorder', (['sentence_window_engine'], {'app_id': '"""Sentence Window Query Engine"""'}), "(sentence_window_engine, app_id=\n 'Sentence Window Query Engine')\n", (4980, 5048), False, 'from utils import get_prebuilt_trulens_recorder\n'), ((5440, 5554), 'utils.build_automerging_index', 'build_automerging_index', (['documents', 'llm'], {'embed_model': '"""local:BAAI/bge-small-en-v1.5"""', 'save_dir': '"""merging_index"""'}), "(documents, llm, embed_model=\n 'local:BAAI/bge-small-en-v1.5', save_dir='merging_index')\n", (5463, 5554), False, 'from utils import build_automerging_index\n'), ((5644, 5691), 'utils.get_automerging_query_engine', 'get_automerging_query_engine', (['automerging_index'], {}), '(automerging_index)\n', (5672, 5691), False, 'from utils import get_automerging_query_engine\n'), ((5891, 5986), 'utils.get_prebuilt_trulens_recorder', 'get_prebuilt_trulens_recorder', (['automerging_query_engine'], {'app_id': '"""Automerging Query Engine"""'}), "(automerging_query_engine, app_id=\n 'Automerging Query Engine')\n", (5920, 5986), False, 'from utils import get_prebuilt_trulens_recorder\n'), ((545, 569), 'os.path.exists', 'os.path.exists', (['filename'], {}), '(filename)\n', (559, 569), False, 'import os\n'), ((641, 658), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (653, 658), False, 'import requests\n'), ((1386, 1473), 'llama_cpp.Llama', 'Llama', ([], {'model_path': 'model_path', 'n_threads': '(2)', 'n_batch': '(512)', 'n_gpu_layers': '(43)', 'n_ctx': '(4096)'}), '(model_path=model_path, n_threads=2, n_batch=512, n_gpu_layers=43,\n n_ctx=4096)\n', (1391, 1473), False, 'from llama_cpp import Llama\n'), ((1772, 1831), 'transformers.LlamaTokenizer.from_pretrained', 'LlamaTokenizer.from_pretrained', (['"""ChanceFocus/finma-7b-full"""'], {}), "('ChanceFocus/finma-7b-full')\n", (1802, 1831), False, 'from transformers import LlamaTokenizer, LlamaForCausalLM\n'), ((1842, 1927), 'transformers.LlamaForCausalLM.from_pretrained', 'LlamaForCausalLM.from_pretrained', (['"""ChanceFocus/finma-7b-full"""'], {'device_map': '"""auto"""'}), "('ChanceFocus/finma-7b-full', device_map='auto'\n )\n", (1874, 1927), False, 'from transformers import LlamaTokenizer, LlamaForCausalLM\n'), ((2382, 2567), 'llama_index.llms.llama_utils.completion_to_prompt', 'completion_to_prompt', (['completion'], {'system_prompt': '"""You are a Q&A assistant. Your goal is to answer questions as accurately as possible is the instructions and context provided."""'}), "(completion, system_prompt=\n 'You are a Q&A assistant. Your goal is to answer questions as accurately as possible is the instructions and context provided.'\n )\n", (2402, 2567), False, 'from llama_index.llms.llama_utils import messages_to_prompt, completion_to_prompt\n'), ((752, 797), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_files': '[filename]'}), '(input_files=[filename])\n', (773, 797), False, 'from llama_index import SimpleDirectoryReader\n')]

"""Chat service module.""" from llama_index.core.memory import ChatMemoryBuffer from llama_index.core.base.llms.types import ChatMessage, MessageRole from app.api.database.models.message import MessageCreateModel from app.api.services.message_service import MessageService from app.api.services.ingest_service import ingest_service import llama_index.core llama_index.core.set_global_handler("simple") class ChatService: """Chat Service class for chat operations.""" def __init__(self): self.message_service = MessageService() @staticmethod def chat(query: str): """Chat with the document.""" chat_engine = ingest_service.index.as_query_engine( similarity_top_k=5, streaming=True, verbose=False ) streaming_response = chat_engine.query(query) return streaming_response.response_gen def conversation(self, query: str, session_id: str): """Get answer from the chat engine.""" history = self.message_service.get_messages_by_session_id(session_id) chat_history = [] if history.messages: for message in history.messages: chat_history.append( ChatMessage( message=message.message, role=( MessageRole.USER if message.sender == "user" else MessageRole.ASSISTANT ), ) ) memory = ChatMemoryBuffer.from_defaults( chat_history=chat_history, token_limit=8000 ) chat_engine = ingest_service.index.as_chat_engine( chat_mode="context", memory=memory, similarity_top_k=5, verbose=False, system_prompt=( """\ You are a chatbot. You MUST NOT provide any information unless it is in the Context or previous messages or general conversation. If the user ask something you don't know, say that you cannot answer. \ you MUST keep the answers short and simple. \ """ ), ) response = chat_engine.stream_chat(message=query) for token in response.response_gen: yield token self.message_service.create_message( message=MessageCreateModel( session_id=session_id, message=query, sender="user", ) ) self.message_service.create_message( message=MessageCreateModel( session_id=session_id, message=str(response), sender="assistant", ) )

[((532, 548), 'app.api.services.message_service.MessageService', 'MessageService', ([], {}), '()\n', (546, 548), False, 'from app.api.services.message_service import MessageService\n'), ((655, 746), 'app.api.services.ingest_service.ingest_service.index.as_query_engine', 'ingest_service.index.as_query_engine', ([], {'similarity_top_k': '(5)', 'streaming': '(True)', 'verbose': '(False)'}), '(similarity_top_k=5, streaming=True,\n verbose=False)\n', (691, 746), False, 'from app.api.services.ingest_service import ingest_service\n'), ((1542, 1617), 'llama_index.core.memory.ChatMemoryBuffer.from_defaults', 'ChatMemoryBuffer.from_defaults', ([], {'chat_history': 'chat_history', 'token_limit': '(8000)'}), '(chat_history=chat_history, token_limit=8000)\n', (1572, 1617), False, 'from llama_index.core.memory import ChatMemoryBuffer\n'), ((1662, 2080), 'app.api.services.ingest_service.ingest_service.index.as_chat_engine', 'ingest_service.index.as_chat_engine', ([], {'chat_mode': '"""context"""', 'memory': 'memory', 'similarity_top_k': '(5)', 'verbose': '(False)', 'system_prompt': '""" You are a chatbot. You MUST NOT provide any information unless it is in the Context or previous messages or general conversation. If the user ask something you don\'t know, say that you cannot answer. you MUST keep the answers short and simple. """'}), '(chat_mode=\'context\', memory=memory,\n similarity_top_k=5, verbose=False, system_prompt=\n " You are a chatbot. You MUST NOT provide any information unless it is in the Context or previous messages or general conversation. If the user ask something you don\'t know, say that you cannot answer. you MUST keep the answers short and simple. "\n )\n', (1697, 2080), False, 'from app.api.services.ingest_service import ingest_service\n'), ((2374, 2445), 'app.api.database.models.message.MessageCreateModel', 'MessageCreateModel', ([], {'session_id': 'session_id', 'message': 'query', 'sender': '"""user"""'}), "(session_id=session_id, message=query, sender='user')\n", (2392, 2445), False, 'from app.api.database.models.message import MessageCreateModel\n'), ((1208, 1327), 'llama_index.core.base.llms.types.ChatMessage', 'ChatMessage', ([], {'message': 'message.message', 'role': "(MessageRole.USER if message.sender == 'user' else MessageRole.ASSISTANT)"}), "(message=message.message, role=MessageRole.USER if message.\n sender == 'user' else MessageRole.ASSISTANT)\n", (1219, 1327), False, 'from llama_index.core.base.llms.types import ChatMessage, MessageRole\n')]

"""FastAPI app creation, logger configuration and main API routes.""" import sys from typing import Any import llama_index from fastapi import FastAPI from fastapi.openapi.utils import get_openapi from loguru import logger from private_gpt.paths import docs_path from private_gpt.server.chat.chat_router import chat_router from private_gpt.server.chunks.chunks_router import chunks_router from private_gpt.server.completions.completions_router import completions_router from private_gpt.server.embeddings.embeddings_router import embeddings_router from private_gpt.server.health.health_router import health_router from private_gpt.server.ingest.ingest_router import ingest_router from private_gpt.settings.settings import settings # Remove pre-configured logging handler logger.remove(0) # Create a new logging handler same as the pre-configured one but with the extra # attribute `request_id` logger.add( sys.stdout, level="INFO", format=( "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | " "<level>{level: <8}</level> | " "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | " "ID: {extra[request_id]} - <level>{message}</level>" ), ) # Add LlamaIndex simple observability llama_index.set_global_handler("simple") # Start the API with open(docs_path / "description.md") as description_file: description = description_file.read() tags_metadata = [ { "name": "Ingestion", "description": "High-level APIs covering document ingestion -internally " "managing document parsing, splitting," "metadata extraction, embedding generation and storage- and ingested " "documents CRUD." "Each ingested document is identified by an ID that can be used to filter the " "context" "used in *Contextual Completions* and *Context Chunks* APIs.", }, { "name": "Contextual Completions", "description": "High-level APIs covering contextual Chat and Completions. They " "follow OpenAI's format, extending it to " "allow using the context coming from ingested documents to create the " "response. Internally" "manage context retrieval, prompt engineering and the response generation.", }, { "name": "Context Chunks", "description": "Low-level API that given a query return relevant chunks of " "text coming from the ingested" "documents.", }, { "name": "Embeddings", "description": "Low-level API to obtain the vector representation of a given " "text, using an Embeddings model." "Follows OpenAI's embeddings API format.", }, { "name": "Health", "description": "Simple health API to make sure the server is up and running.", }, ] app = FastAPI() def custom_openapi() -> dict[str, Any]: if app.openapi_schema: return app.openapi_schema openapi_schema = get_openapi( title="Momentus GPT", description=description, version="0.1.0", summary="PrivateGPT is a production-ready AI project that allows you to " "ask questions to your documents using the power of Large Language " "Models (LLMs), even in scenarios without Internet connection. " "100% private, no data leaves your execution environment at any point.", contact={ "url": "https://github.com/imartinez/privateGPT", }, license_info={ "name": "Apache 2.0", "url": "https://www.apache.org/licenses/LICENSE-2.0.html", }, routes=app.routes, tags=tags_metadata, ) openapi_schema["info"]["x-logo"] = { "url": "https://lh3.googleusercontent.com/drive-viewer" "/AK7aPaD_iNlMoTquOBsw4boh4tIYxyEuhz6EtEs8nzq3yNkNAK00xGj" "E1KUCmPJSk3TYOjcs6tReG6w_cLu1S7L_gPgT9z52iw=s2560" } app.openapi_schema = openapi_schema return app.openapi_schema app.openapi = custom_openapi # type: ignore[method-assign] app.include_router(completions_router) app.include_router(chat_router) app.include_router(chunks_router) app.include_router(ingest_router) app.include_router(embeddings_router) app.include_router(health_router) if settings.ui.enabled: from private_gpt.ui.ui import mount_in_app mount_in_app(app)

[((774, 790), 'loguru.logger.remove', 'logger.remove', (['(0)'], {}), '(0)\n', (787, 790), False, 'from loguru import logger\n'), ((897, 1147), 'loguru.logger.add', 'logger.add', (['sys.stdout'], {'level': '"""INFO"""', 'format': '"""<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | ID: {extra[request_id]} - <level>{message}</level>"""'}), "(sys.stdout, level='INFO', format=\n '<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> | ID: {extra[request_id]} - <level>{message}</level>'\n )\n", (907, 1147), False, 'from loguru import logger\n'), ((1241, 1281), 'llama_index.set_global_handler', 'llama_index.set_global_handler', (['"""simple"""'], {}), "('simple')\n", (1271, 1281), False, 'import llama_index\n'), ((2819, 2828), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (2826, 2828), False, 'from fastapi import FastAPI\n'), ((2953, 3521), 'fastapi.openapi.utils.get_openapi', 'get_openapi', ([], {'title': '"""Momentus GPT"""', 'description': 'description', 'version': '"""0.1.0"""', 'summary': '"""PrivateGPT is a production-ready AI project that allows you to ask questions to your documents using the power of Large Language Models (LLMs), even in scenarios without Internet connection. 100% private, no data leaves your execution environment at any point."""', 'contact': "{'url': 'https://github.com/imartinez/privateGPT'}", 'license_info': "{'name': 'Apache 2.0', 'url':\n 'https://www.apache.org/licenses/LICENSE-2.0.html'}", 'routes': 'app.routes', 'tags': 'tags_metadata'}), "(title='Momentus GPT', description=description, version='0.1.0',\n summary=\n 'PrivateGPT is a production-ready AI project that allows you to ask questions to your documents using the power of Large Language Models (LLMs), even in scenarios without Internet connection. 100% private, no data leaves your execution environment at any point.'\n , contact={'url': 'https://github.com/imartinez/privateGPT'},\n license_info={'name': 'Apache 2.0', 'url':\n 'https://www.apache.org/licenses/LICENSE-2.0.html'}, routes=app.routes,\n tags=tags_metadata)\n", (2964, 3521), False, 'from fastapi.openapi.utils import get_openapi\n'), ((4319, 4336), 'private_gpt.ui.ui.mount_in_app', 'mount_in_app', (['app'], {}), '(app)\n', (4331, 4336), False, 'from private_gpt.ui.ui import mount_in_app\n')]

get_ipython().run_line_magic('pip', 'install llama-index-llms-openai') get_ipython().system('wget "https://github.com/ppasupat/WikiTableQuestions/releases/download/v1.0.2/WikiTableQuestions-1.0.2-compact.zip" -O data.zip') get_ipython().system('unzip data.zip') import pandas as pd from pathlib import Path data_dir = Path("./WikiTableQuestions/csv/200-csv") csv_files = sorted([f for f in data_dir.glob("*.csv")]) dfs = [] for csv_file in csv_files: print(f"processing file: {csv_file}") try: df = pd.read_csv(csv_file) dfs.append(df) except Exception as e: print(f"Error parsing {csv_file}: {str(e)}") tableinfo_dir = "WikiTableQuestions_TableInfo" get_ipython().system('mkdir {tableinfo_dir}') from llama_index.core.program import LLMTextCompletionProgram from llama_index.core.bridge.pydantic import BaseModel, Field from llama_index.llms.openai import OpenAI class TableInfo(BaseModel): """Information regarding a structured table.""" table_name: str = Field( ..., description="table name (must be underscores and NO spaces)" ) table_summary: str = Field( ..., description="short, concise summary/caption of the table" ) prompt_str = """\ Give me a summary of the table with the following JSON format. - The table name must be unique to the table and describe it while being concise. - Do NOT output a generic table name (e.g. table, my_table). Do NOT make the table name one of the following: {exclude_table_name_list} Table: {table_str} Summary: """ program = LLMTextCompletionProgram.from_defaults( output_cls=TableInfo, llm=OpenAI(model="gpt-3.5-turbo"), prompt_template_str=prompt_str, ) import json def _get_tableinfo_with_index(idx: int) -> str: results_gen = Path(tableinfo_dir).glob(f"{idx}_*") results_list = list(results_gen) if len(results_list) == 0: return None elif len(results_list) == 1: path = results_list[0] return TableInfo.parse_file(path) else: raise ValueError( f"More than one file matching index: {list(results_gen)}" ) table_names = set() table_infos = [] for idx, df in enumerate(dfs): table_info = _get_tableinfo_with_index(idx) if table_info: table_infos.append(table_info) else: while True: df_str = df.head(10).to_csv() table_info = program( table_str=df_str, exclude_table_name_list=str(list(table_names)), ) table_name = table_info.table_name print(f"Processed table: {table_name}") if table_name not in table_names: table_names.add(table_name) break else: print(f"Table name {table_name} already exists, trying again.") pass out_file = f"{tableinfo_dir}/{idx}_{table_name}.json" json.dump(table_info.dict(), open(out_file, "w")) table_infos.append(table_info) from sqlalchemy import ( create_engine, MetaData, Table, Column, String, Integer, ) import re def sanitize_column_name(col_name): return re.sub(r"\W+", "_", col_name) def create_table_from_dataframe( df: pd.DataFrame, table_name: str, engine, metadata_obj ): sanitized_columns = {col: sanitize_column_name(col) for col in df.columns} df = df.rename(columns=sanitized_columns) columns = [ Column(col, String if dtype == "object" else Integer) for col, dtype in zip(df.columns, df.dtypes) ] table = Table(table_name, metadata_obj, *columns) metadata_obj.create_all(engine) with engine.connect() as conn: for _, row in df.iterrows(): insert_stmt = table.insert().values(**row.to_dict()) conn.execute(insert_stmt) conn.commit() engine = create_engine("sqlite:///:memory:") metadata_obj = MetaData() for idx, df in enumerate(dfs): tableinfo = _get_tableinfo_with_index(idx) print(f"Creating table: {tableinfo.table_name}") create_table_from_dataframe(df, tableinfo.table_name, engine, metadata_obj) import phoenix as px import llama_index.core px.launch_app() llama_index.core.set_global_handler("arize_phoenix") from llama_index.core.objects import ( SQLTableNodeMapping, ObjectIndex, SQLTableSchema, ) from llama_index.core import SQLDatabase, VectorStoreIndex sql_database = SQLDatabase(engine) table_node_mapping = SQLTableNodeMapping(sql_database) table_schema_objs = [ SQLTableSchema(table_name=t.table_name, context_str=t.table_summary) for t in table_infos ] # add a SQLTableSchema for each table obj_index = ObjectIndex.from_objects( table_schema_objs, table_node_mapping, VectorStoreIndex, ) obj_retriever = obj_index.as_retriever(similarity_top_k=3) from llama_index.core.retrievers import SQLRetriever from typing import List from llama_index.core.query_pipeline import FnComponent sql_retriever = SQLRetriever(sql_database) def get_table_context_str(table_schema_objs: List[SQLTableSchema]): """Get table context string.""" context_strs = [] for table_schema_obj in table_schema_objs: table_info = sql_database.get_single_table_info( table_schema_obj.table_name ) if table_schema_obj.context_str: table_opt_context = " The table description is: " table_opt_context += table_schema_obj.context_str table_info += table_opt_context context_strs.append(table_info) return "\n\n".join(context_strs) table_parser_component = FnComponent(fn=get_table_context_str) from llama_index.core.prompts.default_prompts import DEFAULT_TEXT_TO_SQL_PROMPT from llama_index.core import PromptTemplate from llama_index.core.query_pipeline import FnComponent from llama_index.core.llms import ChatResponse def parse_response_to_sql(response: ChatResponse) -> str: """Parse response to SQL.""" response = response.message.content sql_query_start = response.find("SQLQuery:") if sql_query_start != -1: response = response[sql_query_start:] if response.startswith("SQLQuery:"): response = response[len("SQLQuery:") :] sql_result_start = response.find("SQLResult:") if sql_result_start != -1: response = response[:sql_result_start] return response.strip().strip("```").strip() sql_parser_component = FnComponent(fn=parse_response_to_sql) text2sql_prompt = DEFAULT_TEXT_TO_SQL_PROMPT.partial_format( dialect=engine.dialect.name ) print(text2sql_prompt.template) response_synthesis_prompt_str = ( "Given an input question, synthesize a response from the query results.\n" "Query: {query_str}\n" "SQL: {sql_query}\n" "SQL Response: {context_str}\n" "Response: " ) response_synthesis_prompt = PromptTemplate( response_synthesis_prompt_str, ) llm = OpenAI(model="gpt-3.5-turbo") from llama_index.core.query_pipeline import ( QueryPipeline as QP, Link, InputComponent, CustomQueryComponent, ) qp = QP( modules={ "input": InputComponent(), "table_retriever": obj_retriever, "table_output_parser": table_parser_component, "text2sql_prompt": text2sql_prompt, "text2sql_llm": llm, "sql_output_parser": sql_parser_component, "sql_retriever": sql_retriever, "response_synthesis_prompt": response_synthesis_prompt, "response_synthesis_llm": llm, }, verbose=True, ) qp.add_chain(["input", "table_retriever", "table_output_parser"]) qp.add_link("input", "text2sql_prompt", dest_key="query_str") qp.add_link("table_output_parser", "text2sql_prompt", dest_key="schema") qp.add_chain( ["text2sql_prompt", "text2sql_llm", "sql_output_parser", "sql_retriever"] ) qp.add_link( "sql_output_parser", "response_synthesis_prompt", dest_key="sql_query" ) qp.add_link( "sql_retriever", "response_synthesis_prompt", dest_key="context_str" ) qp.add_link("input", "response_synthesis_prompt", dest_key="query_str") qp.add_link("response_synthesis_prompt", "response_synthesis_llm") from pyvis.network import Network net = Network(notebook=True, cdn_resources="in_line", directed=True) net.from_nx(qp.dag) net.show("text2sql_dag.html") response = qp.run( query="What was the year that The Notorious B.I.G was signed to Bad Boy?" ) print(str(response)) response = qp.run(query="Who won best director in the 1972 academy awards") print(str(response)) response = qp.run(query="What was the term of Pasquale Preziosa?") print(str(response)) from llama_index.core import VectorStoreIndex, load_index_from_storage from sqlalchemy import text from llama_index.core.schema import TextNode from llama_index.core import StorageContext import os from pathlib import Path from typing import Dict def index_all_tables( sql_database: SQLDatabase, table_index_dir: str = "table_index_dir" ) -> Dict[str, VectorStoreIndex]: """Index all tables.""" if not Path(table_index_dir).exists(): os.makedirs(table_index_dir) vector_index_dict = {} engine = sql_database.engine for table_name in sql_database.get_usable_table_names(): print(f"Indexing rows in table: {table_name}") if not os.path.exists(f"{table_index_dir}/{table_name}"): with engine.connect() as conn: cursor = conn.execute(text(f'SELECT * FROM "{table_name}"')) result = cursor.fetchall() row_tups = [] for row in result: row_tups.append(tuple(row)) nodes = [TextNode(text=str(t)) for t in row_tups] index = VectorStoreIndex(nodes) index.set_index_id("vector_index") index.storage_context.persist(f"{table_index_dir}/{table_name}") else: storage_context = StorageContext.from_defaults( persist_dir=f"{table_index_dir}/{table_name}" ) index = load_index_from_storage( storage_context, index_id="vector_index" ) vector_index_dict[table_name] = index return vector_index_dict vector_index_dict = index_all_tables(sql_database) test_retriever = vector_index_dict["Bad_Boy_Artists"].as_retriever( similarity_top_k=1 ) nodes = test_retriever.retrieve("P. Diddy") print(nodes[0].get_content()) from llama_index.core.retrievers import SQLRetriever from typing import List from llama_index.core.query_pipeline import FnComponent sql_retriever = SQLRetriever(sql_database) def get_table_context_and_rows_str( query_str: str, table_schema_objs: List[SQLTableSchema] ): """Get table context string.""" context_strs = [] for table_schema_obj in table_schema_objs: table_info = sql_database.get_single_table_info( table_schema_obj.table_name ) if table_schema_obj.context_str: table_opt_context = " The table description is: " table_opt_context += table_schema_obj.context_str table_info += table_opt_context vector_retriever = vector_index_dict[ table_schema_obj.table_name ].as_retriever(similarity_top_k=2) relevant_nodes = vector_retriever.retrieve(query_str) if len(relevant_nodes) > 0: table_row_context = "\nHere are some relevant example rows (values in the same order as columns above)\n" for node in relevant_nodes: table_row_context += str(node.get_content()) + "\n" table_info += table_row_context context_strs.append(table_info) return "\n\n".join(context_strs) table_parser_component = FnComponent(fn=get_table_context_and_rows_str) from llama_index.core.query_pipeline import ( QueryPipeline as QP, Link, InputComponent, CustomQueryComponent, ) qp = QP( modules={ "input": InputComponent(), "table_retriever": obj_retriever, "table_output_parser": table_parser_component, "text2sql_prompt": text2sql_prompt, "text2sql_llm": llm, "sql_output_parser": sql_parser_component, "sql_retriever": sql_retriever, "response_synthesis_prompt": response_synthesis_prompt, "response_synthesis_llm": llm, }, verbose=True, ) qp.add_link("input", "table_retriever") qp.add_link("input", "table_output_parser", dest_key="query_str") qp.add_link( "table_retriever", "table_output_parser", dest_key="table_schema_objs" ) qp.add_link("input", "text2sql_prompt", dest_key="query_str") qp.add_link("table_output_parser", "text2sql_prompt", dest_key="schema") qp.add_chain( ["text2sql_prompt", "text2sql_llm", "sql_output_parser", "sql_retriever"] ) qp.add_link( "sql_output_parser", "response_synthesis_prompt", dest_key="sql_query" ) qp.add_link( "sql_retriever", "response_synthesis_prompt", dest_key="context_str" ) qp.add_link("input", "response_synthesis_prompt", dest_key="query_str") qp.add_link("response_synthesis_prompt", "response_synthesis_llm") from pyvis.network import Network net = Network(notebook=True, cdn_resources="in_line", directed=True) net.from_nx(qp.dag) net.show("text2sql_dag.html") response = qp.run( query="What was the year that The Notorious BIG was signed to Bad Boy?" ) print(str(response))

[((323, 363), 'pathlib.Path', 'Path', (['"""./WikiTableQuestions/csv/200-csv"""'], {}), "('./WikiTableQuestions/csv/200-csv')\n", (327, 363), False, 'from pathlib import Path\n'), ((3874, 3909), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite:///:memory:"""'], {}), "('sqlite:///:memory:')\n", (3887, 3909), False, 'from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer\n'), ((3925, 3935), 'sqlalchemy.MetaData', 'MetaData', ([], {}), '()\n', (3933, 3935), False, 'from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer\n'), ((4195, 4210), 'phoenix.launch_app', 'px.launch_app', ([], {}), '()\n', (4208, 4210), True, 'import phoenix as px\n'), ((4446, 4465), 'llama_index.core.SQLDatabase', 'SQLDatabase', (['engine'], {}), '(engine)\n', (4457, 4465), False, 'from llama_index.core import SQLDatabase, VectorStoreIndex\n'), ((4488, 4521), 'llama_index.core.objects.SQLTableNodeMapping', 'SQLTableNodeMapping', (['sql_database'], {}), '(sql_database)\n', (4507, 4521), False, 'from llama_index.core.objects import SQLTableNodeMapping, ObjectIndex, SQLTableSchema\n'), ((4696, 4781), 'llama_index.core.objects.ObjectIndex.from_objects', 'ObjectIndex.from_objects', (['table_schema_objs', 'table_node_mapping', 'VectorStoreIndex'], {}), '(table_schema_objs, table_node_mapping,\n VectorStoreIndex)\n', (4720, 4781), False, 'from llama_index.core.objects import SQLTableNodeMapping, ObjectIndex, SQLTableSchema\n'), ((5005, 5031), 'llama_index.core.retrievers.SQLRetriever', 'SQLRetriever', (['sql_database'], {}), '(sql_database)\n', (5017, 5031), False, 'from llama_index.core.retrievers import SQLRetriever\n'), ((5628, 5665), 'llama_index.core.query_pipeline.FnComponent', 'FnComponent', ([], {'fn': 'get_table_context_str'}), '(fn=get_table_context_str)\n', (5639, 5665), False, 'from llama_index.core.query_pipeline import FnComponent\n'), ((6454, 6491), 'llama_index.core.query_pipeline.FnComponent', 'FnComponent', ([], {'fn': 'parse_response_to_sql'}), '(fn=parse_response_to_sql)\n', (6465, 6491), False, 'from llama_index.core.query_pipeline import FnComponent\n'), ((6511, 6581), 'llama_index.core.prompts.default_prompts.DEFAULT_TEXT_TO_SQL_PROMPT.partial_format', 'DEFAULT_TEXT_TO_SQL_PROMPT.partial_format', ([], {'dialect': 'engine.dialect.name'}), '(dialect=engine.dialect.name)\n', (6552, 6581), False, 'from llama_index.core.prompts.default_prompts import DEFAULT_TEXT_TO_SQL_PROMPT\n'), ((6871, 6916), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['response_synthesis_prompt_str'], {}), '(response_synthesis_prompt_str)\n', (6885, 6916), False, 'from llama_index.core import PromptTemplate\n'), ((6932, 6961), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (6938, 6961), False, 'from llama_index.llms.openai import OpenAI\n'), ((8202, 8264), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'cdn_resources': '"""in_line"""', 'directed': '(True)'}), "(notebook=True, cdn_resources='in_line', directed=True)\n", (8209, 8264), False, 'from pyvis.network import Network\n'), ((10585, 10611), 'llama_index.core.retrievers.SQLRetriever', 'SQLRetriever', (['sql_database'], {}), '(sql_database)\n', (10597, 10611), False, 'from llama_index.core.retrievers import SQLRetriever\n'), ((11737, 11783), 'llama_index.core.query_pipeline.FnComponent', 'FnComponent', ([], {'fn': 'get_table_context_and_rows_str'}), '(fn=get_table_context_and_rows_str)\n', (11748, 11783), False, 'from llama_index.core.query_pipeline import FnComponent\n'), ((13153, 13215), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'cdn_resources': '"""in_line"""', 'directed': '(True)'}), "(notebook=True, cdn_resources='in_line', directed=True)\n", (13160, 13215), False, 'from pyvis.network import Network\n'), ((1015, 1087), 'llama_index.core.bridge.pydantic.Field', 'Field', (['...'], {'description': '"""table name (must be underscores and NO spaces)"""'}), "(..., description='table name (must be underscores and NO spaces)')\n", (1020, 1087), False, 'from llama_index.core.bridge.pydantic import BaseModel, Field\n'), ((1127, 1196), 'llama_index.core.bridge.pydantic.Field', 'Field', (['...'], {'description': '"""short, concise summary/caption of the table"""'}), "(..., description='short, concise summary/caption of the table')\n", (1132, 1196), False, 'from llama_index.core.bridge.pydantic import BaseModel, Field\n'), ((3182, 3211), 're.sub', 're.sub', (['"""\\\\W+"""', '"""_"""', 'col_name'], {}), "('\\\\W+', '_', col_name)\n", (3188, 3211), False, 'import re\n'), ((3586, 3627), 'sqlalchemy.Table', 'Table', (['table_name', 'metadata_obj', '*columns'], {}), '(table_name, metadata_obj, *columns)\n', (3591, 3627), False, 'from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer\n'), ((4548, 4616), 'llama_index.core.objects.SQLTableSchema', 'SQLTableSchema', ([], {'table_name': 't.table_name', 'context_str': 't.table_summary'}), '(table_name=t.table_name, context_str=t.table_summary)\n', (4562, 4616), False, 'from llama_index.core.objects import SQLTableNodeMapping, ObjectIndex, SQLTableSchema\n'), ((520, 541), 'pandas.read_csv', 'pd.read_csv', (['csv_file'], {}), '(csv_file)\n', (531, 541), True, 'import pandas as pd\n'), ((1634, 1663), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (1640, 1663), False, 'from llama_index.llms.openai import OpenAI\n'), ((3460, 3513), 'sqlalchemy.Column', 'Column', (['col', "(String if dtype == 'object' else Integer)"], {}), "(col, String if dtype == 'object' else Integer)\n", (3466, 3513), False, 'from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer\n'), ((9087, 9115), 'os.makedirs', 'os.makedirs', (['table_index_dir'], {}), '(table_index_dir)\n', (9098, 9115), False, 'import os\n'), ((1785, 1804), 'pathlib.Path', 'Path', (['tableinfo_dir'], {}), '(tableinfo_dir)\n', (1789, 1804), False, 'from pathlib import Path\n'), ((7135, 7151), 'llama_index.core.query_pipeline.InputComponent', 'InputComponent', ([], {}), '()\n', (7149, 7151), False, 'from llama_index.core.query_pipeline import QueryPipeline as QP, Link, InputComponent, CustomQueryComponent\n'), ((9308, 9357), 'os.path.exists', 'os.path.exists', (['f"""{table_index_dir}/{table_name}"""'], {}), "(f'{table_index_dir}/{table_name}')\n", (9322, 9357), False, 'import os\n'), ((9719, 9742), 'llama_index.core.VectorStoreIndex', 'VectorStoreIndex', (['nodes'], {}), '(nodes)\n', (9735, 9742), False, 'from llama_index.core import VectorStoreIndex, load_index_from_storage\n'), ((9912, 9987), 'llama_index.core.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'f"""{table_index_dir}/{table_name}"""'}), "(persist_dir=f'{table_index_dir}/{table_name}')\n", (9940, 9987), False, 'from llama_index.core import StorageContext\n'), ((10038, 10103), 'llama_index.core.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {'index_id': '"""vector_index"""'}), "(storage_context, index_id='vector_index')\n", (10061, 10103), False, 'from llama_index.core import VectorStoreIndex, load_index_from_storage\n'), ((11957, 11973), 'llama_index.core.query_pipeline.InputComponent', 'InputComponent', ([], {}), '()\n', (11971, 11973), False, 'from llama_index.core.query_pipeline import QueryPipeline as QP, Link, InputComponent, CustomQueryComponent\n'), ((9047, 9068), 'pathlib.Path', 'Path', (['table_index_dir'], {}), '(table_index_dir)\n', (9051, 9068), False, 'from pathlib import Path\n'), ((9440, 9477), 'sqlalchemy.text', 'text', (['f"""SELECT * FROM "{table_name}\\""""'], {}), '(f\'SELECT * FROM "{table_name}"\')\n', (9444, 9477), False, 'from sqlalchemy import text\n')]

from llama_index.core import SQLDatabase from sqlalchemy import ( create_engine, MetaData, Table, Column, String, Integer, select, column, ) engine = create_engine("sqlite:///chinook.db") sql_database = SQLDatabase(engine) from llama_index.core.query_pipeline import QueryPipeline get_ipython().run_line_magic('pip', 'install llama-index-llms-openai') get_ipython().system('curl "https://www.sqlitetutorial.net/wp-content/uploads/2018/03/chinook.zip" -O ./chinook.zip') get_ipython().system('unzip ./chinook.zip') from llama_index.core.settings import Settings from llama_index.core.callbacks import CallbackManager callback_manager = CallbackManager() Settings.callback_manager = callback_manager import phoenix as px import llama_index.core px.launch_app() llama_index.core.set_global_handler("arize_phoenix") from llama_index.core.query_engine import NLSQLTableQueryEngine from llama_index.core.tools import QueryEngineTool sql_query_engine = NLSQLTableQueryEngine( sql_database=sql_database, tables=["albums", "tracks", "artists"], verbose=True, ) sql_tool = QueryEngineTool.from_defaults( query_engine=sql_query_engine, name="sql_tool", description=( "Useful for translating a natural language query into a SQL query" ), ) from llama_index.core.query_pipeline import QueryPipeline as QP qp = QP(verbose=True) from llama_index.core.agent.react.types import ( ActionReasoningStep, ObservationReasoningStep, ResponseReasoningStep, ) from llama_index.core.agent import Task, AgentChatResponse from llama_index.core.query_pipeline import ( AgentInputComponent, AgentFnComponent, CustomAgentComponent, QueryComponent, ToolRunnerComponent, ) from llama_index.core.llms import MessageRole from typing import Dict, Any, Optional, Tuple, List, cast def agent_input_fn(task: Task, state: Dict[str, Any]) -> Dict[str, Any]: """Agent input function. Returns: A Dictionary of output keys and values. If you are specifying src_key when defining links between this component and other components, make sure the src_key matches the specified output_key. """ if "current_reasoning" not in state: state["current_reasoning"] = [] reasoning_step = ObservationReasoningStep(observation=task.input) state["current_reasoning"].append(reasoning_step) return {"input": task.input} agent_input_component = AgentInputComponent(fn=agent_input_fn) from llama_index.core.agent import ReActChatFormatter from llama_index.core.query_pipeline import InputComponent, Link from llama_index.core.llms import ChatMessage from llama_index.core.tools import BaseTool def react_prompt_fn( task: Task, state: Dict[str, Any], input: str, tools: List[BaseTool] ) -> List[ChatMessage]: chat_formatter = ReActChatFormatter() return chat_formatter.format( tools, chat_history=task.memory.get() + state["memory"].get_all(), current_reasoning=state["current_reasoning"], ) react_prompt_component = AgentFnComponent( fn=react_prompt_fn, partial_dict={"tools": [sql_tool]} ) from typing import Set, Optional from llama_index.core.agent.react.output_parser import ReActOutputParser from llama_index.core.llms import ChatResponse from llama_index.core.agent.types import Task def parse_react_output_fn( task: Task, state: Dict[str, Any], chat_response: ChatResponse ): """Parse ReAct output into a reasoning step.""" output_parser = ReActOutputParser() reasoning_step = output_parser.parse(chat_response.message.content) return {"done": reasoning_step.is_done, "reasoning_step": reasoning_step} parse_react_output = AgentFnComponent(fn=parse_react_output_fn) def run_tool_fn( task: Task, state: Dict[str, Any], reasoning_step: ActionReasoningStep ): """Run tool and process tool output.""" tool_runner_component = ToolRunnerComponent( [sql_tool], callback_manager=task.callback_manager ) tool_output = tool_runner_component.run_component( tool_name=reasoning_step.action, tool_input=reasoning_step.action_input, ) observation_step = ObservationReasoningStep(observation=str(tool_output)) state["current_reasoning"].append(observation_step) return {"response_str": observation_step.get_content(), "is_done": False} run_tool = AgentFnComponent(fn=run_tool_fn) def process_response_fn( task: Task, state: Dict[str, Any], response_step: ResponseReasoningStep ): """Process response.""" state["current_reasoning"].append(response_step) response_str = response_step.response state["memory"].put(ChatMessage(content=task.input, role=MessageRole.USER)) state["memory"].put( ChatMessage(content=response_str, role=MessageRole.ASSISTANT) ) return {"response_str": response_str, "is_done": True} process_response = AgentFnComponent(fn=process_response_fn) def process_agent_response_fn( task: Task, state: Dict[str, Any], response_dict: dict ): """Process agent response.""" return ( AgentChatResponse(response_dict["response_str"]), response_dict["is_done"], ) process_agent_response = AgentFnComponent(fn=process_agent_response_fn) from llama_index.core.query_pipeline import QueryPipeline as QP from llama_index.llms.openai import OpenAI qp.add_modules( { "agent_input": agent_input_component, "react_prompt": react_prompt_component, "llm": OpenAI(model="gpt-4-1106-preview"), "react_output_parser": parse_react_output, "run_tool": run_tool, "process_response": process_response, "process_agent_response": process_agent_response, } ) qp.add_chain(["agent_input", "react_prompt", "llm", "react_output_parser"]) qp.add_link( "react_output_parser", "run_tool", condition_fn=lambda x: not x["done"], input_fn=lambda x: x["reasoning_step"], ) qp.add_link( "react_output_parser", "process_response", condition_fn=lambda x: x["done"], input_fn=lambda x: x["reasoning_step"], ) qp.add_link("process_response", "process_agent_response") qp.add_link("run_tool", "process_agent_response") from pyvis.network import Network net = Network(notebook=True, cdn_resources="in_line", directed=True) net.from_nx(qp.clean_dag) net.show("agent_dag.html") from llama_index.core.agent import QueryPipelineAgentWorker, AgentRunner from llama_index.core.callbacks import CallbackManager agent_worker = QueryPipelineAgentWorker(qp) agent = AgentRunner( agent_worker, callback_manager=CallbackManager([]), verbose=True ) task = agent.create_task( "What are some tracks from the artist AC/DC? Limit it to 3" ) step_output = agent.run_step(task.task_id) step_output = agent.run_step(task.task_id) step_output.is_last response = agent.finalize_response(task.task_id) print(str(response)) agent.reset() response = agent.chat( "What are some tracks from the artist AC/DC? Limit it to 3" ) print(str(response)) from llama_index.llms.openai import OpenAI llm = OpenAI(model="gpt-4-1106-preview") from llama_index.core.agent import Task, AgentChatResponse from typing import Dict, Any from llama_index.core.query_pipeline import ( AgentInputComponent, AgentFnComponent, ) def agent_input_fn(task: Task, state: Dict[str, Any]) -> Dict: """Agent input function.""" if "convo_history" not in state: state["convo_history"] = [] state["count"] = 0 state["convo_history"].append(f"User: {task.input}") convo_history_str = "\n".join(state["convo_history"]) or "None" return {"input": task.input, "convo_history": convo_history_str} agent_input_component = AgentInputComponent(fn=agent_input_fn) from llama_index.core import PromptTemplate retry_prompt_str = """\ You are trying to generate a proper natural language query given a user input. This query will then be interpreted by a downstream text-to-SQL agent which will convert the query to a SQL statement. If the agent triggers an error, then that will be reflected in the current conversation history (see below). If the conversation history is None, use the user input. If its not None, generate a new SQL query that avoids the problems of the previous SQL query. Input: {input} Convo history (failed attempts): {convo_history} New input: """ retry_prompt = PromptTemplate(retry_prompt_str) from llama_index.core import Response from typing import Tuple validate_prompt_str = """\ Given the user query, validate whether the inferred SQL query and response from executing the query is correct and answers the query. Answer with YES or NO. Query: {input} Inferred SQL query: {sql_query} SQL Response: {sql_response} Result: """ validate_prompt = PromptTemplate(validate_prompt_str) MAX_ITER = 3 def agent_output_fn( task: Task, state: Dict[str, Any], output: Response ) -> Tuple[AgentChatResponse, bool]: """Agent output component.""" print(f"> Inferred SQL Query: {output.metadata['sql_query']}") print(f"> SQL Response: {str(output)}") state["convo_history"].append( f"Assistant (inferred SQL query): {output.metadata['sql_query']}" ) state["convo_history"].append(f"Assistant (response): {str(output)}") validate_prompt_partial = validate_prompt.as_query_component( partial={ "sql_query": output.metadata["sql_query"], "sql_response": str(output), } ) qp = QP(chain=[validate_prompt_partial, llm]) validate_output = qp.run(input=task.input) state["count"] += 1 is_done = False if state["count"] >= MAX_ITER: is_done = True if "YES" in validate_output.message.content: is_done = True return AgentChatResponse(response=str(output)), is_done agent_output_component = AgentFnComponent(fn=agent_output_fn) from llama_index.core.query_pipeline import ( QueryPipeline as QP, Link, InputComponent, ) qp = QP( modules={ "input": agent_input_component, "retry_prompt": retry_prompt, "llm": llm, "sql_query_engine": sql_query_engine, "output_component": agent_output_component, }, verbose=True, ) qp.add_link("input", "retry_prompt", src_key="input", dest_key="input") qp.add_link( "input", "retry_prompt", src_key="convo_history", dest_key="convo_history" ) qp.add_chain(["retry_prompt", "llm", "sql_query_engine", "output_component"]) from pyvis.network import Network net = Network(notebook=True, cdn_resources="in_line", directed=True) net.from_nx(qp.dag) net.show("agent_dag.html") from llama_index.core.agent import QueryPipelineAgentWorker, AgentRunner from llama_index.core.callbacks import CallbackManager agent_worker = QueryPipelineAgentWorker(qp) agent = AgentRunner( agent_worker, callback_manager=CallbackManager(), verbose=False ) response = agent.chat( "How many albums did the artist who wrote 'Restless and Wild' release? (answer should be non-zero)?" ) print(str(response))

[((183, 220), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite:///chinook.db"""'], {}), "('sqlite:///chinook.db')\n", (196, 220), False, 'from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer, select, column\n'), ((236, 255), 'llama_index.core.SQLDatabase', 'SQLDatabase', (['engine'], {}), '(engine)\n', (247, 255), False, 'from llama_index.core import SQLDatabase\n'), ((679, 696), 'llama_index.core.callbacks.CallbackManager', 'CallbackManager', ([], {}), '()\n', (694, 696), False, 'from llama_index.core.callbacks import CallbackManager\n'), ((790, 805), 'phoenix.launch_app', 'px.launch_app', ([], {}), '()\n', (803, 805), True, 'import phoenix as px\n'), ((997, 1103), 'llama_index.core.query_engine.NLSQLTableQueryEngine', 'NLSQLTableQueryEngine', ([], {'sql_database': 'sql_database', 'tables': "['albums', 'tracks', 'artists']", 'verbose': '(True)'}), "(sql_database=sql_database, tables=['albums', 'tracks',\n 'artists'], verbose=True)\n", (1018, 1103), False, 'from llama_index.core.query_engine import NLSQLTableQueryEngine\n'), ((1126, 1293), 'llama_index.core.tools.QueryEngineTool.from_defaults', 'QueryEngineTool.from_defaults', ([], {'query_engine': 'sql_query_engine', 'name': '"""sql_tool"""', 'description': '"""Useful for translating a natural language query into a SQL query"""'}), "(query_engine=sql_query_engine, name=\n 'sql_tool', description=\n 'Useful for translating a natural language query into a SQL query')\n", (1155, 1293), False, 'from llama_index.core.tools import QueryEngineTool\n'), ((1388, 1404), 'llama_index.core.query_pipeline.QueryPipeline', 'QP', ([], {'verbose': '(True)'}), '(verbose=True)\n', (1390, 1404), True, 'from llama_index.core.query_pipeline import QueryPipeline as QP, Link, InputComponent\n'), ((2476, 2514), 'llama_index.core.query_pipeline.AgentInputComponent', 'AgentInputComponent', ([], {'fn': 'agent_input_fn'}), '(fn=agent_input_fn)\n', (2495, 2514), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((3093, 3165), 'llama_index.core.query_pipeline.AgentFnComponent', 'AgentFnComponent', ([], {'fn': 'react_prompt_fn', 'partial_dict': "{'tools': [sql_tool]}"}), "(fn=react_prompt_fn, partial_dict={'tools': [sql_tool]})\n", (3109, 3165), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((3738, 3780), 'llama_index.core.query_pipeline.AgentFnComponent', 'AgentFnComponent', ([], {'fn': 'parse_react_output_fn'}), '(fn=parse_react_output_fn)\n', (3754, 3780), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((4412, 4444), 'llama_index.core.query_pipeline.AgentFnComponent', 'AgentFnComponent', ([], {'fn': 'run_tool_fn'}), '(fn=run_tool_fn)\n', (4428, 4444), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((4936, 4976), 'llama_index.core.query_pipeline.AgentFnComponent', 'AgentFnComponent', ([], {'fn': 'process_response_fn'}), '(fn=process_response_fn)\n', (4952, 4976), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((5244, 5290), 'llama_index.core.query_pipeline.AgentFnComponent', 'AgentFnComponent', ([], {'fn': 'process_agent_response_fn'}), '(fn=process_agent_response_fn)\n', (5260, 5290), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((6286, 6348), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'cdn_resources': '"""in_line"""', 'directed': '(True)'}), "(notebook=True, cdn_resources='in_line', directed=True)\n", (6293, 6348), False, 'from pyvis.network import Network\n'), ((6549, 6577), 'llama_index.core.agent.QueryPipelineAgentWorker', 'QueryPipelineAgentWorker', (['qp'], {}), '(qp)\n', (6573, 6577), False, 'from llama_index.core.agent import QueryPipelineAgentWorker, AgentRunner\n'), ((7133, 7167), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4-1106-preview"""'}), "(model='gpt-4-1106-preview')\n", (7139, 7167), False, 'from llama_index.llms.openai import OpenAI\n'), ((7770, 7808), 'llama_index.core.query_pipeline.AgentInputComponent', 'AgentInputComponent', ([], {'fn': 'agent_input_fn'}), '(fn=agent_input_fn)\n', (7789, 7808), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((8437, 8469), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['retry_prompt_str'], {}), '(retry_prompt_str)\n', (8451, 8469), False, 'from llama_index.core import PromptTemplate\n'), ((8829, 8864), 'llama_index.core.PromptTemplate', 'PromptTemplate', (['validate_prompt_str'], {}), '(validate_prompt_str)\n', (8843, 8864), False, 'from llama_index.core import PromptTemplate\n'), ((9886, 9922), 'llama_index.core.query_pipeline.AgentFnComponent', 'AgentFnComponent', ([], {'fn': 'agent_output_fn'}), '(fn=agent_output_fn)\n', (9902, 9922), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent\n'), ((10034, 10224), 'llama_index.core.query_pipeline.QueryPipeline', 'QP', ([], {'modules': "{'input': agent_input_component, 'retry_prompt': retry_prompt, 'llm': llm,\n 'sql_query_engine': sql_query_engine, 'output_component':\n agent_output_component}", 'verbose': '(True)'}), "(modules={'input': agent_input_component, 'retry_prompt': retry_prompt,\n 'llm': llm, 'sql_query_engine': sql_query_engine, 'output_component':\n agent_output_component}, verbose=True)\n", (10036, 10224), True, 'from llama_index.core.query_pipeline import QueryPipeline as QP, Link, InputComponent\n'), ((10563, 10625), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'cdn_resources': '"""in_line"""', 'directed': '(True)'}), "(notebook=True, cdn_resources='in_line', directed=True)\n", (10570, 10625), False, 'from pyvis.network import Network\n'), ((10820, 10848), 'llama_index.core.agent.QueryPipelineAgentWorker', 'QueryPipelineAgentWorker', (['qp'], {}), '(qp)\n', (10844, 10848), False, 'from llama_index.core.agent import QueryPipelineAgentWorker, AgentRunner\n'), ((2314, 2362), 'llama_index.core.agent.react.types.ObservationReasoningStep', 'ObservationReasoningStep', ([], {'observation': 'task.input'}), '(observation=task.input)\n', (2338, 2362), False, 'from llama_index.core.agent.react.types import ActionReasoningStep, ObservationReasoningStep, ResponseReasoningStep\n'), ((2868, 2888), 'llama_index.core.agent.ReActChatFormatter', 'ReActChatFormatter', ([], {}), '()\n', (2886, 2888), False, 'from llama_index.core.agent import ReActChatFormatter\n'), ((3545, 3564), 'llama_index.core.agent.react.output_parser.ReActOutputParser', 'ReActOutputParser', ([], {}), '()\n', (3562, 3564), False, 'from llama_index.core.agent.react.output_parser import ReActOutputParser\n'), ((3950, 4021), 'llama_index.core.query_pipeline.ToolRunnerComponent', 'ToolRunnerComponent', (['[sql_tool]'], {'callback_manager': 'task.callback_manager'}), '([sql_tool], callback_manager=task.callback_manager)\n', (3969, 4021), False, 'from llama_index.core.query_pipeline import AgentInputComponent, AgentFnComponent, CustomAgentComponent, QueryComponent, ToolRunnerComponent\n'), ((9535, 9575), 'llama_index.core.query_pipeline.QueryPipeline', 'QP', ([], {'chain': '[validate_prompt_partial, llm]'}), '(chain=[validate_prompt_partial, llm])\n', (9537, 9575), True, 'from llama_index.core.query_pipeline import QueryPipeline as QP, Link, InputComponent\n'), ((4698, 4752), 'llama_index.core.llms.ChatMessage', 'ChatMessage', ([], {'content': 'task.input', 'role': 'MessageRole.USER'}), '(content=task.input, role=MessageRole.USER)\n', (4709, 4752), False, 'from llama_index.core.llms import ChatMessage\n'), ((4787, 4848), 'llama_index.core.llms.ChatMessage', 'ChatMessage', ([], {'content': 'response_str', 'role': 'MessageRole.ASSISTANT'}), '(content=response_str, role=MessageRole.ASSISTANT)\n', (4798, 4848), False, 'from llama_index.core.llms import ChatMessage\n'), ((5127, 5175), 'llama_index.core.agent.AgentChatResponse', 'AgentChatResponse', (["response_dict['response_str']"], {}), "(response_dict['response_str'])\n", (5144, 5175), False, 'from llama_index.core.agent import Task, AgentChatResponse\n'), ((5533, 5567), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-4-1106-preview"""'}), "(model='gpt-4-1106-preview')\n", (5539, 5567), False, 'from llama_index.llms.openai import OpenAI\n'), ((6634, 6653), 'llama_index.core.callbacks.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (6649, 6653), False, 'from llama_index.core.callbacks import CallbackManager\n'), ((10905, 10922), 'llama_index.core.callbacks.CallbackManager', 'CallbackManager', ([], {}), '()\n', (10920, 10922), False, 'from llama_index.core.callbacks import CallbackManager\n')]

import requests import pandas as pd from bs4 import BeautifulSoup import os from llama_index import SimpleDirectoryReader,GPTListIndex,GPTVectorStoreIndex,LLMPredictor,PromptHelper,ServiceContext,StorageContext from langchain import OpenAI import openai import llama_index # from main import secret_key # with open('key.txt','r') as f: # secret_key=f.read().strip() # os.environ["OPENAI_API_KEY"]=secret_key # secret_key = os.getenv('api_key') from langchain import OpenAI Base_Dir=os.getcwd() from PyPDF2 import PdfReader,PdfWriter def api_status(key): # Set your OpenAI API key # os.environ('OPENAI_API') # openai.api_key="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" openai.api_key=key # Try to create a completion try: response = openai.Completion.create( engine="text-davinci-001", prompt="What is the meaning of life?", temperature=0.5, max_tokens=60, top_p=0.3, frequency_penalty=0.5, presence_penalty=0.0, ) except openai.OpenAIError as e: return False else: return True def get_chat_response(question,api_key): # API endpoint url = 'https://api.openai.com/v1/chat/completions' # Your OpenAI API key # api_key = secret_key # Request headers headers = { 'Content-Type': 'application/json', 'Authorization': f'Bearer {api_key}' } # Request payload payload = { 'model': 'gpt-3.5-turbo', 'messages': [{'role': 'system', 'content': 'You are a helpful assistant.'}, {'role': 'user', 'content': question}] } # Send POST request to the API response = requests.post(url, headers=headers, json=payload) # Parse the response data = response.json() # return data try: reply= data['choices'][0]['message']['content'] # Get the model's reply # reply = data['choices'][0]['message']['content'] return reply except Exception as e: print(e) return None def company_with_url(company_name): csv_path=os.path.join(Base_Dir,'companies_data.csv') from sentence_transformers import SentenceTransformer,util encode_model = SentenceTransformer('paraphrase-MiniLM-L6-v2') df=pd.read_csv(csv_path) companies=list(df['company']) companies_urls=list(df['screener url']) encoded_names=encode_model.encode(companies) cos=util.cos_sim(encode_model.encode(company_name.split()[0]),encoded_names) similar=list(map(lambda x:x.items,cos[0])) index=similar.index(max(similar)) # m=0 # index=0 # for i in range(len(cos[0])): # if m<cos[0][i].item(): # index=i # m=cos[0][i] company=companies[index] screener_url=companies_urls[index] return (company,screener_url) def report_url(url): soup_annual=BeautifulSoup(requests.get(url).content,'html.parser') annual_urls=[i.get('href') for i in soup_annual.find_all('a')] annual_reports=[] for i in annual_urls: if 'Annual' in i and '#' not in i: annual_reports.append(i) annual_report_2022=annual_reports[0] return annual_report_2022 def autodownload_report(url,company): headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.162 Safari/537.36' } response = requests.get(url, stream=True,headers=headers) folder_path=os.path.join(Base_Dir,f'Annual_reports/{company}_report') if not os.path.exists(folder_path): os.mkdir(folder_path) print('folder created') pdf_path=os.path.join(Base_Dir,f'{company}_2022.pdf') # print(pdf_path) with open(pdf_path, "wb") as f: for chunk in response.iter_content(chunk_size=1024): f.write(chunk) return def pdf2txt(pdf_path,company): if not os.path.exists(os.path.join(Base_Dir,f'Annual_reports/{company}_report/{company}_2022.txt')): titles = ['STANDALONE BALANCE SHEET', 'STANDALONE STATEMENT OF PROFIT AND LOSS', 'Balance Sheet', 'Balance Sheet (contd.)', 'Statement of Profit and Loss', 'Statement of Profit and Loss (contd.)'] with open(pdf_path, 'rb') as pdf_file: # Create a PDF reader object pdf_reader = PdfReader(pdf_file) text='' pdf_writer = PdfWriter() page_no=0 for page in pdf_reader.pages: page_content=page.extract_text() page_no+=1 for word in titles: if word in page_content: # print(page_no) text+=page.extract_text() pdf_writer.add_page(page) with open(f'{company}_imp.pdf', 'wb') as output_file: pdf_writer.write(output_file) txt_path=os.path.join(Base_Dir,f'Annual_reports/{company}_report/{company}_2022.txt') with open(txt_path,'w',encoding='utf-8') as f: f.write(text) print('created txt file') pdf_path=os.path.join(Base_Dir,f'{company}_2022.pdf') os.remove(pdf_path) print('removed pdf file') return import base64 def display_pdf(pdf_file): with open(pdf_file, "rb") as f: base64_pdf = base64.b64encode(f.read()).decode('utf-8') pdf_display = f'<iframe src="data:application/pdf;base64,{base64_pdf}" width="700" height="500" type="application/pdf"></iframe>' return pdf_display def create_index(company,secret_key): import openai vstore_path=os.path.join(Base_Dir,f'vector_stores/{company}_vstore') doc_path=os.path.join(Base_Dir,f'Annual_reports/{company}_report') if not os.path.exists(vstore_path): os.mkdir(vstore_path) max_input=4096 tokens=200 chunk_size=600 max_chunk_overlap=20 promptHelpter=PromptHelper(max_input,max_chunk_overlap,chunk_size_limit=chunk_size) openai.api_key=secret_key llmPredictor=LLMPredictor(llm=OpenAI(temperature=0,model_name='text-ada-001',max_tokens=tokens)) docs=SimpleDirectoryReader(doc_path).load_data() service_context=ServiceContext.from_defaults(llm_predictor=llmPredictor,prompt_helper=promptHelpter) openai.api_key=secret_key vectorIndex=GPTVectorStoreIndex.from_documents(documents=docs) vectorIndex.storage_context.persist(persist_dir=vstore_path) return def load_index(vstore_path): # rebuild storage context storage_context = StorageContext.from_defaults(persist_dir=vstore_path) # load index index = llama_index.load_index_from_storage(storage_context) return index # print(index) def give_answer(index,que): return index.as_query_engine().query(que) def answerMe(question,company): vstore_path=os.path.join(Base_Dir,f'vector_stores/{company}_vstore') storage_context=StorageContext.from_defaults(persist_dir=vstore_path) # index=load_index_from_storage(storage_context) index=llama_index.load_index_from_storage(storage_context) query_engine=index.as_query_engine() response=query_engine.query(question) return response.response def balance(url): dfs = pd.read_html(url) return dfs[6] def shareholding(url): dfs = pd.read_html(url) return dfs[10] def balance(url): dfs = pd.read_html(url) return dfs[6]

[((490, 501), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (499, 501), False, 'import os\n'), ((1741, 1790), 'requests.post', 'requests.post', (['url'], {'headers': 'headers', 'json': 'payload'}), '(url, headers=headers, json=payload)\n', (1754, 1790), False, 'import requests\n'), ((2167, 2211), 'os.path.join', 'os.path.join', (['Base_Dir', '"""companies_data.csv"""'], {}), "(Base_Dir, 'companies_data.csv')\n", (2179, 2211), False, 'import os\n'), ((2293, 2339), 'sentence_transformers.SentenceTransformer', 'SentenceTransformer', (['"""paraphrase-MiniLM-L6-v2"""'], {}), "('paraphrase-MiniLM-L6-v2')\n", (2312, 2339), False, 'from sentence_transformers import SentenceTransformer, util\n'), ((2347, 2368), 'pandas.read_csv', 'pd.read_csv', (['csv_path'], {}), '(csv_path)\n', (2358, 2368), True, 'import pandas as pd\n'), ((3497, 3544), 'requests.get', 'requests.get', (['url'], {'stream': '(True)', 'headers': 'headers'}), '(url, stream=True, headers=headers)\n', (3509, 3544), False, 'import requests\n'), ((3561, 3619), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""Annual_reports/{company}_report"""'], {}), "(Base_Dir, f'Annual_reports/{company}_report')\n", (3573, 3619), False, 'import os\n'), ((5768, 5825), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""vector_stores/{company}_vstore"""'], {}), "(Base_Dir, f'vector_stores/{company}_vstore')\n", (5780, 5825), False, 'import os\n'), ((5838, 5896), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""Annual_reports/{company}_report"""'], {}), "(Base_Dir, f'Annual_reports/{company}_report')\n", (5850, 5896), False, 'import os\n'), ((6782, 6835), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'vstore_path'}), '(persist_dir=vstore_path)\n', (6810, 6835), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n'), ((6865, 6917), 'llama_index.load_index_from_storage', 'llama_index.load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (6900, 6917), False, 'import llama_index\n'), ((7079, 7136), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""vector_stores/{company}_vstore"""'], {}), "(Base_Dir, f'vector_stores/{company}_vstore')\n", (7091, 7136), False, 'import os\n'), ((7156, 7209), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': 'vstore_path'}), '(persist_dir=vstore_path)\n', (7184, 7209), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n'), ((7273, 7325), 'llama_index.load_index_from_storage', 'llama_index.load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (7308, 7325), False, 'import llama_index\n'), ((7473, 7490), 'pandas.read_html', 'pd.read_html', (['url'], {}), '(url)\n', (7485, 7490), True, 'import pandas as pd\n'), ((7543, 7560), 'pandas.read_html', 'pd.read_html', (['url'], {}), '(url)\n', (7555, 7560), True, 'import pandas as pd\n'), ((7609, 7626), 'pandas.read_html', 'pd.read_html', (['url'], {}), '(url)\n', (7621, 7626), True, 'import pandas as pd\n'), ((782, 970), 'openai.Completion.create', 'openai.Completion.create', ([], {'engine': '"""text-davinci-001"""', 'prompt': '"""What is the meaning of life?"""', 'temperature': '(0.5)', 'max_tokens': '(60)', 'top_p': '(0.3)', 'frequency_penalty': '(0.5)', 'presence_penalty': '(0.0)'}), "(engine='text-davinci-001', prompt=\n 'What is the meaning of life?', temperature=0.5, max_tokens=60, top_p=\n 0.3, frequency_penalty=0.5, presence_penalty=0.0)\n", (806, 970), False, 'import openai\n'), ((3631, 3658), 'os.path.exists', 'os.path.exists', (['folder_path'], {}), '(folder_path)\n', (3645, 3658), False, 'import os\n'), ((3668, 3689), 'os.mkdir', 'os.mkdir', (['folder_path'], {}), '(folder_path)\n', (3676, 3689), False, 'import os\n'), ((3739, 3784), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""{company}_2022.pdf"""'], {}), "(Base_Dir, f'{company}_2022.pdf')\n", (3751, 3784), False, 'import os\n'), ((5053, 5130), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""Annual_reports/{company}_report/{company}_2022.txt"""'], {}), "(Base_Dir, f'Annual_reports/{company}_report/{company}_2022.txt')\n", (5065, 5130), False, 'import os\n'), ((5262, 5307), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""{company}_2022.pdf"""'], {}), "(Base_Dir, f'{company}_2022.pdf')\n", (5274, 5307), False, 'import os\n'), ((5315, 5334), 'os.remove', 'os.remove', (['pdf_path'], {}), '(pdf_path)\n', (5324, 5334), False, 'import os\n'), ((5907, 5934), 'os.path.exists', 'os.path.exists', (['vstore_path'], {}), '(vstore_path)\n', (5921, 5934), False, 'import os\n'), ((5945, 5966), 'os.mkdir', 'os.mkdir', (['vstore_path'], {}), '(vstore_path)\n', (5953, 5966), False, 'import os\n'), ((6092, 6163), 'llama_index.PromptHelper', 'PromptHelper', (['max_input', 'max_chunk_overlap'], {'chunk_size_limit': 'chunk_size'}), '(max_input, max_chunk_overlap, chunk_size_limit=chunk_size)\n', (6104, 6163), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n'), ((6409, 6499), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llmPredictor', 'prompt_helper': 'promptHelpter'}), '(llm_predictor=llmPredictor, prompt_helper=\n promptHelpter)\n', (6437, 6499), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n'), ((6548, 6598), 'llama_index.GPTVectorStoreIndex.from_documents', 'GPTVectorStoreIndex.from_documents', ([], {'documents': 'docs'}), '(documents=docs)\n', (6582, 6598), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n'), ((2964, 2981), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (2976, 2981), False, 'import requests\n'), ((4028, 4105), 'os.path.join', 'os.path.join', (['Base_Dir', 'f"""Annual_reports/{company}_report/{company}_2022.txt"""'], {}), "(Base_Dir, f'Annual_reports/{company}_report/{company}_2022.txt')\n", (4040, 4105), False, 'import os\n'), ((4437, 4456), 'PyPDF2.PdfReader', 'PdfReader', (['pdf_file'], {}), '(pdf_file)\n', (4446, 4456), False, 'from PyPDF2 import PdfReader, PdfWriter\n'), ((4510, 4521), 'PyPDF2.PdfWriter', 'PdfWriter', ([], {}), '()\n', (4519, 4521), False, 'from PyPDF2 import PdfReader, PdfWriter\n'), ((6243, 6310), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': '(0)', 'model_name': '"""text-ada-001"""', 'max_tokens': 'tokens'}), "(temperature=0, model_name='text-ada-001', max_tokens=tokens)\n", (6249, 6310), False, 'from langchain import OpenAI\n'), ((6332, 6363), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['doc_path'], {}), '(doc_path)\n', (6353, 6363), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, PromptHelper, ServiceContext, StorageContext\n')]

import logging import sys logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) logging.getLogger().addHandler(logging.StreamHandler(stream=sys.stdout)) import os from dotenv import load_dotenv load_dotenv() OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") bulk_data = False # ---------------------------------- async def connect_to_elasticsearch(): # Instantiate the Elasticsearch client right away to check we can connect from elasticsearch import AsyncElasticsearch es_client = AsyncElasticsearch( [os.getenv("ES_URL")], ssl_assert_fingerprint=os.getenv("ES_CERTIFICATE_FINGERPRINT"), basic_auth=(os.getenv("ES_USERNAME"), os.getenv("ES_PASSWORD")) ) await es_client.info() # this connects to the cluster and gets its version if bulk_data: await es_client.indices.delete(index=os.getenv("ES_DEFAULT_INDEX"), ignore=[400, 404]) return es_client def load_data(es_client): from llama_index import SimpleDirectoryReader from llama_index.callbacks import ( CallbackManager, LlamaDebugHandler, CBEventType, ) # Creates a reader for the /data folder if bulk_data: documents = SimpleDirectoryReader("python/data").load_data(show_progress=True) # Creates the ES vector store from llama_index.vector_stores import ElasticsearchStore ES_DEFAULT_INDEX = os.getenv("ES_DEFAULT_INDEX") es_vector_store = ElasticsearchStore( index_name=ES_DEFAULT_INDEX, es_client=es_client ) # Service ctx for debug from llama_index import ServiceContext from llama_index.llms import OpenAI llm = OpenAI(model="gpt-3.5-turbo", temperature=0) llama_debug = LlamaDebugHandler(print_trace_on_end=True) callback_manager = CallbackManager([llama_debug]) service_context = ServiceContext.from_defaults( callback_manager=callback_manager, llm=llm ) # Creates the index import llama_index llama_index.set_global_handler("simple") from llama_index import VectorStoreIndex from llama_index.storage.storage_context import StorageContext storage_context = StorageContext.from_defaults(vector_store=es_vector_store) if bulk_data: index = VectorStoreIndex.from_documents( documents, storage_context=storage_context, service_context=service_context ) else: index = VectorStoreIndex.from_vector_store(vector_store=es_vector_store, service_context=service_context) return index async def main(): es_client = await connect_to_elasticsearch() index = load_data(es_client) # set Logging to DEBUG for more detailed outputs query_engine = index.as_query_engine() # What is Prince and what can you tell me about Hyphenation? while (True): question = input("Enter your question: ") if question == "": question = "what is the address of the bank of yes logic?" response = query_engine.query(question) print("**************************** REFERENCES ****************************") print("Refs " + str(response.source_nodes)) print("**************************** Q&A ****************************") print("Q: " + question) print("A: " + str(response)) import asyncio loop = asyncio.get_event_loop() loop.run_until_complete(main())

[((27, 86), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.DEBUG'}), '(stream=sys.stdout, level=logging.DEBUG)\n', (46, 86), False, 'import logging\n'), ((202, 215), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (213, 215), False, 'from dotenv import load_dotenv\n'), ((234, 261), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (243, 261), False, 'import os\n'), ((3378, 3402), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (3400, 3402), False, 'import asyncio\n'), ((118, 158), 'logging.StreamHandler', 'logging.StreamHandler', ([], {'stream': 'sys.stdout'}), '(stream=sys.stdout)\n', (139, 158), False, 'import logging\n'), ((1411, 1440), 'os.getenv', 'os.getenv', (['"""ES_DEFAULT_INDEX"""'], {}), "('ES_DEFAULT_INDEX')\n", (1420, 1440), False, 'import os\n'), ((1464, 1532), 'llama_index.vector_stores.ElasticsearchStore', 'ElasticsearchStore', ([], {'index_name': 'ES_DEFAULT_INDEX', 'es_client': 'es_client'}), '(index_name=ES_DEFAULT_INDEX, es_client=es_client)\n', (1482, 1532), False, 'from llama_index.vector_stores import ElasticsearchStore\n'), ((1683, 1727), 'llama_index.llms.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""', 'temperature': '(0)'}), "(model='gpt-3.5-turbo', temperature=0)\n", (1689, 1727), False, 'from llama_index.llms import OpenAI\n'), ((1746, 1788), 'llama_index.callbacks.LlamaDebugHandler', 'LlamaDebugHandler', ([], {'print_trace_on_end': '(True)'}), '(print_trace_on_end=True)\n', (1763, 1788), False, 'from llama_index.callbacks import CallbackManager, LlamaDebugHandler, CBEventType\n'), ((1812, 1842), 'llama_index.callbacks.CallbackManager', 'CallbackManager', (['[llama_debug]'], {}), '([llama_debug])\n', (1827, 1842), False, 'from llama_index.callbacks import CallbackManager, LlamaDebugHandler, CBEventType\n'), ((1866, 1938), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'callback_manager': 'callback_manager', 'llm': 'llm'}), '(callback_manager=callback_manager, llm=llm)\n', (1894, 1938), False, 'from llama_index import ServiceContext\n'), ((2005, 2045), 'llama_index.set_global_handler', 'llama_index.set_global_handler', (['"""simple"""'], {}), "('simple')\n", (2035, 2045), False, 'import llama_index\n'), ((2182, 2240), 'llama_index.storage.storage_context.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'es_vector_store'}), '(vector_store=es_vector_store)\n', (2210, 2240), False, 'from llama_index.storage.storage_context import StorageContext\n'), ((87, 106), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (104, 106), False, 'import logging\n'), ((2280, 2392), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(documents, storage_context=storage_context,\n service_context=service_context)\n', (2311, 2392), False, 'from llama_index import VectorStoreIndex\n'), ((2437, 2538), 'llama_index.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', ([], {'vector_store': 'es_vector_store', 'service_context': 'service_context'}), '(vector_store=es_vector_store,\n service_context=service_context)\n', (2471, 2538), False, 'from llama_index import VectorStoreIndex\n'), ((530, 549), 'os.getenv', 'os.getenv', (['"""ES_URL"""'], {}), "('ES_URL')\n", (539, 549), False, 'import os\n'), ((583, 622), 'os.getenv', 'os.getenv', (['"""ES_CERTIFICATE_FINGERPRINT"""'], {}), "('ES_CERTIFICATE_FINGERPRINT')\n", (592, 622), False, 'import os\n'), ((644, 668), 'os.getenv', 'os.getenv', (['"""ES_USERNAME"""'], {}), "('ES_USERNAME')\n", (653, 668), False, 'import os\n'), ((670, 694), 'os.getenv', 'os.getenv', (['"""ES_PASSWORD"""'], {}), "('ES_PASSWORD')\n", (679, 694), False, 'import os\n'), ((1225, 1261), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""python/data"""'], {}), "('python/data')\n", (1246, 1261), False, 'from llama_index import SimpleDirectoryReader\n'), ((857, 886), 'os.getenv', 'os.getenv', (['"""ES_DEFAULT_INDEX"""'], {}), "('ES_DEFAULT_INDEX')\n", (866, 886), False, 'import os\n')]

"""FastAPI app creation, logger configuration and main API routes.""" from typing import Any import llama_index from fastapi import FastAPI from fastapi.openapi.utils import get_openapi from private_gpt.paths import docs_path from private_gpt.server.chat.chat_router import chat_router from private_gpt.server.chunks.chunks_router import chunks_router from private_gpt.server.completions.completions_router import completions_router from private_gpt.server.embeddings.embeddings_router import embeddings_router from private_gpt.server.health.health_router import health_router from private_gpt.server.ingest.ingest_router import ingest_router from private_gpt.settings.settings import settings # Add LlamaIndex simple observability llama_index.set_global_handler("simple") # Start the API with open(docs_path / "description.md") as description_file: description = description_file.read() tags_metadata = [ { "name": "Ingestion", "description": "High-level APIs covering document ingestion -internally " "managing document parsing, splitting," "metadata extraction, embedding generation and storage- and ingested " "documents CRUD." "Each ingested document is identified by an ID that can be used to filter the " "context" "used in *Contextual Completions* and *Context Chunks* APIs.", }, { "name": "Contextual Completions", "description": "High-level APIs covering contextual Chat and Completions. They " "follow OpenAI's format, extending it to " "allow using the context coming from ingested documents to create the " "response. Internally" "manage context retrieval, prompt engineering and the response generation.", }, { "name": "Context Chunks", "description": "Low-level API that given a query return relevant chunks of " "text coming from the ingested" "documents.", }, { "name": "Embeddings", "description": "Low-level API to obtain the vector representation of a given " "text, using an Embeddings model." "Follows OpenAI's embeddings API format.", }, { "name": "Health", "description": "Simple health API to make sure the server is up and running.", }, ] app = FastAPI() def custom_openapi() -> dict[str, Any]: if app.openapi_schema: return app.openapi_schema openapi_schema = get_openapi( title="PrivateGPT", description=description, version="0.1.0", summary="PrivateGPT is a production-ready AI project that allows you to " "ask questions to your documents using the power of Large Language " "Models (LLMs), even in scenarios without Internet connection. " "100% private, no data leaves your execution environment at any point.", contact={ "url": "https://github.com/imartinez/privateGPT", }, license_info={ "name": "Apache 2.0", "url": "https://www.apache.org/licenses/LICENSE-2.0.html", }, routes=app.routes, tags=tags_metadata, ) openapi_schema["info"]["x-logo"] = { "url": "https://lh3.googleusercontent.com/drive-viewer" "/AK7aPaD_iNlMoTquOBsw4boh4tIYxyEuhz6EtEs8nzq3yNkNAK00xGj" "E1KUCmPJSk3TYOjcs6tReG6w_cLu1S7L_gPgT9z52iw=s2560" } app.openapi_schema = openapi_schema return app.openapi_schema app.openapi = custom_openapi # type: ignore[method-assign] app.include_router(completions_router) app.include_router(chat_router) app.include_router(chunks_router) app.include_router(ingest_router) app.include_router(embeddings_router) app.include_router(health_router) if settings.ui.enabled: from private_gpt.ui.ui import mount_in_app mount_in_app(app)

[((735, 775), 'llama_index.set_global_handler', 'llama_index.set_global_handler', (['"""simple"""'], {}), "('simple')\n", (765, 775), False, 'import llama_index\n'), ((2313, 2322), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (2320, 2322), False, 'from fastapi import FastAPI\n'), ((2447, 3013), 'fastapi.openapi.utils.get_openapi', 'get_openapi', ([], {'title': '"""PrivateGPT"""', 'description': 'description', 'version': '"""0.1.0"""', 'summary': '"""PrivateGPT is a production-ready AI project that allows you to ask questions to your documents using the power of Large Language Models (LLMs), even in scenarios without Internet connection. 100% private, no data leaves your execution environment at any point."""', 'contact': "{'url': 'https://github.com/imartinez/privateGPT'}", 'license_info': "{'name': 'Apache 2.0', 'url':\n 'https://www.apache.org/licenses/LICENSE-2.0.html'}", 'routes': 'app.routes', 'tags': 'tags_metadata'}), "(title='PrivateGPT', description=description, version='0.1.0',\n summary=\n 'PrivateGPT is a production-ready AI project that allows you to ask questions to your documents using the power of Large Language Models (LLMs), even in scenarios without Internet connection. 100% private, no data leaves your execution environment at any point.'\n , contact={'url': 'https://github.com/imartinez/privateGPT'},\n license_info={'name': 'Apache 2.0', 'url':\n 'https://www.apache.org/licenses/LICENSE-2.0.html'}, routes=app.routes,\n tags=tags_metadata)\n", (2458, 3013), False, 'from fastapi.openapi.utils import get_openapi\n'), ((3811, 3828), 'private_gpt.ui.ui.mount_in_app', 'mount_in_app', (['app'], {}), '(app)\n', (3823, 3828), False, 'from private_gpt.ui.ui import mount_in_app\n')]

import llama_index from .di import global_injector from .launcher import create_app llama_index.set_global_handler("simple") app = create_app(global_injector)

[((86, 126), 'llama_index.set_global_handler', 'llama_index.set_global_handler', (['"""simple"""'], {}), "('simple')\n", (116, 126), False, 'import llama_index\n')]

import logging from dataclasses import dataclass from typing import List, Optional import llama_index from llama_index.bridge.pydantic import BaseModel from llama_index.callbacks.base import CallbackManager from llama_index.embeddings.base import BaseEmbedding from llama_index.embeddings.utils import EmbedType, resolve_embed_model from llama_index.indices.prompt_helper import PromptHelper from llama_index.llm_predictor import LLMPredictor from llama_index.llm_predictor.base import BaseLLMPredictor, LLMMetadata from llama_index.llms.llm import LLM from llama_index.llms.utils import LLMType, resolve_llm from llama_index.logger import LlamaLogger from llama_index.node_parser.interface import NodeParser, TextSplitter from llama_index.node_parser.text.sentence import ( DEFAULT_CHUNK_SIZE, SENTENCE_CHUNK_OVERLAP, SentenceSplitter, ) from llama_index.prompts.base import BasePromptTemplate from llama_index.schema import TransformComponent from llama_index.types import PydanticProgramMode logger = logging.getLogger(__name__) def _get_default_node_parser( chunk_size: int = DEFAULT_CHUNK_SIZE, chunk_overlap: int = SENTENCE_CHUNK_OVERLAP, callback_manager: Optional[CallbackManager] = None, ) -> NodeParser: """Get default node parser.""" return SentenceSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager or CallbackManager(), ) def _get_default_prompt_helper( llm_metadata: LLMMetadata, context_window: Optional[int] = None, num_output: Optional[int] = None, ) -> PromptHelper: """Get default prompt helper.""" if context_window is not None: llm_metadata.context_window = context_window if num_output is not None: llm_metadata.num_output = num_output return PromptHelper.from_llm_metadata(llm_metadata=llm_metadata) class ServiceContextData(BaseModel): llm: dict llm_predictor: dict prompt_helper: dict embed_model: dict transformations: List[dict] @dataclass class ServiceContext: """Service Context container. The service context container is a utility container for LlamaIndex index and query classes. It contains the following: - llm_predictor: BaseLLMPredictor - prompt_helper: PromptHelper - embed_model: BaseEmbedding - node_parser: NodeParser - llama_logger: LlamaLogger (deprecated) - callback_manager: CallbackManager """ llm_predictor: BaseLLMPredictor prompt_helper: PromptHelper embed_model: BaseEmbedding transformations: List[TransformComponent] llama_logger: LlamaLogger callback_manager: CallbackManager @classmethod def from_defaults( cls, llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[EmbedType] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # pydantic program mode (used if output_cls is specified) pydantic_program_mode: PydanticProgramMode = PydanticProgramMode.DEFAULT, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Create a ServiceContext from defaults. If an argument is specified, then use the argument value provided for that parameter. If an argument is not specified, then use the default value. You can change the base defaults by setting llama_index.global_service_context to a ServiceContext object with your desired settings. Args: llm_predictor (Optional[BaseLLMPredictor]): LLMPredictor prompt_helper (Optional[PromptHelper]): PromptHelper embed_model (Optional[BaseEmbedding]): BaseEmbedding or "local" (use local model) node_parser (Optional[NodeParser]): NodeParser llama_logger (Optional[LlamaLogger]): LlamaLogger (deprecated) chunk_size (Optional[int]): chunk_size callback_manager (Optional[CallbackManager]): CallbackManager system_prompt (Optional[str]): System-wide prompt to be prepended to all input prompts, used to guide system "decision making" query_wrapper_prompt (Optional[BasePromptTemplate]): A format to wrap passed-in input queries. Deprecated Args: chunk_size_limit (Optional[int]): renamed to chunk_size """ if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size instead" ) chunk_size = chunk_size_limit if llama_index.global_service_context is not None: return cls.from_service_context( llama_index.global_service_context, llm=llm, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, text_splitter=text_splitter, llama_logger=llama_logger, callback_manager=callback_manager, context_window=context_window, chunk_size=chunk_size, chunk_size_limit=chunk_size_limit, chunk_overlap=chunk_overlap, num_output=num_output, system_prompt=system_prompt, query_wrapper_prompt=query_wrapper_prompt, transformations=transformations, ) callback_manager = callback_manager or CallbackManager([]) if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm.system_prompt = llm.system_prompt or system_prompt llm.query_wrapper_prompt = llm.query_wrapper_prompt or query_wrapper_prompt llm.pydantic_program_mode = ( llm.pydantic_program_mode or pydantic_program_mode ) if llm_predictor is not None: print("LLMPredictor is deprecated, please use LLM instead.") llm_predictor = llm_predictor or LLMPredictor( llm=llm, pydantic_program_mode=pydantic_program_mode ) if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # NOTE: embed model should be a transformation, but the way the service # context works, we can't put in there yet. embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or [node_parser] llama_logger = llama_logger or LlamaLogger() return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @classmethod def from_service_context( cls, service_context: "ServiceContext", llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[EmbedType] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Instantiate a new service context using a previous as the defaults.""" if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size", DeprecationWarning, ) chunk_size = chunk_size_limit callback_manager = callback_manager or service_context.callback_manager if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or service_context.llm_predictor if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # default to using the embed model passed from the service context if embed_model == "default": embed_model = service_context.embed_model embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or service_context.prompt_helper if context_window is not None or num_output is not None: prompt_helper = _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) transformations = transformations or [] node_parser_found = False for transform in service_context.transformations: if isinstance(transform, NodeParser): node_parser_found = True node_parser = transform break if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") if not node_parser_found: node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or service_context.transformations llama_logger = llama_logger or service_context.llama_logger return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @property def llm(self) -> LLM: return self.llm_predictor.llm @property def node_parser(self) -> NodeParser: """Get the node parser.""" for transform in self.transformations: if isinstance(transform, NodeParser): return transform raise ValueError("No node parser found.") def to_dict(self) -> dict: """Convert service context to dict.""" llm_dict = self.llm_predictor.llm.to_dict() llm_predictor_dict = self.llm_predictor.to_dict() embed_model_dict = self.embed_model.to_dict() prompt_helper_dict = self.prompt_helper.to_dict() tranform_list_dict = [x.to_dict() for x in self.transformations] return ServiceContextData( llm=llm_dict, llm_predictor=llm_predictor_dict, prompt_helper=prompt_helper_dict, embed_model=embed_model_dict, transformations=tranform_list_dict, ).dict() @classmethod def from_dict(cls, data: dict) -> "ServiceContext": from llama_index.embeddings.loading import load_embed_model from llama_index.extractors.loading import load_extractor from llama_index.llm_predictor.loading import load_predictor from llama_index.node_parser.loading import load_parser service_context_data = ServiceContextData.parse_obj(data) llm_predictor = load_predictor(service_context_data.llm_predictor) embed_model = load_embed_model(service_context_data.embed_model) prompt_helper = PromptHelper.from_dict(service_context_data.prompt_helper) transformations: List[TransformComponent] = [] for transform in service_context_data.transformations: try: transformations.append(load_parser(transform)) except ValueError: transformations.append(load_extractor(transform)) return cls.from_defaults( llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, transformations=transformations, ) def set_global_service_context(service_context: Optional[ServiceContext]) -> None: """Helper function to set the global service context.""" llama_index.global_service_context = service_context

[((1018, 1045), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1035, 1045), False, 'import logging\n'), ((1820, 1877), 'llama_index.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', ([], {'llm_metadata': 'llm_metadata'}), '(llm_metadata=llm_metadata)\n', (1850, 1877), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((7504, 7536), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (7523, 7536), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((11065, 11097), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (11084, 11097), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((14239, 14289), 'llama_index.llm_predictor.loading.load_predictor', 'load_predictor', (['service_context_data.llm_predictor'], {}), '(service_context_data.llm_predictor)\n', (14253, 14289), False, 'from llama_index.llm_predictor.loading import load_predictor\n'), ((14313, 14363), 'llama_index.embeddings.loading.load_embed_model', 'load_embed_model', (['service_context_data.embed_model'], {}), '(service_context_data.embed_model)\n', (14329, 14363), False, 'from llama_index.embeddings.loading import load_embed_model\n'), ((14389, 14447), 'llama_index.indices.prompt_helper.PromptHelper.from_dict', 'PromptHelper.from_dict', (['service_context_data.prompt_helper'], {}), '(service_context_data.prompt_helper)\n', (14411, 14447), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((6248, 6267), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (6263, 6267), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((6435, 6451), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (6446, 6451), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((6883, 6949), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm', 'pydantic_program_mode': 'pydantic_program_mode'}), '(llm=llm, pydantic_program_mode=pydantic_program_mode)\n', (6895, 6949), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((8412, 8425), 'llama_index.logger.LlamaLogger', 'LlamaLogger', ([], {}), '()\n', (8423, 8425), False, 'from llama_index.logger import LlamaLogger\n'), ((10360, 10376), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (10371, 10376), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((10405, 10426), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (10417, 10426), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((1419, 1436), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', ([], {}), '()\n', (1434, 1436), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((14623, 14645), 'llama_index.node_parser.loading.load_parser', 'load_parser', (['transform'], {}), '(transform)\n', (14634, 14645), False, 'from llama_index.node_parser.loading import load_parser\n'), ((14717, 14742), 'llama_index.extractors.loading.load_extractor', 'load_extractor', (['transform'], {}), '(transform)\n', (14731, 14742), False, 'from llama_index.extractors.loading import load_extractor\n')]

import os import time import openai import requests from dotenv import load_dotenv from llama_index.core import Settings import llama_index.core from llama_index.core.indices.vector_store.base import VectorStoreIndex from llama_index.core import SimpleDirectoryReader, StorageContext from llama_index.core.memory import ChatMemoryBuffer from llama_index.core.node_parser import SentenceSplitter from llama_index.embeddings.openai import OpenAIEmbedding from llama_index.llms.openai import OpenAI from llama_index.vector_stores.pinecone import PineconeVectorStore from logger import AppLogger from pinecone import Pinecone from utils import get_logger from constant import * load_dotenv() logging = get_logger() class OpenAIChat: def __init__(self): self.setup_openai_api() self.setup_pinecone() self.setup_llama_index_settings() self.setup_chat_engine() def setup_openai_api(self): """ Set up the OpenAI API by setting the API key from the environment variable and configuring the OpenAI API with the key. """ self.openai_api_key = os.getenv("OPENAI_API_KEY") openai.api_key = self.openai_api_key logging.info("OpenAI API has been set up.") def setup_pinecone(self): """ Sets up the pinecone by retrieving the API key from the environment variables and creating a pinecone index. """ pinecone_api_key = os.getenv("PINECONE_API_KEY") self.pinecone_index = self.create_pinecone_index(pinecone_api_key) logging.info("Pinecone has been set up.") def create_pinecone_index(self, pinecone_api_key): """ Create a Pinecone index using the provided Pinecone API key. Args: pinecone_api_key (str): The API key for accessing the Pinecone service. Returns: Pinecone Index: The created Pinecone index for the specified collection. """ pc = Pinecone(api_key=pinecone_api_key) index = pc.Index("chatbot1") logging.info("Pinecone index has been created.") return index def setup_llama_index_settings(self): """ Set up the llama index settings including creating an OpenAI model, setting various settings, and logging the result. """ llm = OpenAI(model="gpt-3.5-turbo-0125", temperature=0) Settings.llm = llm Settings.embed_model = OpenAIEmbedding(embed_batch_size=50) Settings.text_splitter = SentenceSplitter() Settings.transformations = [SentenceSplitter(chunk_size=1024)] logging.info("Llama index settings have been set up.") def setup_chat_engine(self): """ Initializes the chat engine by loading documents, vector store, and creating chat engine. Then, it reindexes the documents. """ self.documents = self.load_documents() self.base_index = self.load_vector_store() self.chat_engine_base = self.create_chat_engine() self.reindex_documents() logging.info("Chat engine has been initialized and documents have been reindexed.") def reindex_documents(self): """ Reindexes documents if requested, and logs the status of the reindexing process. """ # reindex_requested = os.getenv("REINDEX", "no").lower() == "yes" if REINDEX: self.base_index = self.index_documents() logging.info("Documents have been reindexed as requested.") else: logging.info("Reindexing not requested. Using the existing index.") def initialize_pinecone_vector_store(self): """ Initializes the pinecone vector store using the provided pinecone index and returns a PineconeVectorStore object. """ store = PineconeVectorStore(pinecone_index=self.pinecone_index) logging.info("Pinecone vector store has been initialized.") return store def index_documents(self): """ Indexes documents and returns the base index. Returns: VectorStoreIndex: The base index of the indexed documents. """ vector_store = self.initialize_pinecone_vector_store() base_node_parser = SentenceSplitter() base_nodes = base_node_parser.get_nodes_from_documents(self.documents) storage_context = StorageContext.from_defaults(vector_store=vector_store) base_index = VectorStoreIndex(base_nodes, storage_context=storage_context) logging.info("Documents have been indexed and saved.") return base_index def load_documents(self): """ Load documents from a simple directory reader and log the number of documents loaded. :return: The loaded documents. """ documents = SimpleDirectoryReader(SOP_DATA_PATH).load_data() logging.info(f"Loaded {len(documents)} documents.") return documents def load_vector_store(self): """ Load the vector store and create a vector store index from it. :return: Vector store index """ vector_store = PineconeVectorStore(pinecone_index=self.pinecone_index) index = VectorStoreIndex.from_vector_store(vector_store) logging.info("Vector store has been loaded and index has been created.") return index def create_chat_engine(self): """ Create a chat engine using the system prompt and return it. """ system_prompt = self.get_system_prompt() chat_engine = self.base_index.as_chat_engine( chat_mode="context", streaming=True, memory=ChatMemoryBuffer.from_defaults(token_limit=3000), system_prompt=system_prompt, ) logging.info("Chat engine has been created.") return chat_engine def get_system_prompt(self): """ Get the system prompt for Crest Data Systems' assistant. """ return ( "As Crest Data Systems' assistant, provide precise, complete answers and engage smoothly." "Note that you should answer user queries based on the documents you have indexed. Ensure to give your answer in well-defined steps." "Ensure to answer all the questions with respect to crest data systems." "If you don't know the correct answer, prepend the following at the start of the response: Although I couldn't find anything in our knowledge base, here are the general steps to follow. and append the following at the end of the answer: Please contact Crest IT support at IT Helpdesk google chat for further assistance." ) def reset_chat_engine(self): """ Reset the chat engine. """ self.chat_engine_base.reset() # Function to interact with the chat engine def ask_and_respond(self, user_query): """ Function to ask a user query and get a response from the chat engine. :param user_query: the query entered by the user :return: the response stream from the chat engine """ start_time = time.time() response_stream = self.chat_engine_base.stream_chat(user_query) end_time = time.time() logging.info(f"Time taken for this response: {end_time - start_time}") return response_stream def extract_response_data(self, response): """Extracts the response data from the API response.""" if response.status_code == 200: return response.json()["choices"][0]["message"]["content"] else: return "API request failed with status code: " + str(response.status_code) def start_image_processing(self, image_base64, user_query=DEFAULT_USER_QUERY, image_type="image/png"): """Processes an image given in base64 encoding and a user query to generate a response using OpenAI's Vision API.""" url = "https://api.openai.com/v1/chat/completions" headers = { "Content-Type": "application/json", "Authorization": "Bearer " + self.openai_api_key, } payload = { "model": "gpt-4-vision-preview", "messages": [ { "role": "user", "content": [ { "type": "text", "text": "What is the overall issue that user is facing in this image? Start with I am facing an issue.... Pay special attention to the software name and any errors contained in the screenshot. Give a detailed 1 liner answer.", }, { "type": "image_url", "image_url": { "url": f"data:{image_type};base64,{image_base64}" }, }, ], } ], "max_tokens": 300, } response = requests.post(url, headers=headers, json=payload) content = self.extract_response_data(response) user_query = user_query + " " + content logging.info("User query after image processing: " + user_query) response = self.ask_and_respond(user_query) return response

[((675, 688), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (686, 688), False, 'from dotenv import load_dotenv\n'), ((700, 712), 'utils.get_logger', 'get_logger', ([], {}), '()\n', (710, 712), False, 'from utils import get_logger\n'), ((1108, 1135), 'os.getenv', 'os.getenv', (['"""OPENAI_API_KEY"""'], {}), "('OPENAI_API_KEY')\n", (1117, 1135), False, 'import os\n'), ((1432, 1461), 'os.getenv', 'os.getenv', (['"""PINECONE_API_KEY"""'], {}), "('PINECONE_API_KEY')\n", (1441, 1461), False, 'import os\n'), ((1951, 1985), 'pinecone.Pinecone', 'Pinecone', ([], {'api_key': 'pinecone_api_key'}), '(api_key=pinecone_api_key)\n', (1959, 1985), False, 'from pinecone import Pinecone\n'), ((2312, 2361), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo-0125"""', 'temperature': '(0)'}), "(model='gpt-3.5-turbo-0125', temperature=0)\n", (2318, 2361), False, 'from llama_index.llms.openai import OpenAI\n'), ((2420, 2456), 'llama_index.embeddings.openai.OpenAIEmbedding', 'OpenAIEmbedding', ([], {'embed_batch_size': '(50)'}), '(embed_batch_size=50)\n', (2435, 2456), False, 'from llama_index.embeddings.openai import OpenAIEmbedding\n'), ((2490, 2508), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {}), '()\n', (2506, 2508), False, 'from llama_index.core.node_parser import SentenceSplitter\n'), ((3814, 3869), 'llama_index.vector_stores.pinecone.PineconeVectorStore', 'PineconeVectorStore', ([], {'pinecone_index': 'self.pinecone_index'}), '(pinecone_index=self.pinecone_index)\n', (3833, 3869), False, 'from llama_index.vector_stores.pinecone import PineconeVectorStore\n'), ((4252, 4270), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {}), '()\n', (4268, 4270), False, 'from llama_index.core.node_parser import SentenceSplitter\n'), ((4376, 4431), 'llama_index.core.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (4404, 4431), False, 'from llama_index.core import SimpleDirectoryReader, StorageContext\n'), ((4453, 4514), 'llama_index.core.indices.vector_store.base.VectorStoreIndex', 'VectorStoreIndex', (['base_nodes'], {'storage_context': 'storage_context'}), '(base_nodes, storage_context=storage_context)\n', (4469, 4514), False, 'from llama_index.core.indices.vector_store.base import VectorStoreIndex\n'), ((5145, 5200), 'llama_index.vector_stores.pinecone.PineconeVectorStore', 'PineconeVectorStore', ([], {'pinecone_index': 'self.pinecone_index'}), '(pinecone_index=self.pinecone_index)\n', (5164, 5200), False, 'from llama_index.vector_stores.pinecone import PineconeVectorStore\n'), ((5217, 5265), 'llama_index.core.indices.vector_store.base.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', (['vector_store'], {}), '(vector_store)\n', (5251, 5265), False, 'from llama_index.core.indices.vector_store.base import VectorStoreIndex\n'), ((7144, 7155), 'time.time', 'time.time', ([], {}), '()\n', (7153, 7155), False, 'import time\n'), ((7247, 7258), 'time.time', 'time.time', ([], {}), '()\n', (7256, 7258), False, 'import time\n'), ((9031, 9080), 'requests.post', 'requests.post', (['url'], {'headers': 'headers', 'json': 'payload'}), '(url, headers=headers, json=payload)\n', (9044, 9080), False, 'import requests\n'), ((2545, 2578), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {'chunk_size': '(1024)'}), '(chunk_size=1024)\n', (2561, 2578), False, 'from llama_index.core.node_parser import SentenceSplitter\n'), ((4818, 4854), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', (['SOP_DATA_PATH'], {}), '(SOP_DATA_PATH)\n', (4839, 4854), False, 'from llama_index.core import SimpleDirectoryReader, StorageContext\n'), ((5678, 5726), 'llama_index.core.memory.ChatMemoryBuffer.from_defaults', 'ChatMemoryBuffer.from_defaults', ([], {'token_limit': '(3000)'}), '(token_limit=3000)\n', (5708, 5726), False, 'from llama_index.core.memory import ChatMemoryBuffer\n')]

"""FastAPI app creation, logger configuration and main API routes.""" import llama_index from auth_RAG.di import global_injector from auth_RAG.launcher import create_app # Add LlamaIndex simple observability llama_index.set_global_handler("simple") app = create_app(global_injector)

[((211, 251), 'llama_index.set_global_handler', 'llama_index.set_global_handler', (['"""simple"""'], {}), "('simple')\n", (241, 251), False, 'import llama_index\n'), ((259, 286), 'auth_RAG.launcher.create_app', 'create_app', (['global_injector'], {}), '(global_injector)\n', (269, 286), False, 'from auth_RAG.launcher import create_app\n')]

import llama_index from pydantic import BaseModel from typing import List from typing import Optional class Section(BaseModel): section_id: str section_text: str vector_representation: Optional[List[float]] keywords: Optional[List[str]] named_entities: Optional[List[str]] summary: Optional[str] sentiment: Optional[float] document_id: str def to_llama_format(self): """Converts the CogniSphere's Section into a llama's Document format.""" extra_info = { "section_id": self.section_id or "", "document_id": self.document_id or "", "summary": self.summary or "", "sentiment": self.sentiment or "", "keywords": ", ".join(self.keywords) if self.keywords else "", "named_entities": ", ".join(self.named_entities) if self.named_entities else "", } return llama_index.Document( text=self.section_text or "", doc_id=f"{self.document_id}-{self.section_id}" if self.document_id and self.section_id else "", extra_info=extra_info, embedding=self.vector_representation or [], ) class Document(BaseModel): id: str document_id: str title: Optional[str] author: Optional[str] publication_date: Optional[str] genre: Optional[str] publisher: Optional[str] language: Optional[str] isbn: Optional[str] summary: Optional[str] vector_representation: Optional[List[float]] sections: List[Section] def get_section_keywords(self): section_keywords = [ keyword for section in self.sections if section.keywords for keyword in section.keywords ] # remove duplicates return list(set(section_keywords)) def get_section_named_entities(self): section_named_entities = [ entity for section in self.sections if section.named_entities for entity in section.named_entities ] # remove duplicates return list(set(section_named_entities)) def get_text(self): return " ".join(section.section_text for section in self.sections)

[((918, 1146), 'llama_index.Document', 'llama_index.Document', ([], {'text': "(self.section_text or '')", 'doc_id': "(f'{self.document_id}-{self.section_id}' if self.document_id and self.\n section_id else '')", 'extra_info': 'extra_info', 'embedding': '(self.vector_representation or [])'}), "(text=self.section_text or '', doc_id=\n f'{self.document_id}-{self.section_id}' if self.document_id and self.\n section_id else '', extra_info=extra_info, embedding=self.\n vector_representation or [])\n", (938, 1146), False, 'import llama_index\n')]

## create graph from pyvis.network import Network import llama_index.core from llama_index.core import StorageContext, load_index_from_storage storage_context = StorageContext.from_defaults(persist_dir="math_index_persist") index = load_index_from_storage(storage_context) # retriever = llama_index.core.indices.knowledge_graph.KGTableRetriever(index) g = index.get_networkx_graph() net = Network(notebook=True, cdn_resources="in_line", directed=True) net.from_nx(g) net.show("example.html")

[((162, 224), 'llama_index.core.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'persist_dir': '"""math_index_persist"""'}), "(persist_dir='math_index_persist')\n", (190, 224), False, 'from llama_index.core import StorageContext, load_index_from_storage\n'), ((233, 273), 'llama_index.core.load_index_from_storage', 'load_index_from_storage', (['storage_context'], {}), '(storage_context)\n', (256, 273), False, 'from llama_index.core import StorageContext, load_index_from_storage\n'), ((391, 453), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'cdn_resources': '"""in_line"""', 'directed': '(True)'}), "(notebook=True, cdn_resources='in_line', directed=True)\n", (398, 453), False, 'from pyvis.network import Network\n')]

import json import tiktoken from llama_index.query_pipeline.query import QueryPipeline from llama_index.llms import OpenAI from llama_index.prompts import PromptTemplate import llama_index import openai import weaviate from llama_index import SimpleDirectoryReader from llama_index.vector_stores import WeaviateVectorStore from llama_index import VectorStoreIndex, ServiceContext, load_index_from_storage, StorageContext import os from llama_index import download_loader, VectorStoreIndex azure_openai_key = os.getenv("AZURE_OPENAI_KEY") azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT") resource_name = os.getenv("RESOURCE_NAME") azure_client = openai.lib.azure.AzureOpenAI( azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"), api_key=os.getenv("AZURE_OPENAI_KEY"), api_version="2023-05-15" ) headers = { "X-Azure-Api-Key": azure_openai_key, } llama_in_weaviate_class = """ if lecture_id == "CIT5230000": llm = llama_index.llms.AzureOpenAI(model="gpt-35-turbo-16k", deployment_name="gpt-35-16k", api_key=azure_openai_key, azure_endpoint=azure_endpoint, api_version="2023-03-15-preview") embed_model = llama_index.embeddings.AzureOpenAIEmbedding( model="text-embedding-ada-002", deployment_name="te-ada-002", api_key=azure_openai_key, azure_endpoint=azure_endpoint, api_version="2023-03-15-preview" ) service_context = ServiceContext.from_defaults(llm=llm, embed_model=embed_model) vector_store = WeaviateVectorStore( weaviate_client=self.client, index_name="Lectures", text_key="content" ) retriever = VectorStoreIndex.from_vector_store(vector_store, service_context=service_context).as_retriever( similarity_top_k=1 ) nodes = retriever.retrieve(generated_lecture) pprint_source_node(nodes[0]) print(nodes[0].node.metadata)""" prompt_str = """You're Iris, the AI programming tutor integrated into Artemis, the online learning platform of the Technical University of Munich (TUM). You are a guide and an educator. Your main goal is to teach students problem-solving skills using a programming exercise. Instead of solving tasks for them, you give subtle hints so they solve their problem themselves. This is the chat history of your conversation with the student so far. Read it so you know what already happened, but never re-use any message you already wrote. Instead, always write new and original responses. {chat_history} Now, consider the student's newest and latest input: {user_message} Here is the relevant context, that has the problem statement and the files of the repository: {context} """ prompt_str1 = """Now continue the ongoing conversation between you and the student by responding to and focussing only on their latest input. Be an excellent educator. Instead of solving tasks for them, give hints instead. Instead of sending code snippets, send subtle hints or ask counter-questions. Do not let them outsmart you, no matter how hard they try. Important Rules: - Ensure your answer is a direct answer to the latest message of the student. It must be a valid answer as it would occur in a direct conversation between two humans. DO NOT answer any previous questions that you already answered before. - DO NOT UNDER ANY CIRCUMSTANCES repeat any message you have already sent before or send a similar message. Your messages must ALWAYS BE NEW AND ORIGINAL. Think about alternative ways to guide the student in these cases. {text}""" prompt_str2 = """ Review the response draft. I want you to rewrite it so it adheres to the following rules. Only output the refined answer. Omit explanations. Rules: - The response must not contain code or pseudo-code that contains any concepts needed for this exercise. ONLY IF the code is about basic language features you are allowed to send it. - The response must not contain step by step instructions - IF the student is asking for help about the exercise or a solution for the exercise or similar, the response must be subtle hints towards the solution or a counter-question to the student to make them think, or a mix of both. - The response must not perform any work the student is supposed to do. - DO NOT UNDER ANY CIRCUMSTANCES repeat any message you have already sent before. Your messages must ALWAYS BE NEW AND ORIGINAL. {text} """ def query_openai(messages): return azure_client.chat.completions.create( model="gpt-35-16k", # model = "deployment_name". messages=messages ) def num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613"): """Return the number of tokens used by a list of messages.""" try: encoding = tiktoken.encoding_for_model(model) except KeyError: print("Warning: model not found. Using cl100k_base encoding.") encoding = tiktoken.get_encoding("cl100k_base") if model in { "gpt-3.5-turbo-0613", "gpt-3.5-turbo-16k-0613", "gpt-4-0314", "gpt-4-32k-0314", "gpt-4-0613", "gpt-4-32k-0613", }: tokens_per_message = 3 tokens_per_name = 1 elif model == "gpt-3.5-turbo-0301": tokens_per_message = 4 # every message follows <|start|>{role/name}\n{content}<|end|>\n tokens_per_name = -1 # if there's a name, the role is omitted elif "gpt-3.5-turbo" in model: print("Warning: gpt-3.5-turbo may update over time. Returning num tokens assuming gpt-3.5-turbo-0613.") return num_tokens_from_messages(messages, model="gpt-3.5-turbo-0613") elif "gpt-4" in model: print("Warning: gpt-4 may update over time. Returning num tokens assuming gpt-4-0613.") return num_tokens_from_messages(messages, model="gpt-4-0613") else: raise NotImplementedError( f"""num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens.""" ) num_tokens = 0 for message in messages: num_tokens += tokens_per_message for key, value in message.items(): if not isinstance(value, str): print(f"Warning: Non-string value encountered: {value}") value = str(value) # Convert to string or handle as needed num_tokens += len(encoding.encode(value)) if key == "name": num_tokens += tokens_per_name num_tokens += 3 # every reply is primed with assistant return num_tokens class AI: def __init__(self): self.message_history = [] self.index = None self.query_engine = None api_key_header = { "X-Azure-Api-Key": azure_openai_key, # Replace with your inference API key } self.client = weaviate.Client( url="http://localhost:8080", # Replace with your endpoint additional_headers=api_key_header ) self.docs = None def create_class_weaviate(self): t2v = { "model": "ada", "modelVersion": "002", "type": "text", "baseURL": azure_endpoint, "resourceName": resource_name, "deploymentId": "te-ada-002", } self.client.schema.delete_class("Repo") if not self.client.schema.exists("Repo"): class_obj = { "class": "Repo", "vectorizer": "text2vec-openai", "moduleConfig": { "text2vec-openai": t2v, "generative-openai": { "baseURL": azure_endpoint, "resourceName": resource_name, "deploymentId": "gpt-35-16k", "waitForModel": True, "useGPU": False, "useCache": True } } } self.client.schema.create_class(class_obj) print("Schema created") def create_class_llama(self): llm = llama_index.llms.AzureOpenAI(model="gpt-35-turbo-16k", deployment_name="gpt-35-16k", api_key=azure_openai_key, azure_endpoint=azure_endpoint, api_version="2023-03-15-preview") embed_model = llama_index.embeddings.AzureOpenAIEmbedding( model="text-embedding-ada-002", deployment_name="te-ada-002", api_key=azure_openai_key, azure_endpoint=azure_endpoint, api_version="2023-03-15-preview" ) reader = SimpleDirectoryReader(input_dir="/MVP/Programming_exercise", recursive=True) self.docs = reader.load_data() self.create_class_weaviate() vector_store = WeaviateVectorStore(weaviate_client=self.client, index_name="Repo", text_key="content") service_context = ServiceContext.from_defaults(llm=llm, embed_model=embed_model, chunk_size=512, chunk_overlap=50) storage_context = StorageContext.from_defaults(vector_store=vector_store) self.index = VectorStoreIndex.from_documents(self.docs, storage_context=storage_context, service_context=service_context) self.query_engine = self.index.as_query_engine() def generate_response(self, user_message): if self.query_engine is None: # The commented code is for querying with llamaindex # vector_store = WeaviateVectorStore( # weaviate_client=self.client, index_name="Repo" # ) # loaded_index = VectorStoreIndex.from_vector_store(vector_store) # query_engine = loaded_index.as_query_engine( # vector_store_query_mode="hybrid", similarity_top_k=3, alpha=1 # ) # response = query_engine.query(user_message) response = ( self.client.query .get("Repo", ["content", "file_name"]) .with_near_text({"concepts": user_message}) .with_where({ "path": ["file_name"], "operator": "Equal", "valueText": "ProblemStatement" }) .with_limit(3) .do() ) generated = response["data"]["Get"]["Repo"] response = ( self.client.query .get("Repo", ["content", "file_name"]) .with_near_text({"concepts": user_message}) .with_limit(3) .do() ) generated_response = response["data"]["Get"]["Repo"] self.message_history.append({"role": "user", "content": user_message}) prompt_tmpl = PromptTemplate(prompt_str) prompt_tmpl1 = PromptTemplate(prompt_str1) prompt_tmpl2 = PromptTemplate(prompt_str2) llm = OpenAI(model="gpt-3.5-turbo") llm_c = llm.as_query_component(streaming=True) p = QueryPipeline(chain=[prompt_tmpl, llm_c, prompt_tmpl1, llm_c, prompt_tmpl2, llm], verbose=True) if num_tokens_from_messages(self.message_history) > 600: completion = query_openai(self.message_history.append({"role": "system", "content": "summarize the content above, " "keep all only the relevant " "information, do not exceed " "600 tokens"})) self.message_history = [completion.choices[0].message.content] output = p.run(chat_history=self.message_history.__str__(), context=json.dumps(generated, indent=4) + "\n\n" + json.dumps(generated_response, indent=4), user_message=user_message) self.message_history.append({"role": "system", "content": output}) print(str(output)) return str(output)

[((510, 539), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_KEY"""'], {}), "('AZURE_OPENAI_KEY')\n", (519, 539), False, 'import os\n'), ((557, 591), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_ENDPOINT"""'], {}), "('AZURE_OPENAI_ENDPOINT')\n", (566, 591), False, 'import os\n'), ((608, 634), 'os.getenv', 'os.getenv', (['"""RESOURCE_NAME"""'], {}), "('RESOURCE_NAME')\n", (617, 634), False, 'import os\n'), ((699, 733), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_ENDPOINT"""'], {}), "('AZURE_OPENAI_ENDPOINT')\n", (708, 733), False, 'import os\n'), ((747, 776), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_KEY"""'], {}), "('AZURE_OPENAI_KEY')\n", (756, 776), False, 'import os\n'), ((5657, 5691), 'tiktoken.encoding_for_model', 'tiktoken.encoding_for_model', (['model'], {}), '(model)\n', (5684, 5691), False, 'import tiktoken\n'), ((7787, 7866), 'weaviate.Client', 'weaviate.Client', ([], {'url': '"""http://localhost:8080"""', 'additional_headers': 'api_key_header'}), "(url='http://localhost:8080', additional_headers=api_key_header)\n", (7802, 7866), False, 'import weaviate\n'), ((9044, 9228), 'llama_index.llms.AzureOpenAI', 'llama_index.llms.AzureOpenAI', ([], {'model': '"""gpt-35-turbo-16k"""', 'deployment_name': '"""gpt-35-16k"""', 'api_key': 'azure_openai_key', 'azure_endpoint': 'azure_endpoint', 'api_version': '"""2023-03-15-preview"""'}), "(model='gpt-35-turbo-16k', deployment_name=\n 'gpt-35-16k', api_key=azure_openai_key, azure_endpoint=azure_endpoint,\n api_version='2023-03-15-preview')\n", (9072, 9228), False, 'import llama_index\n'), ((9328, 9533), 'llama_index.embeddings.AzureOpenAIEmbedding', 'llama_index.embeddings.AzureOpenAIEmbedding', ([], {'model': '"""text-embedding-ada-002"""', 'deployment_name': '"""te-ada-002"""', 'api_key': 'azure_openai_key', 'azure_endpoint': 'azure_endpoint', 'api_version': '"""2023-03-15-preview"""'}), "(model='text-embedding-ada-002',\n deployment_name='te-ada-002', api_key=azure_openai_key, azure_endpoint=\n azure_endpoint, api_version='2023-03-15-preview')\n", (9371, 9533), False, 'import llama_index\n'), ((9612, 9688), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_dir': '"""/MVP/Programming_exercise"""', 'recursive': '(True)'}), "(input_dir='/MVP/Programming_exercise', recursive=True)\n", (9633, 9688), False, 'from llama_index import SimpleDirectoryReader\n'), ((9827, 9918), 'llama_index.vector_stores.WeaviateVectorStore', 'WeaviateVectorStore', ([], {'weaviate_client': 'self.client', 'index_name': '"""Repo"""', 'text_key': '"""content"""'}), "(weaviate_client=self.client, index_name='Repo',\n text_key='content')\n", (9846, 9918), False, 'from llama_index.vector_stores import WeaviateVectorStore\n'), ((9941, 10042), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': 'embed_model', 'chunk_size': '(512)', 'chunk_overlap': '(50)'}), '(llm=llm, embed_model=embed_model, chunk_size=\n 512, chunk_overlap=50)\n', (9969, 10042), False, 'from llama_index import VectorStoreIndex, ServiceContext, load_index_from_storage, StorageContext\n'), ((10119, 10174), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (10147, 10174), False, 'from llama_index import VectorStoreIndex, ServiceContext, load_index_from_storage, StorageContext\n'), ((10196, 10308), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['self.docs'], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(self.docs, storage_context=storage_context,\n service_context=service_context)\n', (10227, 10308), False, 'from llama_index import download_loader, VectorStoreIndex\n'), ((5803, 5839), 'tiktoken.get_encoding', 'tiktoken.get_encoding', (['"""cl100k_base"""'], {}), "('cl100k_base')\n", (5824, 5839), False, 'import tiktoken\n'), ((11883, 11909), 'llama_index.prompts.PromptTemplate', 'PromptTemplate', (['prompt_str'], {}), '(prompt_str)\n', (11897, 11909), False, 'from llama_index.prompts import PromptTemplate\n'), ((11937, 11964), 'llama_index.prompts.PromptTemplate', 'PromptTemplate', (['prompt_str1'], {}), '(prompt_str1)\n', (11951, 11964), False, 'from llama_index.prompts import PromptTemplate\n'), ((11992, 12019), 'llama_index.prompts.PromptTemplate', 'PromptTemplate', (['prompt_str2'], {}), '(prompt_str2)\n', (12006, 12019), False, 'from llama_index.prompts import PromptTemplate\n'), ((12039, 12068), 'llama_index.llms.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (12045, 12068), False, 'from llama_index.llms import OpenAI\n'), ((12144, 12243), 'llama_index.query_pipeline.query.QueryPipeline', 'QueryPipeline', ([], {'chain': '[prompt_tmpl, llm_c, prompt_tmpl1, llm_c, prompt_tmpl2, llm]', 'verbose': '(True)'}), '(chain=[prompt_tmpl, llm_c, prompt_tmpl1, llm_c, prompt_tmpl2,\n llm], verbose=True)\n', (12157, 12243), False, 'from llama_index.query_pipeline.query import QueryPipeline\n'), ((13007, 13047), 'json.dumps', 'json.dumps', (['generated_response'], {'indent': '(4)'}), '(generated_response, indent=4)\n', (13017, 13047), False, 'import json\n'), ((12964, 12995), 'json.dumps', 'json.dumps', (['generated'], {'indent': '(4)'}), '(generated, indent=4)\n', (12974, 12995), False, 'import json\n')]

from dataclasses import dataclass from typing import TYPE_CHECKING, Any, Callable, List, Optional if TYPE_CHECKING: from llama_index import ServiceContext from llama_index.core.base.embeddings.base import BaseEmbedding from llama_index.core.callbacks.base import BaseCallbackHandler, CallbackManager from llama_index.core.embeddings.utils import EmbedType, resolve_embed_model from llama_index.core.indices.prompt_helper import PromptHelper from llama_index.core.llms import LLM from llama_index.core.llms.utils import LLMType, resolve_llm from llama_index.core.node_parser import NodeParser, SentenceSplitter from llama_index.core.schema import TransformComponent from llama_index.core.types import PydanticProgramMode from llama_index.core.utils import get_tokenizer, set_global_tokenizer @dataclass class _Settings: """Settings for the Llama Index, lazily initialized.""" # lazy initialization _llm: Optional[LLM] = None _embed_model: Optional[BaseEmbedding] = None _callback_manager: Optional[CallbackManager] = None _tokenizer: Optional[Callable[[str], List[Any]]] = None _node_parser: Optional[NodeParser] = None _prompt_helper: Optional[PromptHelper] = None _transformations: Optional[List[TransformComponent]] = None # ---- LLM ---- @property def llm(self) -> LLM: """Get the LLM.""" if self._llm is None: self._llm = resolve_llm("default") if self._callback_manager is not None: self._llm.callback_manager = self._callback_manager return self._llm @llm.setter def llm(self, llm: LLMType) -> None: """Set the LLM.""" self._llm = resolve_llm(llm) @property def pydantic_program_mode(self) -> PydanticProgramMode: """Get the pydantic program mode.""" return self.llm.pydantic_program_mode @pydantic_program_mode.setter def pydantic_program_mode(self, pydantic_program_mode: PydanticProgramMode) -> None: """Set the pydantic program mode.""" self.llm.pydantic_program_mode = pydantic_program_mode # ---- Embedding ---- @property def embed_model(self) -> BaseEmbedding: """Get the embedding model.""" if self._embed_model is None: self._embed_model = resolve_embed_model("default") if self._callback_manager is not None: self._embed_model.callback_manager = self._callback_manager return self._embed_model @embed_model.setter def embed_model(self, embed_model: EmbedType) -> None: """Set the embedding model.""" self._embed_model = resolve_embed_model(embed_model) # ---- Callbacks ---- @property def global_handler(self) -> Optional[BaseCallbackHandler]: """Get the global handler.""" import llama_index.core # TODO: deprecated? return llama_index.global_handler @global_handler.setter def global_handler(self, eval_mode: str, **eval_params: Any) -> None: """Set the global handler.""" from llama_index import set_global_handler # TODO: deprecated? set_global_handler(eval_mode, **eval_params) @property def callback_manager(self) -> CallbackManager: """Get the callback manager.""" if self._callback_manager is None: self._callback_manager = CallbackManager() return self._callback_manager @callback_manager.setter def callback_manager(self, callback_manager: CallbackManager) -> None: """Set the callback manager.""" self._callback_manager = callback_manager # ---- Tokenizer ---- @property def tokenizer(self) -> Callable[[str], List[Any]]: """Get the tokenizer.""" import llama_index.core if llama_index.global_tokenizer is None: return get_tokenizer() # TODO: deprecated? return llama_index.global_tokenizer @tokenizer.setter def tokenizer(self, tokenizer: Callable[[str], List[Any]]) -> None: """Set the tokenizer.""" try: from transformers import PreTrainedTokenizerBase # pants: no-infer-dep if isinstance(tokenizer, PreTrainedTokenizerBase): from functools import partial tokenizer = partial(tokenizer.encode, add_special_tokens=False) except ImportError: pass # TODO: deprecated? set_global_tokenizer(tokenizer) # ---- Node parser ---- @property def node_parser(self) -> NodeParser: """Get the node parser.""" if self._node_parser is None: self._node_parser = SentenceSplitter() if self._callback_manager is not None: self._node_parser.callback_manager = self._callback_manager return self._node_parser @node_parser.setter def node_parser(self, node_parser: NodeParser) -> None: """Set the node parser.""" self._node_parser = node_parser @property def chunk_size(self) -> int: """Get the chunk size.""" if hasattr(self.node_parser, "chunk_size"): return self.node_parser.chunk_size else: raise ValueError("Configured node parser does not have chunk size.") @chunk_size.setter def chunk_size(self, chunk_size: int) -> None: """Set the chunk size.""" if hasattr(self.node_parser, "chunk_size"): self.node_parser.chunk_size = chunk_size else: raise ValueError("Configured node parser does not have chunk size.") @property def chunk_overlap(self) -> int: """Get the chunk overlap.""" if hasattr(self.node_parser, "chunk_overlap"): return self.node_parser.chunk_overlap else: raise ValueError("Configured node parser does not have chunk overlap.") @chunk_overlap.setter def chunk_overlap(self, chunk_overlap: int) -> None: """Set the chunk overlap.""" if hasattr(self.node_parser, "chunk_overlap"): self.node_parser.chunk_overlap = chunk_overlap else: raise ValueError("Configured node parser does not have chunk overlap.") # ---- Node parser alias ---- @property def text_splitter(self) -> NodeParser: """Get the text splitter.""" return self.node_parser @text_splitter.setter def text_splitter(self, text_splitter: NodeParser) -> None: """Set the text splitter.""" self.node_parser = text_splitter # ---- Prompt helper ---- @property def prompt_helper(self) -> PromptHelper: """Get the prompt helper.""" if self._llm is not None and self._prompt_helper is None: self._prompt_helper = PromptHelper.from_llm_metadata(self._llm.metadata) elif self._prompt_helper is None: self._prompt_helper = PromptHelper() return self._prompt_helper @prompt_helper.setter def prompt_helper(self, prompt_helper: PromptHelper) -> None: """Set the prompt helper.""" self._prompt_helper = prompt_helper @property def num_output(self) -> int: """Get the number of outputs.""" return self.prompt_helper.num_output @num_output.setter def num_output(self, num_output: int) -> None: """Set the number of outputs.""" self.prompt_helper.num_output = num_output @property def context_window(self) -> int: """Get the context window.""" return self.prompt_helper.context_window @context_window.setter def context_window(self, context_window: int) -> None: """Set the context window.""" self.prompt_helper.context_window = context_window # ---- Transformations ---- @property def transformations(self) -> List[TransformComponent]: """Get the transformations.""" if self._transformations is None: self._transformations = [self.node_parser] return self._transformations @transformations.setter def transformations(self, transformations: List[TransformComponent]) -> None: """Set the transformations.""" self._transformations = transformations # Singleton Settings = _Settings() # -- Helper functions for deprecation/migration -- def llm_from_settings_or_context( settings: _Settings, context: Optional["ServiceContext"] ) -> LLM: """Get settings from either settings or context.""" if context is not None: return context.llm return settings.llm def embed_model_from_settings_or_context( settings: _Settings, context: Optional["ServiceContext"] ) -> BaseEmbedding: """Get settings from either settings or context.""" if context is not None: return context.embed_model return settings.embed_model def callback_manager_from_settings_or_context( settings: _Settings, context: Optional["ServiceContext"] ) -> CallbackManager: """Get settings from either settings or context.""" if context is not None: return context.callback_manager return settings.callback_manager def node_parser_from_settings_or_context( settings: _Settings, context: Optional["ServiceContext"] ) -> NodeParser: """Get settings from either settings or context.""" if context is not None: return context.node_parser return settings.node_parser def prompt_helper_from_settings_or_context( settings: _Settings, context: Optional["ServiceContext"] ) -> PromptHelper: """Get settings from either settings or context.""" if context is not None: return context.prompt_helper return settings.prompt_helper def transformations_from_settings_or_context( settings: _Settings, context: Optional["ServiceContext"] ) -> List[TransformComponent]: """Get settings from either settings or context.""" if context is not None: return context.transformations return settings.transformations

[((1680, 1696), 'llama_index.core.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (1691, 1696), False, 'from llama_index.core.llms.utils import LLMType, resolve_llm\n'), ((2626, 2658), 'llama_index.core.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (2645, 2658), False, 'from llama_index.core.embeddings.utils import EmbedType, resolve_embed_model\n'), ((3133, 3177), 'llama_index.set_global_handler', 'set_global_handler', (['eval_mode'], {}), '(eval_mode, **eval_params)\n', (3151, 3177), False, 'from llama_index import set_global_handler\n'), ((4433, 4464), 'llama_index.core.utils.set_global_tokenizer', 'set_global_tokenizer', (['tokenizer'], {}), '(tokenizer)\n', (4453, 4464), False, 'from llama_index.core.utils import get_tokenizer, set_global_tokenizer\n'), ((1414, 1436), 'llama_index.core.llms.utils.resolve_llm', 'resolve_llm', (['"""default"""'], {}), "('default')\n", (1425, 1436), False, 'from llama_index.core.llms.utils import LLMType, resolve_llm\n'), ((2290, 2320), 'llama_index.core.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['"""default"""'], {}), "('default')\n", (2309, 2320), False, 'from llama_index.core.embeddings.utils import EmbedType, resolve_embed_model\n'), ((3364, 3381), 'llama_index.core.callbacks.base.CallbackManager', 'CallbackManager', ([], {}), '()\n', (3379, 3381), False, 'from llama_index.core.callbacks.base import BaseCallbackHandler, CallbackManager\n'), ((3846, 3861), 'llama_index.core.utils.get_tokenizer', 'get_tokenizer', ([], {}), '()\n', (3859, 3861), False, 'from llama_index.core.utils import get_tokenizer, set_global_tokenizer\n'), ((4655, 4673), 'llama_index.core.node_parser.SentenceSplitter', 'SentenceSplitter', ([], {}), '()\n', (4671, 4673), False, 'from llama_index.core.node_parser import NodeParser, SentenceSplitter\n'), ((6756, 6806), 'llama_index.core.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', (['self._llm.metadata'], {}), '(self._llm.metadata)\n', (6786, 6806), False, 'from llama_index.core.indices.prompt_helper import PromptHelper\n'), ((4299, 4350), 'functools.partial', 'partial', (['tokenizer.encode'], {'add_special_tokens': '(False)'}), '(tokenizer.encode, add_special_tokens=False)\n', (4306, 4350), False, 'from functools import partial\n'), ((6883, 6897), 'llama_index.core.indices.prompt_helper.PromptHelper', 'PromptHelper', ([], {}), '()\n', (6895, 6897), False, 'from llama_index.core.indices.prompt_helper import PromptHelper\n')]

"""Download.""" import json import logging import os import subprocess import sys from enum import Enum from importlib import util from pathlib import Path from typing import Any, Dict, List, Optional, Union import pkg_resources import requests from pkg_resources import DistributionNotFound from llama_index.download.utils import ( get_exports, get_file_content, initialize_directory, rewrite_exports, ) LLAMA_HUB_CONTENTS_URL = f"https://raw.githubusercontent.com/run-llama/llama-hub/main" LLAMA_HUB_PATH = "/llama_hub" LLAMA_HUB_URL = LLAMA_HUB_CONTENTS_URL + LLAMA_HUB_PATH PATH_TYPE = Union[str, Path] logger = logging.getLogger(__name__) LLAMAHUB_ANALYTICS_PROXY_SERVER = "https://llamahub.ai/api/analytics/downloads" class MODULE_TYPE(str, Enum): LOADER = "loader" TOOL = "tool" LLAMAPACK = "llamapack" DATASETS = "datasets" def get_module_info( local_dir_path: PATH_TYPE, remote_dir_path: PATH_TYPE, module_class: str, refresh_cache: bool = False, library_path: str = "library.json", disable_library_cache: bool = False, ) -> Dict: """Get module info.""" if isinstance(local_dir_path, str): local_dir_path = Path(local_dir_path) local_library_path = f"{local_dir_path}/{library_path}" module_id = None # e.g. `web/simple_web` extra_files = [] # e.g. `web/simple_web/utils.py` # Check cache first if not refresh_cache and os.path.exists(local_library_path): with open(local_library_path) as f: library = json.load(f) if module_class in library: module_id = library[module_class]["id"] extra_files = library[module_class].get("extra_files", []) # Fetch up-to-date library from remote repo if module_id not found if module_id is None: library_raw_content, _ = get_file_content( str(remote_dir_path), f"/{library_path}" ) library = json.loads(library_raw_content) if module_class not in library: raise ValueError("Loader class name not found in library") module_id = library[module_class]["id"] extra_files = library[module_class].get("extra_files", []) # create cache dir if needed local_library_dir = os.path.dirname(local_library_path) if not disable_library_cache: if not os.path.exists(local_library_dir): os.makedirs(local_library_dir) # Update cache with open(local_library_path, "w") as f: f.write(library_raw_content) if module_id is None: raise ValueError("Loader class name not found in library") return { "module_id": module_id, "extra_files": extra_files, } def download_module_and_reqs( local_dir_path: PATH_TYPE, remote_dir_path: PATH_TYPE, module_id: str, extra_files: List[str], refresh_cache: bool = False, use_gpt_index_import: bool = False, base_file_name: str = "base.py", override_path: bool = False, ) -> None: """Load module.""" if isinstance(local_dir_path, str): local_dir_path = Path(local_dir_path) if override_path: module_path = str(local_dir_path) else: module_path = f"{local_dir_path}/{module_id}" if refresh_cache or not os.path.exists(module_path): os.makedirs(module_path, exist_ok=True) basepy_raw_content, _ = get_file_content( str(remote_dir_path), f"/{module_id}/{base_file_name}" ) if use_gpt_index_import: basepy_raw_content = basepy_raw_content.replace( "import llama_index", "import llama_index" ) basepy_raw_content = basepy_raw_content.replace( "from llama_index", "from llama_index" ) with open(f"{module_path}/{base_file_name}", "w") as f: f.write(basepy_raw_content) # Get content of extra files if there are any # and write them under the loader directory for extra_file in extra_files: extra_file_raw_content, _ = get_file_content( str(remote_dir_path), f"/{module_id}/{extra_file}" ) # If the extra file is an __init__.py file, we need to # add the exports to the __init__.py file in the modules directory if extra_file == "__init__.py": loader_exports = get_exports(extra_file_raw_content) existing_exports = [] with open(local_dir_path / "__init__.py", "r+") as f: f.write(f"from .{module_id} import {', '.join(loader_exports)}") existing_exports = get_exports(f.read()) rewrite_exports(existing_exports + loader_exports, str(local_dir_path)) with open(f"{module_path}/{extra_file}", "w") as f: f.write(extra_file_raw_content) # install requirements requirements_path = f"{local_dir_path}/requirements.txt" if not os.path.exists(requirements_path): # NOTE: need to check the status code response_txt, status_code = get_file_content( str(remote_dir_path), f"/{module_id}/requirements.txt" ) if status_code == 200: with open(requirements_path, "w") as f: f.write(response_txt) # Install dependencies if there are any and not already installed if os.path.exists(requirements_path): try: requirements = pkg_resources.parse_requirements( Path(requirements_path).open() ) pkg_resources.require([str(r) for r in requirements]) except DistributionNotFound: subprocess.check_call( [sys.executable, "-m", "pip", "install", "-r", requirements_path] ) def download_llama_module( module_class: str, llama_hub_url: str = LLAMA_HUB_URL, refresh_cache: bool = False, custom_dir: Optional[str] = None, custom_path: Optional[str] = None, library_path: str = "library.json", base_file_name: str = "base.py", use_gpt_index_import: bool = False, disable_library_cache: bool = False, override_path: bool = False, ) -> Any: """Download a module from LlamaHub. Can be a loader, tool, pack, or more. Args: loader_class: The name of the llama module class you want to download, such as `GmailOpenAIAgentPack`. refresh_cache: If true, the local cache will be skipped and the loader will be fetched directly from the remote repo. custom_dir: Custom dir name to download loader into (under parent folder). custom_path: Custom dirpath to download loader into. library_path: File name of the library file. use_gpt_index_import: If true, the loader files will use llama_index as the base dependency. By default (False), the loader files use llama_index as the base dependency. NOTE: this is a temporary workaround while we fully migrate all usages to llama_index. is_dataset: whether or not downloading a LlamaDataset Returns: A Loader, A Pack, An Agent, or A Dataset """ # create directory / get path dirpath = initialize_directory(custom_path=custom_path, custom_dir=custom_dir) # fetch info from library.json file module_info = get_module_info( local_dir_path=dirpath, remote_dir_path=llama_hub_url, module_class=module_class, refresh_cache=refresh_cache, library_path=library_path, disable_library_cache=disable_library_cache, ) module_id = module_info["module_id"] extra_files = module_info["extra_files"] # download the module, install requirements download_module_and_reqs( local_dir_path=dirpath, remote_dir_path=llama_hub_url, module_id=module_id, extra_files=extra_files, refresh_cache=refresh_cache, use_gpt_index_import=use_gpt_index_import, base_file_name=base_file_name, override_path=override_path, ) # loads the module into memory if override_path: spec = util.spec_from_file_location( "custom_module", location=f"{dirpath}/{base_file_name}" ) if spec is None: raise ValueError(f"Could not find file: {dirpath}/{base_file_name}.") else: spec = util.spec_from_file_location( "custom_module", location=f"{dirpath}/{module_id}/{base_file_name}" ) if spec is None: raise ValueError( f"Could not find file: {dirpath}/{module_id}/{base_file_name}." ) module = util.module_from_spec(spec) spec.loader.exec_module(module) # type: ignore return getattr(module, module_class) def track_download(module_class: str, module_type: str) -> None: """Tracks number of downloads via Llamahub proxy. Args: module_class: The name of the llama module being downloaded, e.g.,`GmailOpenAIAgentPack`. module_type: Can be "loader", "tool", "llamapack", or "datasets" """ try: requests.post( LLAMAHUB_ANALYTICS_PROXY_SERVER, json={"type": module_type, "plugin": module_class}, ) except Exception as e: logger.info(f"Error tracking downloads for {module_class} : {e}")

[((637, 664), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (654, 664), False, 'import logging\n'), ((5360, 5393), 'os.path.exists', 'os.path.exists', (['requirements_path'], {}), '(requirements_path)\n', (5374, 5393), False, 'import os\n'), ((7213, 7281), 'llama_index.download.utils.initialize_directory', 'initialize_directory', ([], {'custom_path': 'custom_path', 'custom_dir': 'custom_dir'}), '(custom_path=custom_path, custom_dir=custom_dir)\n', (7233, 7281), False, 'from llama_index.download.utils import get_exports, get_file_content, initialize_directory, rewrite_exports\n'), ((8659, 8686), 'importlib.util.module_from_spec', 'util.module_from_spec', (['spec'], {}), '(spec)\n', (8680, 8686), False, 'from importlib import util\n'), ((1197, 1217), 'pathlib.Path', 'Path', (['local_dir_path'], {}), '(local_dir_path)\n', (1201, 1217), False, 'from pathlib import Path\n'), ((1434, 1468), 'os.path.exists', 'os.path.exists', (['local_library_path'], {}), '(local_library_path)\n', (1448, 1468), False, 'import os\n'), ((1938, 1969), 'json.loads', 'json.loads', (['library_raw_content'], {}), '(library_raw_content)\n', (1948, 1969), False, 'import json\n'), ((2263, 2298), 'os.path.dirname', 'os.path.dirname', (['local_library_path'], {}), '(local_library_path)\n', (2278, 2298), False, 'import os\n'), ((3131, 3151), 'pathlib.Path', 'Path', (['local_dir_path'], {}), '(local_dir_path)\n', (3135, 3151), False, 'from pathlib import Path\n'), ((3347, 3386), 'os.makedirs', 'os.makedirs', (['module_path'], {'exist_ok': '(True)'}), '(module_path, exist_ok=True)\n', (3358, 3386), False, 'import os\n'), ((4949, 4982), 'os.path.exists', 'os.path.exists', (['requirements_path'], {}), '(requirements_path)\n', (4963, 4982), False, 'import os\n'), ((8136, 8226), 'importlib.util.spec_from_file_location', 'util.spec_from_file_location', (['"""custom_module"""'], {'location': 'f"""{dirpath}/{base_file_name}"""'}), "('custom_module', location=\n f'{dirpath}/{base_file_name}')\n", (8164, 8226), False, 'from importlib import util\n'), ((8376, 8478), 'importlib.util.spec_from_file_location', 'util.spec_from_file_location', (['"""custom_module"""'], {'location': 'f"""{dirpath}/{module_id}/{base_file_name}"""'}), "('custom_module', location=\n f'{dirpath}/{module_id}/{base_file_name}')\n", (8404, 8478), False, 'from importlib import util\n'), ((9109, 9211), 'requests.post', 'requests.post', (['LLAMAHUB_ANALYTICS_PROXY_SERVER'], {'json': "{'type': module_type, 'plugin': module_class}"}), "(LLAMAHUB_ANALYTICS_PROXY_SERVER, json={'type': module_type,\n 'plugin': module_class})\n", (9122, 9211), False, 'import requests\n'), ((1536, 1548), 'json.load', 'json.load', (['f'], {}), '(f)\n', (1545, 1548), False, 'import json\n'), ((3310, 3337), 'os.path.exists', 'os.path.exists', (['module_path'], {}), '(module_path)\n', (3324, 3337), False, 'import os\n'), ((4385, 4420), 'llama_index.download.utils.get_exports', 'get_exports', (['extra_file_raw_content'], {}), '(extra_file_raw_content)\n', (4396, 4420), False, 'from llama_index.download.utils import get_exports, get_file_content, initialize_directory, rewrite_exports\n'), ((2356, 2389), 'os.path.exists', 'os.path.exists', (['local_library_dir'], {}), '(local_library_dir)\n', (2370, 2389), False, 'import os\n'), ((2407, 2437), 'os.makedirs', 'os.makedirs', (['local_library_dir'], {}), '(local_library_dir)\n', (2418, 2437), False, 'import os\n'), ((5645, 5737), 'subprocess.check_call', 'subprocess.check_call', (["[sys.executable, '-m', 'pip', 'install', '-r', requirements_path]"], {}), "([sys.executable, '-m', 'pip', 'install', '-r',\n requirements_path])\n", (5666, 5737), False, 'import subprocess\n'), ((5485, 5508), 'pathlib.Path', 'Path', (['requirements_path'], {}), '(requirements_path)\n', (5489, 5508), False, 'from pathlib import Path\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. from typing import Any, Callable, Coroutine from langchain.llms.base import BaseLLM from nemoguardrails import LLMRails, RailsConfig COLANG_CONFIG = """ define user express greeting "hi" define user express ill intent "I hate you" "I want to destroy the world" define bot express cannot respond "I'm sorry I cannot help you with that." define user express question "What is the current unemployment rate?" # Basic guardrail example define flow user express ill intent bot express cannot respond # Question answering flow define flow user ... $answer = execute llama_index_query(query=$last_user_message) bot $answer """ YAML_CONFIG = """ models: - type: main engine: openai model: text-davinci-003 """ def demo(): try: import llama_index from llama_index.indices.query.base import BaseQueryEngine from llama_index.response.schema import StreamingResponse except ImportError: raise ImportError( "Could not import llama_index, please install it with " "`pip install llama_index`." ) config = RailsConfig.from_content(COLANG_CONFIG, YAML_CONFIG) app = LLMRails(config) def _get_llama_index_query_engine(llm: BaseLLM): docs = llama_index.SimpleDirectoryReader( input_files=["../examples/grounding_rail/kb/report.md"] ).load_data() llm_predictor = llama_index.LLMPredictor(llm=llm) index = llama_index.GPTVectorStoreIndex.from_documents( docs, llm_predictor=llm_predictor ) default_query_engine = index.as_query_engine() return default_query_engine def _get_callable_query_engine( query_engine: BaseQueryEngine, ) -> Callable[[str], Coroutine[Any, Any, str]]: async def get_query_response(query: str) -> str: response = query_engine.query(query) if isinstance(response, StreamingResponse): typed_response = response.get_response() else: typed_response = response response_str = typed_response.response if response_str is None: return "" return response_str return get_query_response query_engine = _get_llama_index_query_engine(app.llm) app.register_action( _get_callable_query_engine(query_engine), name="llama_index_query" ) history = [{"role": "user", "content": "What is the current unemployment rate?"}] result = app.generate(messages=history) print(result) if __name__ == "__main__": demo()

[((1791, 1843), 'nemoguardrails.RailsConfig.from_content', 'RailsConfig.from_content', (['COLANG_CONFIG', 'YAML_CONFIG'], {}), '(COLANG_CONFIG, YAML_CONFIG)\n', (1815, 1843), False, 'from nemoguardrails import LLMRails, RailsConfig\n'), ((1854, 1870), 'nemoguardrails.LLMRails', 'LLMRails', (['config'], {}), '(config)\n', (1862, 1870), False, 'from nemoguardrails import LLMRails, RailsConfig\n'), ((2089, 2122), 'llama_index.LLMPredictor', 'llama_index.LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (2113, 2122), False, 'import llama_index\n'), ((2139, 2225), 'llama_index.GPTVectorStoreIndex.from_documents', 'llama_index.GPTVectorStoreIndex.from_documents', (['docs'], {'llm_predictor': 'llm_predictor'}), '(docs, llm_predictor=\n llm_predictor)\n', (2185, 2225), False, 'import llama_index\n'), ((1940, 2035), 'llama_index.SimpleDirectoryReader', 'llama_index.SimpleDirectoryReader', ([], {'input_files': "['../examples/grounding_rail/kb/report.md']"}), "(input_files=[\n '../examples/grounding_rail/kb/report.md'])\n", (1973, 2035), False, 'import llama_index\n')]

import logging from dataclasses import dataclass from typing import Optional, Union import llama_index from llama_index.callbacks.base import CallbackManager from llama_index.embeddings.base import BaseEmbedding from llama_index.embeddings.openai import OpenAIEmbedding from llama_index.indices.prompt_helper import PromptHelper from llama_index.llm_predictor import LLMPredictor from llama_index.llm_predictor.base import BaseLLMPredictor, LLMMetadata from llama_index.llms.base import LLM from llama_index.llms.utils import LLMType from llama_index.logger import LlamaLogger from llama_index.node_parser.interface import NodeParser from llama_index.node_parser.simple import SimpleNodeParser from llama_index.embeddings import ( DEFAULT_HUGGINGFACE_EMBEDDING_MODEL, LangchainEmbedding, ) logger = logging.getLogger(__name__) def _get_default_node_parser( chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, callback_manager: Optional[CallbackManager] = None, ) -> NodeParser: """Get default node parser.""" return SimpleNodeParser.from_defaults( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) def _get_default_prompt_helper( llm_metadata: LLMMetadata, context_window: Optional[int] = None, num_output: Optional[int] = None, ) -> PromptHelper: """Get default prompt helper.""" if context_window is not None: llm_metadata.context_window = context_window if num_output is not None: llm_metadata.num_output = num_output return PromptHelper.from_llm_metadata(llm_metadata=llm_metadata) @dataclass class ServiceContext: """Service Context container. The service context container is a utility container for LlamaIndex index and query classes. It contains the following: - llm_predictor: BaseLLMPredictor - prompt_helper: PromptHelper - embed_model: BaseEmbedding - node_parser: NodeParser - llama_logger: LlamaLogger (deprecated) - callback_manager: CallbackManager """ llm_predictor: BaseLLMPredictor prompt_helper: PromptHelper embed_model: BaseEmbedding node_parser: NodeParser llama_logger: LlamaLogger callback_manager: CallbackManager @classmethod def from_defaults( cls, llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = None, prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[Union[BaseEmbedding, str]] = None, node_parser: Optional[NodeParser] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Create a ServiceContext from defaults. If an argument is specified, then use the argument value provided for that parameter. If an argument is not specified, then use the default value. You can change the base defaults by setting llama_index.global_service_context to a ServiceContext object with your desired settings. Args: llm_predictor (Optional[BaseLLMPredictor]): LLMPredictor prompt_helper (Optional[PromptHelper]): PromptHelper embed_model (Optional[BaseEmbedding]): BaseEmbedding or "local" (use local model) node_parser (Optional[NodeParser]): NodeParser llama_logger (Optional[LlamaLogger]): LlamaLogger (deprecated) chunk_size (Optional[int]): chunk_size callback_manager (Optional[CallbackManager]): CallbackManager Deprecated Args: chunk_size_limit (Optional[int]): renamed to chunk_size """ if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size instead" ) chunk_size = chunk_size_limit if isinstance(embed_model, str): splits = embed_model.split(":", 1) is_local = splits[0] model_name = splits[1] if len(splits) > 1 else None if is_local != "local": raise ValueError( "embed_model must start with str 'local' or of type BaseEmbedding" ) try: from langchain.embeddings import HuggingFaceEmbeddings except ImportError as exc: raise ImportError( "Could not import sentence_transformers or langchain package. " "Please install with `pip install sentence-transformers langchain`." ) from exc embed_model = LangchainEmbedding( HuggingFaceEmbeddings( model_name=model_name or DEFAULT_HUGGINGFACE_EMBEDDING_MODEL ) ) if llama_index.global_service_context is not None: return cls.from_service_context( llama_index.global_service_context, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, llama_logger=llama_logger, callback_manager=callback_manager, chunk_size=chunk_size, chunk_size_limit=chunk_size_limit, ) callback_manager = callback_manager or CallbackManager([]) if llm is not None: if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or LLMPredictor() llm_predictor.callback_manager = callback_manager # NOTE: the embed_model isn't used in all indices embed_model = embed_model or OpenAIEmbedding() embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) node_parser = node_parser or _get_default_node_parser( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) llama_logger = llama_logger or LlamaLogger() return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @classmethod def from_service_context( cls, service_context: "ServiceContext", llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLM] = None, prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[BaseEmbedding] = None, node_parser: Optional[NodeParser] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Instantiate a new service context using a previous as the defaults.""" if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size", DeprecationWarning, ) chunk_size = chunk_size_limit callback_manager = callback_manager or service_context.callback_manager if llm is not None: if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or service_context.llm_predictor llm_predictor.callback_manager = callback_manager # NOTE: the embed_model isn't used in all indices embed_model = embed_model or service_context.embed_model embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) node_parser = node_parser or service_context.node_parser if chunk_size is not None or chunk_overlap is not None: node_parser = _get_default_node_parser( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager, ) llama_logger = llama_logger or service_context.llama_logger return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @property def llm(self) -> LLM: if not isinstance(self.llm_predictor, LLMPredictor): raise ValueError("llm_predictor must be an instance of LLMPredictor") return self.llm_predictor.llm def set_global_service_context(service_context: Optional[ServiceContext]) -> None: """Helper function to set the global service context.""" llama_index.global_service_context = service_context

[((809, 836), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (826, 836), False, 'import logging\n'), ((1067, 1189), 'llama_index.node_parser.simple.SimpleNodeParser.from_defaults', 'SimpleNodeParser.from_defaults', ([], {'chunk_size': 'chunk_size', 'chunk_overlap': 'chunk_overlap', 'callback_manager': 'callback_manager'}), '(chunk_size=chunk_size, chunk_overlap=\n chunk_overlap, callback_manager=callback_manager)\n', (1097, 1189), False, 'from llama_index.node_parser.simple import SimpleNodeParser\n'), ((1592, 1649), 'llama_index.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', ([], {'llm_metadata': 'llm_metadata'}), '(llm_metadata=llm_metadata)\n', (1622, 1649), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((5761, 5780), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (5776, 5780), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((5957, 5978), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (5969, 5978), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((6020, 6034), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {}), '()\n', (6032, 6034), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((6189, 6206), 'llama_index.embeddings.openai.OpenAIEmbedding', 'OpenAIEmbedding', ([], {}), '()\n', (6204, 6206), False, 'from llama_index.embeddings.openai import OpenAIEmbedding\n'), ((6707, 6720), 'llama_index.logger.LlamaLogger', 'LlamaLogger', ([], {}), '()\n', (6718, 6720), False, 'from llama_index.logger import LlamaLogger\n'), ((8412, 8433), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (8424, 8433), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((5050, 5137), 'langchain.embeddings.HuggingFaceEmbeddings', 'HuggingFaceEmbeddings', ([], {'model_name': '(model_name or DEFAULT_HUGGINGFACE_EMBEDDING_MODEL)'}), '(model_name=model_name or\n DEFAULT_HUGGINGFACE_EMBEDDING_MODEL)\n', (5071, 5137), False, 'from langchain.embeddings import HuggingFaceEmbeddings\n')]

"""Google GenerativeAI Attributed Question and Answering (AQA) service. The GenAI Semantic AQA API is a managed end to end service that allows developers to create responses grounded on specified passages based on a user query. For more information visit: https://developers.generativeai.google/guide """ import logging from typing import TYPE_CHECKING, Any, List, Optional, Sequence, cast from llama_index.bridge.pydantic import BaseModel # type: ignore from llama_index.callbacks.schema import CBEventType, EventPayload from llama_index.indices.query.schema import QueryBundle from llama_index.prompts.mixin import PromptDictType from llama_index.response.schema import Response from llama_index.response_synthesizers.base import BaseSynthesizer, QueryTextType from llama_index.schema import MetadataMode, NodeWithScore, TextNode from llama_index.types import RESPONSE_TEXT_TYPE from llama_index.vector_stores.google.generativeai import google_service_context if TYPE_CHECKING: import google.ai.generativelanguage as genai _logger = logging.getLogger(__name__) _import_err_msg = "`google.generativeai` package not found, please run `pip install google-generativeai`" _separator = "\n\n" class SynthesizedResponse(BaseModel): """Response of `GoogleTextSynthesizer.get_response`.""" answer: str """The grounded response to the user's question.""" attributed_passages: List[str] """The list of passages the AQA model used for its response.""" answerable_probability: float """The model's estimate of the probability that its answer is correct and grounded in the input passages.""" class GoogleTextSynthesizer(BaseSynthesizer): """Google's Attributed Question and Answering service. Given a user's query and a list of passages, Google's server will return a response that is grounded to the provided list of passages. It will not base the response on parametric memory. """ _client: Any _temperature: float _answer_style: Any _safety_setting: List[Any] def __init__( self, *, temperature: float, answer_style: Any, safety_setting: List[Any], **kwargs: Any, ): """Create a new Google AQA. Prefer to use the factory `from_defaults` instead for type safety. See `from_defaults` for more documentation. """ try: import llama_index.vector_stores.google.generativeai.genai_extension as genaix except ImportError: raise ImportError(_import_err_msg) super().__init__( service_context=google_service_context, output_cls=SynthesizedResponse, **kwargs, ) self._client = genaix.build_generative_service() self._temperature = temperature self._answer_style = answer_style self._safety_setting = safety_setting # Type safe factory that is only available if Google is installed. @classmethod def from_defaults( cls, temperature: float = 0.7, answer_style: int = 1, safety_setting: List["genai.SafetySetting"] = [], ) -> "GoogleTextSynthesizer": """Create a new Google AQA. Example: responder = GoogleTextSynthesizer.create( temperature=0.7, answer_style=AnswerStyle.ABSTRACTIVE, safety_setting=[ SafetySetting( category=HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE, ), ] ) Args: temperature: 0.0 to 1.0. answer_style: See `google.ai.generativelanguage.GenerateAnswerRequest.AnswerStyle` The default is ABSTRACTIVE (1). safety_setting: See `google.ai.generativelanguage.SafetySetting`. Returns: an instance of GoogleTextSynthesizer. """ return cls( temperature=temperature, answer_style=answer_style, safety_setting=safety_setting, ) def get_response( self, query_str: str, text_chunks: Sequence[str], **response_kwargs: Any, ) -> SynthesizedResponse: """Generate a grounded response on provided passages. Args: query_str: The user's question. text_chunks: A list of passages that should be used to answer the question. Returns: A `SynthesizedResponse` object. """ try: import google.ai.generativelanguage as genai import llama_index.vector_stores.google.generativeai.genai_extension as genaix except ImportError: raise ImportError(_import_err_msg) client = cast(genai.GenerativeServiceClient, self._client) response = genaix.generate_answer( prompt=query_str, passages=list(text_chunks), answer_style=self._answer_style, safety_settings=self._safety_setting, temperature=self._temperature, client=client, ) return SynthesizedResponse( answer=response.answer, attributed_passages=[ passage.text for passage in response.attributed_passages ], answerable_probability=response.answerable_probability, ) async def aget_response( self, query_str: str, text_chunks: Sequence[str], **response_kwargs: Any, ) -> RESPONSE_TEXT_TYPE: # TODO: Implement a true async version. return self.get_response(query_str, text_chunks, **response_kwargs) def synthesize( self, query: QueryTextType, nodes: List[NodeWithScore], additional_source_nodes: Optional[Sequence[NodeWithScore]] = None, **response_kwargs: Any, ) -> Response: """Returns a grounded response based on provided passages. Returns: Response's `source_nodes` will begin with a list of attributed passages. These passages are the ones that were used to construct the grounded response. These passages will always have no score, the only way to mark them as attributed passages. Then, the list will follow with the originally provided passages, which will have a score from the retrieval. Response's `metadata` may also have have an entry with key `answerable_probability`, which is the model's estimate of the probability that its answer is correct and grounded in the input passages. """ if len(nodes) == 0: return Response("Empty Response") if isinstance(query, str): query = QueryBundle(query_str=query) with self._callback_manager.event( CBEventType.SYNTHESIZE, payload={EventPayload.QUERY_STR: query.query_str} ) as event: internal_response = self.get_response( query_str=query.query_str, text_chunks=[ n.node.get_content(metadata_mode=MetadataMode.LLM) for n in nodes ], **response_kwargs, ) additional_source_nodes = list(additional_source_nodes or []) external_response = self._prepare_external_response( internal_response, nodes + additional_source_nodes ) event.on_end(payload={EventPayload.RESPONSE: external_response}) return external_response async def asynthesize( self, query: QueryTextType, nodes: List[NodeWithScore], additional_source_nodes: Optional[Sequence[NodeWithScore]] = None, **response_kwargs: Any, ) -> Response: # TODO: Implement a true async version. return self.synthesize(query, nodes, additional_source_nodes, **response_kwargs) def _prepare_external_response( self, response: SynthesizedResponse, source_nodes: List[NodeWithScore], ) -> Response: return Response( response=response.answer, source_nodes=[ NodeWithScore(node=TextNode(text=passage)) for passage in response.attributed_passages ] + source_nodes, metadata={ "answerable_probability": response.answerable_probability, }, ) def _get_prompts(self) -> PromptDictType: # Not used. return {} def _update_prompts(self, prompts_dict: PromptDictType) -> None: # Not used. ...

[((1046, 1073), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1063, 1073), False, 'import logging\n'), ((2734, 2767), 'llama_index.vector_stores.google.generativeai.genai_extension.build_generative_service', 'genaix.build_generative_service', ([], {}), '()\n', (2765, 2767), True, 'import llama_index.vector_stores.google.generativeai.genai_extension as genaix\n'), ((4819, 4868), 'typing.cast', 'cast', (['genai.GenerativeServiceClient', 'self._client'], {}), '(genai.GenerativeServiceClient, self._client)\n', (4823, 4868), False, 'from typing import TYPE_CHECKING, Any, List, Optional, Sequence, cast\n'), ((6762, 6788), 'llama_index.response.schema.Response', 'Response', (['"""Empty Response"""'], {}), "('Empty Response')\n", (6770, 6788), False, 'from llama_index.response.schema import Response\n'), ((6845, 6873), 'llama_index.indices.query.schema.QueryBundle', 'QueryBundle', ([], {'query_str': 'query'}), '(query_str=query)\n', (6856, 6873), False, 'from llama_index.indices.query.schema import QueryBundle\n'), ((8284, 8306), 'llama_index.schema.TextNode', 'TextNode', ([], {'text': 'passage'}), '(text=passage)\n', (8292, 8306), False, 'from llama_index.schema import MetadataMode, NodeWithScore, TextNode\n')]

get_ipython().run_line_magic('pip', 'install llama-index-llms-openai') get_ipython().run_line_magic('pip', 'install llama-index-packs-rag-fusion-query-pipeline') get_ipython().system("wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt' -O 'data/paul_graham/paul_graham_essay.txt' -O pg_essay.txt") from llama_index.core import SimpleDirectoryReader reader = SimpleDirectoryReader(input_files=["pg_essay.txt"]) docs = reader.load_data() import phoenix as px px.launch_app() import llama_index.core llama_index.core.set_global_handler("arize_phoenix") from llama_index.core.llama_pack import download_llama_pack from llama_index.packs.rag_fusion_query_pipeline import RAGFusionPipelinePack from llama_index.llms.openai import OpenAI pack = RAGFusionPipelinePack(docs, llm=OpenAI(model="gpt-3.5-turbo")) from pyvis.network import Network net = Network(notebook=True, cdn_resources="in_line", directed=True) net.from_nx(pack.query_pipeline.dag) net.show("rag_dag.html") response = pack.run(query="What did the author do growing up?") print(str(response))

[((432, 483), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', ([], {'input_files': "['pg_essay.txt']"}), "(input_files=['pg_essay.txt'])\n", (453, 483), False, 'from llama_index.core import SimpleDirectoryReader\n'), ((535, 550), 'phoenix.launch_app', 'px.launch_app', ([], {}), '()\n', (548, 550), True, 'import phoenix as px\n'), ((933, 995), 'pyvis.network.Network', 'Network', ([], {'notebook': '(True)', 'cdn_resources': '"""in_line"""', 'directed': '(True)'}), "(notebook=True, cdn_resources='in_line', directed=True)\n", (940, 995), False, 'from pyvis.network import Network\n'), ((858, 887), 'llama_index.llms.openai.OpenAI', 'OpenAI', ([], {'model': '"""gpt-3.5-turbo"""'}), "(model='gpt-3.5-turbo')\n", (864, 887), False, 'from llama_index.llms.openai import OpenAI\n')]

import uvicorn import os import logging import llama_index from typing import cast from pathlib import Path from fastapi.middleware.cors import CORSMiddleware from fastapi import FastAPI from dotenv import load_dotenv from contextlib import asynccontextmanager from firebase_admin import credentials, initialize_app from app.db.pg_vector import CustomPGVectorStore, get_vector_store_singleton from app.db.wait_for_db import check_database_connection from app.api.api import api_router from app.setup.service_context import initialize_llamaindex_service_context from app.setup.tracing import initialize_tracing_service load_dotenv() cwd = Path.cwd() # Default to 'development' if not set environment = os.getenv("ENVIRONMENT", "dev") @asynccontextmanager async def lifespan(app: FastAPI): # First wait for DB to be connectable. await check_database_connection() # Initialize pg vector store singleton. vector_store = await get_vector_store_singleton() vector_store = cast(CustomPGVectorStore, vector_store) await vector_store.run_setup() # Initialize firebase admin for authentication. cred = credentials.Certificate(cwd / 'firebase_creds.json') initialize_app(cred) # if environment == "dev": # # Initialize observability service. # initialize_tracing_service("wandb", "talking-resume") # Set global ServiceContext for LlamaIndex. initialize_llamaindex_service_context(environment) yield # This section is run on app shutdown. await vector_store.close() app = FastAPI(lifespan=lifespan) if environment == "dev": # LLM debug. llama_index.set_global_handler("simple") logger = logging.getLogger("uvicorn") logger.warning( "Running in development mode - allowing CORS for all origins") app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) app.include_router(api_router, prefix="/api") if __name__ == "__main__": uvicorn.run(app="main:app", host="0.0.0.0", reload=True)

[((620, 633), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (631, 633), False, 'from dotenv import load_dotenv\n'), ((641, 651), 'pathlib.Path.cwd', 'Path.cwd', ([], {}), '()\n', (649, 651), False, 'from pathlib import Path\n'), ((705, 736), 'os.getenv', 'os.getenv', (['"""ENVIRONMENT"""', '"""dev"""'], {}), "('ENVIRONMENT', 'dev')\n", (714, 736), False, 'import os\n'), ((1549, 1575), 'fastapi.FastAPI', 'FastAPI', ([], {'lifespan': 'lifespan'}), '(lifespan=lifespan)\n', (1556, 1575), False, 'from fastapi import FastAPI\n'), ((993, 1032), 'typing.cast', 'cast', (['CustomPGVectorStore', 'vector_store'], {}), '(CustomPGVectorStore, vector_store)\n', (997, 1032), False, 'from typing import cast\n'), ((1132, 1184), 'firebase_admin.credentials.Certificate', 'credentials.Certificate', (["(cwd / 'firebase_creds.json')"], {}), "(cwd / 'firebase_creds.json')\n", (1155, 1184), False, 'from firebase_admin import credentials, initialize_app\n'), ((1189, 1209), 'firebase_admin.initialize_app', 'initialize_app', (['cred'], {}), '(cred)\n', (1203, 1209), False, 'from firebase_admin import credentials, initialize_app\n'), ((1405, 1455), 'app.setup.service_context.initialize_llamaindex_service_context', 'initialize_llamaindex_service_context', (['environment'], {}), '(environment)\n', (1442, 1455), False, 'from app.setup.service_context import initialize_llamaindex_service_context\n'), ((1623, 1663), 'llama_index.set_global_handler', 'llama_index.set_global_handler', (['"""simple"""'], {}), "('simple')\n", (1653, 1663), False, 'import llama_index\n'), ((1678, 1706), 'logging.getLogger', 'logging.getLogger', (['"""uvicorn"""'], {}), "('uvicorn')\n", (1695, 1706), False, 'import logging\n'), ((2051, 2107), 'uvicorn.run', 'uvicorn.run', ([], {'app': '"""main:app"""', 'host': '"""0.0.0.0"""', 'reload': '(True)'}), "(app='main:app', host='0.0.0.0', reload=True)\n", (2062, 2107), False, 'import uvicorn\n'), ((847, 874), 'app.db.wait_for_db.check_database_connection', 'check_database_connection', ([], {}), '()\n', (872, 874), False, 'from app.db.wait_for_db import check_database_connection\n'), ((945, 973), 'app.db.pg_vector.get_vector_store_singleton', 'get_vector_store_singleton', ([], {}), '()\n', (971, 973), False, 'from app.db.pg_vector import CustomPGVectorStore, get_vector_store_singleton\n')]

#!/usr/bin/env python import os, sys print("[INFO] Python", sys.version) if "VIRTUAL_ENV" in os.environ: print("[INFO] venv:", os.environ["VIRTUAL_ENV"]) if sys.version_info.major != 3 or sys.version_info.minor not in (8,9,10,11): print("[WARNING] Unsupported python version!") print("[INFO] Testing imports...") try: import llama_index, jupyterlab, loguru except ImportError: print("[ERROR] /!\ Could not import some requirements, make sure you've installed everything " \ "according to README.md") print("[INFO] python path set to:", sys.path) raise print("[INFO] OK. Loading model...") service_context = llama_index.ServiceContext.from_defaults( embed_model="local:sentence-transformers/all-minilm-l6-v2", chunk_size=256, llm=None ) print("[INFO] OK. Testing model...") service_context.embed_model.get_text_embedding('Sphinx of black quartz, judge my vow') print("All OK!")

[((644, 775), 'llama_index.ServiceContext.from_defaults', 'llama_index.ServiceContext.from_defaults', ([], {'embed_model': '"""local:sentence-transformers/all-minilm-l6-v2"""', 'chunk_size': '(256)', 'llm': 'None'}), "(embed_model=\n 'local:sentence-transformers/all-minilm-l6-v2', chunk_size=256, llm=None)\n", (684, 775), False, 'import llama_index, jupyterlab, loguru\n')]

get_ipython().run_line_magic('pip', 'install llama-index-llms-gemini') get_ipython().run_line_magic('pip', 'install llama-index-vector-stores-google') get_ipython().run_line_magic('pip', 'install llama-index-indices-managed-google') get_ipython().run_line_magic('pip', 'install llama-index-response-synthesizers-google') get_ipython().run_line_magic('pip', 'install llama-index') get_ipython().run_line_magic('pip', 'install "google-ai-generativelanguage>=0.4,<=1.0"') get_ipython().run_line_magic('pip', 'install google-auth-oauthlib') from google.oauth2 import service_account from llama_index.vector_stores.google import set_google_config credentials = service_account.Credentials.from_service_account_file( "service_account_key.json", scopes=[ "https://www.googleapis.com/auth/generative-language.retriever", ], ) set_google_config(auth_credentials=credentials) get_ipython().system("mkdir -p 'data/paul_graham/'") get_ipython().system("wget 'https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt' -O 'data/paul_graham/paul_graham_essay.txt'") import llama_index.core.vector_stores.google.generativeai.genai_extension as genaix from typing import Iterable from random import randrange LLAMA_INDEX_COLAB_CORPUS_ID_PREFIX = f"llama-index-colab" SESSION_CORPUS_ID_PREFIX = ( f"{LLAMA_INDEX_COLAB_CORPUS_ID_PREFIX}-{randrange(1000000)}" ) def corpus_id(num_id: int) -> str: return f"{SESSION_CORPUS_ID_PREFIX}-{num_id}" SESSION_CORPUS_ID = corpus_id(1) def list_corpora() -> Iterable[genaix.Corpus]: client = genaix.build_semantic_retriever() yield from genaix.list_corpora(client=client) def delete_corpus(*, corpus_id: str) -> None: client = genaix.build_semantic_retriever() genaix.delete_corpus(corpus_id=corpus_id, client=client) def cleanup_colab_corpora(): for corpus in list_corpora(): if corpus.corpus_id.startswith(LLAMA_INDEX_COLAB_CORPUS_ID_PREFIX): try: delete_corpus(corpus_id=corpus.corpus_id) print(f"Deleted corpus {corpus.corpus_id}.") except Exception: pass cleanup_colab_corpora() from llama_index.core import SimpleDirectoryReader from llama_index.indices.managed.google import GoogleIndex from llama_index.core import Response import time index = GoogleIndex.create_corpus( corpus_id=SESSION_CORPUS_ID, display_name="My first corpus!" ) print(f"Newly created corpus ID is {index.corpus_id}.") documents = SimpleDirectoryReader("./data/paul_graham/").load_data() index.insert_documents(documents) for corpus in list_corpora(): print(corpus) query_engine = index.as_query_engine() response = query_engine.query("What did Paul Graham do growing up?") assert isinstance(response, Response) print(f"Response is {response.response}") for cited_text in [node.text for node in response.source_nodes]: print(f"Cited text: {cited_text}") if response.metadata: print( f"Answerability: {response.metadata.get('answerable_probability', 0)}" ) index = GoogleIndex.from_corpus(corpus_id=SESSION_CORPUS_ID) query_engine = index.as_query_engine() response = query_engine.query("Which company did Paul Graham build?") assert isinstance(response, Response) print(f"Response is {response.response}") from llama_index.core.schema import NodeRelationship, RelatedNodeInfo, TextNode index = GoogleIndex.from_corpus(corpus_id=SESSION_CORPUS_ID) index.insert_nodes( [ TextNode( text="It was the best of times.", relationships={ NodeRelationship.SOURCE: RelatedNodeInfo( node_id="123", metadata={"file_name": "Tale of Two Cities"}, ) }, ), TextNode( text="It was the worst of times.", relationships={ NodeRelationship.SOURCE: RelatedNodeInfo( node_id="123", metadata={"file_name": "Tale of Two Cities"}, ) }, ), TextNode( text="Bugs Bunny: Wassup doc?", relationships={ NodeRelationship.SOURCE: RelatedNodeInfo( node_id="456", metadata={"file_name": "Bugs Bunny Adventure"}, ) }, ), ] ) from google.ai.generativelanguage import ( GenerateAnswerRequest, HarmCategory, SafetySetting, ) index = GoogleIndex.from_corpus(corpus_id=SESSION_CORPUS_ID) query_engine = index.as_query_engine( temperature=0.2, answer_style=GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE, safety_setting=[ SafetySetting( category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold=SafetySetting.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE, ), SafetySetting( category=HarmCategory.HARM_CATEGORY_VIOLENCE, threshold=SafetySetting.HarmBlockThreshold.BLOCK_ONLY_HIGH, ), ], ) response = query_engine.query("What was Bugs Bunny's favorite saying?") print(response) from llama_index.core import Response response = query_engine.query("What were Paul Graham's achievements?") assert isinstance(response, Response) print(f"Response is {response.response}") for cited_text in [node.text for node in response.source_nodes]: print(f"Cited text: {cited_text}") if response.metadata: print( f"Answerability: {response.metadata.get('answerable_probability', 0)}" ) from llama_index.llms.gemini import Gemini GEMINI_API_KEY = "" # @param {type:"string"} gemini = Gemini(api_key=GEMINI_API_KEY) from llama_index.response_synthesizers.google import GoogleTextSynthesizer from llama_index.vector_stores.google import GoogleVectorStore from llama_index.core import VectorStoreIndex from llama_index.core.postprocessor import LLMRerank from llama_index.core.query_engine import RetrieverQueryEngine from llama_index.core.retrievers import VectorIndexRetriever store = GoogleVectorStore.from_corpus(corpus_id=SESSION_CORPUS_ID) index = VectorStoreIndex.from_vector_store( vector_store=store, ) response_synthesizer = GoogleTextSynthesizer.from_defaults( temperature=0.2, answer_style=GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE, ) reranker = LLMRerank( top_n=10, llm=gemini, ) query_engine = RetrieverQueryEngine.from_args( retriever=VectorIndexRetriever( index=index, similarity_top_k=20, ), node_postprocessors=[reranker], response_synthesizer=response_synthesizer, ) response = query_engine.query("What were Paul Graham's achievements?") print(response) from llama_index.core.indices.query.query_transform.base import ( StepDecomposeQueryTransform, ) from llama_index.core.query_engine import MultiStepQueryEngine store = GoogleVectorStore.from_corpus(corpus_id=SESSION_CORPUS_ID) index = VectorStoreIndex.from_vector_store( vector_store=store, ) response_synthesizer = GoogleTextSynthesizer.from_defaults( temperature=0.2, answer_style=GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE, ) single_step_query_engine = index.as_query_engine( similarity_top_k=10, response_synthesizer=response_synthesizer, ) step_decompose_transform = StepDecomposeQueryTransform( llm=gemini, verbose=True, ) query_engine = MultiStepQueryEngine( query_engine=single_step_query_engine, query_transform=step_decompose_transform, response_synthesizer=response_synthesizer, index_summary="Ask me anything.", num_steps=6, ) response = query_engine.query("What were Paul Graham's achievements?") print(response) from llama_index.core.indices.query.query_transform import HyDEQueryTransform from llama_index.core.query_engine import TransformQueryEngine store = GoogleVectorStore.from_corpus(corpus_id=SESSION_CORPUS_ID) index = VectorStoreIndex.from_vector_store( vector_store=store, ) response_synthesizer = GoogleTextSynthesizer.from_defaults( temperature=0.2, answer_style=GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE, ) base_query_engine = index.as_query_engine( similarity_top_k=10, response_synthesizer=response_synthesizer, ) hyde = HyDEQueryTransform( llm=gemini, include_original=False, ) hyde_query_engine = TransformQueryEngine(base_query_engine, hyde) response = query_engine.query("What were Paul Graham's achievements?") print(response) store = GoogleVectorStore.from_corpus(corpus_id=SESSION_CORPUS_ID) index = VectorStoreIndex.from_vector_store( vector_store=store, ) response_synthesizer = GoogleTextSynthesizer.from_defaults( temperature=0.2, answer_style=GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE ) reranker = LLMRerank( top_n=10, llm=gemini, ) single_step_query_engine = index.as_query_engine( similarity_top_k=20, node_postprocessors=[reranker], response_synthesizer=response_synthesizer, ) hyde = HyDEQueryTransform( llm=gemini, include_original=False, ) hyde_query_engine = TransformQueryEngine(single_step_query_engine, hyde) step_decompose_transform = StepDecomposeQueryTransform( llm=gemini, verbose=True ) query_engine = MultiStepQueryEngine( query_engine=hyde_query_engine, query_transform=step_decompose_transform, response_synthesizer=response_synthesizer, index_summary="Ask me anything.", num_steps=6, ) response = query_engine.query("What were Paul Graham's achievements?") print(response) cleanup_colab_corpora() project_name = "TODO-your-project-name" # @param {type:"string"} email = "TODO-your-email@gmail.com" # @param {type:"string"} client_file_name = "client_secret.json" get_ipython().system('gcloud config set project $project_name') get_ipython().system('gcloud config set account $email') get_ipython().system('gcloud auth application-default login --no-browser --client-id-file=$client_file_name --scopes="https://www.googleapis.com/auth/generative-language.retriever,https://www.googleapis.com/auth/cloud-platform"')

[((665, 830), 'google.oauth2.service_account.Credentials.from_service_account_file', 'service_account.Credentials.from_service_account_file', (['"""service_account_key.json"""'], {'scopes': "['https://www.googleapis.com/auth/generative-language.retriever']"}), "(\n 'service_account_key.json', scopes=[\n 'https://www.googleapis.com/auth/generative-language.retriever'])\n", (718, 830), False, 'from google.oauth2 import service_account\n'), ((847, 894), 'llama_index.vector_stores.google.set_google_config', 'set_google_config', ([], {'auth_credentials': 'credentials'}), '(auth_credentials=credentials)\n', (864, 894), False, 'from llama_index.vector_stores.google import set_google_config\n'), ((2390, 2482), 'llama_index.indices.managed.google.GoogleIndex.create_corpus', 'GoogleIndex.create_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID', 'display_name': '"""My first corpus!"""'}), "(corpus_id=SESSION_CORPUS_ID, display_name=\n 'My first corpus!')\n", (2415, 2482), False, 'from llama_index.indices.managed.google import GoogleIndex\n'), ((3123, 3175), 'llama_index.indices.managed.google.GoogleIndex.from_corpus', 'GoogleIndex.from_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID'}), '(corpus_id=SESSION_CORPUS_ID)\n', (3146, 3175), False, 'from llama_index.indices.managed.google import GoogleIndex\n'), ((3460, 3512), 'llama_index.indices.managed.google.GoogleIndex.from_corpus', 'GoogleIndex.from_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID'}), '(corpus_id=SESSION_CORPUS_ID)\n', (3483, 3512), False, 'from llama_index.indices.managed.google import GoogleIndex\n'), ((4556, 4608), 'llama_index.indices.managed.google.GoogleIndex.from_corpus', 'GoogleIndex.from_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID'}), '(corpus_id=SESSION_CORPUS_ID)\n', (4579, 4608), False, 'from llama_index.indices.managed.google import GoogleIndex\n'), ((5714, 5744), 'llama_index.llms.gemini.Gemini', 'Gemini', ([], {'api_key': 'GEMINI_API_KEY'}), '(api_key=GEMINI_API_KEY)\n', (5720, 5744), False, 'from llama_index.llms.gemini import Gemini\n'), ((6118, 6176), 'llama_index.vector_stores.google.GoogleVectorStore.from_corpus', 'GoogleVectorStore.from_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID'}), '(corpus_id=SESSION_CORPUS_ID)\n', (6147, 6176), False, 'from llama_index.vector_stores.google import GoogleVectorStore\n'), ((6185, 6239), 'llama_index.core.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', ([], {'vector_store': 'store'}), '(vector_store=store)\n', (6219, 6239), False, 'from llama_index.core import VectorStoreIndex\n'), ((6270, 6387), 'llama_index.response_synthesizers.google.GoogleTextSynthesizer.from_defaults', 'GoogleTextSynthesizer.from_defaults', ([], {'temperature': '(0.2)', 'answer_style': 'GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE'}), '(temperature=0.2, answer_style=\n GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE)\n', (6305, 6387), False, 'from llama_index.response_synthesizers.google import GoogleTextSynthesizer\n'), ((6405, 6436), 'llama_index.core.postprocessor.LLMRerank', 'LLMRerank', ([], {'top_n': '(10)', 'llm': 'gemini'}), '(top_n=10, llm=gemini)\n', (6414, 6436), False, 'from llama_index.core.postprocessor import LLMRerank\n'), ((6937, 6995), 'llama_index.vector_stores.google.GoogleVectorStore.from_corpus', 'GoogleVectorStore.from_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID'}), '(corpus_id=SESSION_CORPUS_ID)\n', (6966, 6995), False, 'from llama_index.vector_stores.google import GoogleVectorStore\n'), ((7004, 7058), 'llama_index.core.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', ([], {'vector_store': 'store'}), '(vector_store=store)\n', (7038, 7058), False, 'from llama_index.core import VectorStoreIndex\n'), ((7089, 7206), 'llama_index.response_synthesizers.google.GoogleTextSynthesizer.from_defaults', 'GoogleTextSynthesizer.from_defaults', ([], {'temperature': '(0.2)', 'answer_style': 'GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE'}), '(temperature=0.2, answer_style=\n GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE)\n', (7124, 7206), False, 'from llama_index.response_synthesizers.google import GoogleTextSynthesizer\n'), ((7364, 7417), 'llama_index.core.indices.query.query_transform.base.StepDecomposeQueryTransform', 'StepDecomposeQueryTransform', ([], {'llm': 'gemini', 'verbose': '(True)'}), '(llm=gemini, verbose=True)\n', (7391, 7417), False, 'from llama_index.core.indices.query.query_transform.base import StepDecomposeQueryTransform\n'), ((7444, 7644), 'llama_index.core.query_engine.MultiStepQueryEngine', 'MultiStepQueryEngine', ([], {'query_engine': 'single_step_query_engine', 'query_transform': 'step_decompose_transform', 'response_synthesizer': 'response_synthesizer', 'index_summary': '"""Ask me anything."""', 'num_steps': '(6)'}), "(query_engine=single_step_query_engine, query_transform\n =step_decompose_transform, response_synthesizer=response_synthesizer,\n index_summary='Ask me anything.', num_steps=6)\n", (7464, 7644), False, 'from llama_index.core.query_engine import MultiStepQueryEngine\n'), ((7900, 7958), 'llama_index.vector_stores.google.GoogleVectorStore.from_corpus', 'GoogleVectorStore.from_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID'}), '(corpus_id=SESSION_CORPUS_ID)\n', (7929, 7958), False, 'from llama_index.vector_stores.google import GoogleVectorStore\n'), ((7967, 8021), 'llama_index.core.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', ([], {'vector_store': 'store'}), '(vector_store=store)\n', (8001, 8021), False, 'from llama_index.core import VectorStoreIndex\n'), ((8052, 8169), 'llama_index.response_synthesizers.google.GoogleTextSynthesizer.from_defaults', 'GoogleTextSynthesizer.from_defaults', ([], {'temperature': '(0.2)', 'answer_style': 'GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE'}), '(temperature=0.2, answer_style=\n GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE)\n', (8087, 8169), False, 'from llama_index.response_synthesizers.google import GoogleTextSynthesizer\n'), ((8300, 8354), 'llama_index.core.indices.query.query_transform.HyDEQueryTransform', 'HyDEQueryTransform', ([], {'llm': 'gemini', 'include_original': '(False)'}), '(llm=gemini, include_original=False)\n', (8318, 8354), False, 'from llama_index.core.indices.query.query_transform import HyDEQueryTransform\n'), ((8386, 8431), 'llama_index.core.query_engine.TransformQueryEngine', 'TransformQueryEngine', (['base_query_engine', 'hyde'], {}), '(base_query_engine, hyde)\n', (8406, 8431), False, 'from llama_index.core.query_engine import TransformQueryEngine\n'), ((8531, 8589), 'llama_index.vector_stores.google.GoogleVectorStore.from_corpus', 'GoogleVectorStore.from_corpus', ([], {'corpus_id': 'SESSION_CORPUS_ID'}), '(corpus_id=SESSION_CORPUS_ID)\n', (8560, 8589), False, 'from llama_index.vector_stores.google import GoogleVectorStore\n'), ((8598, 8652), 'llama_index.core.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', ([], {'vector_store': 'store'}), '(vector_store=store)\n', (8632, 8652), False, 'from llama_index.core import VectorStoreIndex\n'), ((8683, 8800), 'llama_index.response_synthesizers.google.GoogleTextSynthesizer.from_defaults', 'GoogleTextSynthesizer.from_defaults', ([], {'temperature': '(0.2)', 'answer_style': 'GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE'}), '(temperature=0.2, answer_style=\n GenerateAnswerRequest.AnswerStyle.ABSTRACTIVE)\n', (8718, 8800), False, 'from llama_index.response_synthesizers.google import GoogleTextSynthesizer\n'), ((8814, 8845), 'llama_index.core.postprocessor.LLMRerank', 'LLMRerank', ([], {'top_n': '(10)', 'llm': 'gemini'}), '(top_n=10, llm=gemini)\n', (8823, 8845), False, 'from llama_index.core.postprocessor import LLMRerank\n'), ((9025, 9079), 'llama_index.core.indices.query.query_transform.HyDEQueryTransform', 'HyDEQueryTransform', ([], {'llm': 'gemini', 'include_original': '(False)'}), '(llm=gemini, include_original=False)\n', (9043, 9079), False, 'from llama_index.core.indices.query.query_transform import HyDEQueryTransform\n'), ((9111, 9163), 'llama_index.core.query_engine.TransformQueryEngine', 'TransformQueryEngine', (['single_step_query_engine', 'hyde'], {}), '(single_step_query_engine, hyde)\n', (9131, 9163), False, 'from llama_index.core.query_engine import TransformQueryEngine\n'), ((9192, 9245), 'llama_index.core.indices.query.query_transform.base.StepDecomposeQueryTransform', 'StepDecomposeQueryTransform', ([], {'llm': 'gemini', 'verbose': '(True)'}), '(llm=gemini, verbose=True)\n', (9219, 9245), False, 'from llama_index.core.indices.query.query_transform.base import StepDecomposeQueryTransform\n'), ((9267, 9460), 'llama_index.core.query_engine.MultiStepQueryEngine', 'MultiStepQueryEngine', ([], {'query_engine': 'hyde_query_engine', 'query_transform': 'step_decompose_transform', 'response_synthesizer': 'response_synthesizer', 'index_summary': '"""Ask me anything."""', 'num_steps': '(6)'}), "(query_engine=hyde_query_engine, query_transform=\n step_decompose_transform, response_synthesizer=response_synthesizer,\n index_summary='Ask me anything.', num_steps=6)\n", (9287, 9460), False, 'from llama_index.core.query_engine import MultiStepQueryEngine\n'), ((1624, 1657), 'llama_index.core.vector_stores.google.generativeai.genai_extension.build_semantic_retriever', 'genaix.build_semantic_retriever', ([], {}), '()\n', (1655, 1657), True, 'import llama_index.core.vector_stores.google.generativeai.genai_extension as genaix\n'), ((1769, 1802), 'llama_index.core.vector_stores.google.generativeai.genai_extension.build_semantic_retriever', 'genaix.build_semantic_retriever', ([], {}), '()\n', (1800, 1802), True, 'import llama_index.core.vector_stores.google.generativeai.genai_extension as genaix\n'), ((1807, 1863), 'llama_index.core.vector_stores.google.generativeai.genai_extension.delete_corpus', 'genaix.delete_corpus', ([], {'corpus_id': 'corpus_id', 'client': 'client'}), '(corpus_id=corpus_id, client=client)\n', (1827, 1863), True, 'import llama_index.core.vector_stores.google.generativeai.genai_extension as genaix\n'), ((1417, 1435), 'random.randrange', 'randrange', (['(1000000)'], {}), '(1000000)\n', (1426, 1435), False, 'from random import randrange\n'), ((1673, 1707), 'llama_index.core.vector_stores.google.generativeai.genai_extension.list_corpora', 'genaix.list_corpora', ([], {'client': 'client'}), '(client=client)\n', (1692, 1707), True, 'import llama_index.core.vector_stores.google.generativeai.genai_extension as genaix\n'), ((2553, 2597), 'llama_index.core.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""./data/paul_graham/"""'], {}), "('./data/paul_graham/')\n", (2574, 2597), False, 'from llama_index.core import SimpleDirectoryReader\n'), ((6509, 6563), 'llama_index.core.retrievers.VectorIndexRetriever', 'VectorIndexRetriever', ([], {'index': 'index', 'similarity_top_k': '(20)'}), '(index=index, similarity_top_k=20)\n', (6529, 6563), False, 'from llama_index.core.retrievers import VectorIndexRetriever\n'), ((4761, 4897), 'google.ai.generativelanguage.SafetySetting', 'SafetySetting', ([], {'category': 'HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT', 'threshold': 'SafetySetting.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE'}), '(category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,\n threshold=SafetySetting.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE)\n', (4774, 4897), False, 'from google.ai.generativelanguage import GenerateAnswerRequest, HarmCategory, SafetySetting\n'), ((4938, 5062), 'google.ai.generativelanguage.SafetySetting', 'SafetySetting', ([], {'category': 'HarmCategory.HARM_CATEGORY_VIOLENCE', 'threshold': 'SafetySetting.HarmBlockThreshold.BLOCK_ONLY_HIGH'}), '(category=HarmCategory.HARM_CATEGORY_VIOLENCE, threshold=\n SafetySetting.HarmBlockThreshold.BLOCK_ONLY_HIGH)\n', (4951, 5062), False, 'from google.ai.generativelanguage import GenerateAnswerRequest, HarmCategory, SafetySetting\n'), ((3672, 3748), 'llama_index.core.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': '"""123"""', 'metadata': "{'file_name': 'Tale of Two Cities'}"}), "(node_id='123', metadata={'file_name': 'Tale of Two Cities'})\n", (3687, 3748), False, 'from llama_index.core.schema import NodeRelationship, RelatedNodeInfo, TextNode\n'), ((3968, 4044), 'llama_index.core.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': '"""123"""', 'metadata': "{'file_name': 'Tale of Two Cities'}"}), "(node_id='123', metadata={'file_name': 'Tale of Two Cities'})\n", (3983, 4044), False, 'from llama_index.core.schema import NodeRelationship, RelatedNodeInfo, TextNode\n'), ((4261, 4339), 'llama_index.core.schema.RelatedNodeInfo', 'RelatedNodeInfo', ([], {'node_id': '"""456"""', 'metadata': "{'file_name': 'Bugs Bunny Adventure'}"}), "(node_id='456', metadata={'file_name': 'Bugs Bunny Adventure'})\n", (4276, 4339), False, 'from llama_index.core.schema import NodeRelationship, RelatedNodeInfo, TextNode\n')]

import logging from dataclasses import dataclass from typing import List, Optional import llama_index from llama_index.bridge.pydantic import BaseModel from llama_index.callbacks.base import CallbackManager from llama_index.embeddings.base import BaseEmbedding from llama_index.embeddings.utils import EmbedType, resolve_embed_model from llama_index.indices.prompt_helper import PromptHelper from llama_index.llm_predictor import LLMPredictor from llama_index.llm_predictor.base import BaseLLMPredictor, LLMMetadata from llama_index.llms.base import LLM from llama_index.llms.utils import LLMType, resolve_llm from llama_index.logger import LlamaLogger from llama_index.node_parser.interface import NodeParser, TextSplitter from llama_index.node_parser.text.sentence import ( DEFAULT_CHUNK_SIZE, SENTENCE_CHUNK_OVERLAP, SentenceSplitter, ) from llama_index.prompts.base import BasePromptTemplate from llama_index.schema import TransformComponent from llama_index.types import PydanticProgramMode logger = logging.getLogger(__name__) def _get_default_node_parser( chunk_size: int = DEFAULT_CHUNK_SIZE, chunk_overlap: int = SENTENCE_CHUNK_OVERLAP, callback_manager: Optional[CallbackManager] = None, ) -> NodeParser: """Get default node parser.""" return SentenceSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager or CallbackManager(), ) def _get_default_prompt_helper( llm_metadata: LLMMetadata, context_window: Optional[int] = None, num_output: Optional[int] = None, ) -> PromptHelper: """Get default prompt helper.""" if context_window is not None: llm_metadata.context_window = context_window if num_output is not None: llm_metadata.num_output = num_output return PromptHelper.from_llm_metadata(llm_metadata=llm_metadata) class ServiceContextData(BaseModel): llm: dict llm_predictor: dict prompt_helper: dict embed_model: dict transformations: List[dict] @dataclass class ServiceContext: """Service Context container. The service context container is a utility container for LlamaIndex index and query classes. It contains the following: - llm_predictor: BaseLLMPredictor - prompt_helper: PromptHelper - embed_model: BaseEmbedding - node_parser: NodeParser - llama_logger: LlamaLogger (deprecated) - callback_manager: CallbackManager """ llm_predictor: BaseLLMPredictor prompt_helper: PromptHelper embed_model: BaseEmbedding transformations: List[TransformComponent] llama_logger: LlamaLogger callback_manager: CallbackManager @classmethod def from_defaults( cls, llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[EmbedType] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # pydantic program mode (used if output_cls is specified) pydantic_program_mode: PydanticProgramMode = PydanticProgramMode.DEFAULT, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Create a ServiceContext from defaults. If an argument is specified, then use the argument value provided for that parameter. If an argument is not specified, then use the default value. You can change the base defaults by setting llama_index.global_service_context to a ServiceContext object with your desired settings. Args: llm_predictor (Optional[BaseLLMPredictor]): LLMPredictor prompt_helper (Optional[PromptHelper]): PromptHelper embed_model (Optional[BaseEmbedding]): BaseEmbedding or "local" (use local model) node_parser (Optional[NodeParser]): NodeParser llama_logger (Optional[LlamaLogger]): LlamaLogger (deprecated) chunk_size (Optional[int]): chunk_size callback_manager (Optional[CallbackManager]): CallbackManager system_prompt (Optional[str]): System-wide prompt to be prepended to all input prompts, used to guide system "decision making" query_wrapper_prompt (Optional[BasePromptTemplate]): A format to wrap passed-in input queries. Deprecated Args: chunk_size_limit (Optional[int]): renamed to chunk_size """ if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size instead" ) chunk_size = chunk_size_limit if llama_index.global_service_context is not None: return cls.from_service_context( llama_index.global_service_context, llm=llm, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, text_splitter=text_splitter, llama_logger=llama_logger, callback_manager=callback_manager, context_window=context_window, chunk_size=chunk_size, chunk_size_limit=chunk_size_limit, chunk_overlap=chunk_overlap, num_output=num_output, system_prompt=system_prompt, query_wrapper_prompt=query_wrapper_prompt, transformations=transformations, ) callback_manager = callback_manager or CallbackManager([]) if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm_predictor = llm_predictor or LLMPredictor( llm=llm, pydantic_program_mode=pydantic_program_mode ) if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # NOTE: embed model should be a transformation, but the way the service # context works, we can't put in there yet. embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or [node_parser] llama_logger = llama_logger or LlamaLogger() return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @classmethod def from_service_context( cls, service_context: "ServiceContext", llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[EmbedType] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Instantiate a new service context using a previous as the defaults.""" if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size", DeprecationWarning, ) chunk_size = chunk_size_limit callback_manager = callback_manager or service_context.callback_manager if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or service_context.llm_predictor if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # default to using the embed model passed from the service context if embed_model == "default": embed_model = service_context.embed_model embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or service_context.prompt_helper if context_window is not None or num_output is not None: prompt_helper = _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) transformations = transformations or [] node_parser_found = False for transform in service_context.transformations: if isinstance(transform, NodeParser): node_parser_found = True node_parser = transform break if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") if not node_parser_found: node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or service_context.transformations llama_logger = llama_logger or service_context.llama_logger return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @property def llm(self) -> LLM: if not isinstance(self.llm_predictor, LLMPredictor): raise ValueError("llm_predictor must be an instance of LLMPredictor") return self.llm_predictor.llm @property def node_parser(self) -> NodeParser: """Get the node parser.""" for transform in self.transformations: if isinstance(transform, NodeParser): return transform raise ValueError("No node parser found.") def to_dict(self) -> dict: """Convert service context to dict.""" llm_dict = self.llm_predictor.llm.to_dict() llm_predictor_dict = self.llm_predictor.to_dict() embed_model_dict = self.embed_model.to_dict() prompt_helper_dict = self.prompt_helper.to_dict() tranform_list_dict = [x.to_dict() for x in self.transformations] return ServiceContextData( llm=llm_dict, llm_predictor=llm_predictor_dict, prompt_helper=prompt_helper_dict, embed_model=embed_model_dict, transformations=tranform_list_dict, ).dict() @classmethod def from_dict(cls, data: dict) -> "ServiceContext": from llama_index.embeddings.loading import load_embed_model from llama_index.extractors.loading import load_extractor from llama_index.llm_predictor.loading import load_predictor from llama_index.node_parser.loading import load_parser service_context_data = ServiceContextData.parse_obj(data) llm_predictor = load_predictor(service_context_data.llm_predictor) embed_model = load_embed_model(service_context_data.embed_model) prompt_helper = PromptHelper.from_dict(service_context_data.prompt_helper) transformations: List[TransformComponent] = [] for transform in service_context_data.transformations: try: transformations.append(load_parser(transform)) except ValueError: transformations.append(load_extractor(transform)) return cls.from_defaults( llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, transformations=transformations, ) def set_global_service_context(service_context: Optional[ServiceContext]) -> None: """Helper function to set the global service context.""" llama_index.global_service_context = service_context

[((1019, 1046), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1036, 1046), False, 'import logging\n'), ((1821, 1878), 'llama_index.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', ([], {'llm_metadata': 'llm_metadata'}), '(llm_metadata=llm_metadata)\n', (1851, 1878), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((7115, 7147), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (7134, 7147), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((10676, 10708), 'llama_index.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (10695, 10708), False, 'from llama_index.embeddings.utils import EmbedType, resolve_embed_model\n'), ((13993, 14043), 'llama_index.llm_predictor.loading.load_predictor', 'load_predictor', (['service_context_data.llm_predictor'], {}), '(service_context_data.llm_predictor)\n', (14007, 14043), False, 'from llama_index.llm_predictor.loading import load_predictor\n'), ((14067, 14117), 'llama_index.embeddings.loading.load_embed_model', 'load_embed_model', (['service_context_data.embed_model'], {}), '(service_context_data.embed_model)\n', (14083, 14117), False, 'from llama_index.embeddings.loading import load_embed_model\n'), ((14143, 14201), 'llama_index.indices.prompt_helper.PromptHelper.from_dict', 'PromptHelper.from_dict', (['service_context_data.prompt_helper'], {}), '(service_context_data.prompt_helper)\n', (14165, 14201), False, 'from llama_index.indices.prompt_helper import PromptHelper\n'), ((6249, 6268), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (6264, 6268), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((6436, 6452), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (6447, 6452), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((6494, 6560), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm', 'pydantic_program_mode': 'pydantic_program_mode'}), '(llm=llm, pydantic_program_mode=pydantic_program_mode)\n', (6506, 6560), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((8023, 8036), 'llama_index.logger.LlamaLogger', 'LlamaLogger', ([], {}), '()\n', (8034, 8036), False, 'from llama_index.logger import LlamaLogger\n'), ((9971, 9987), 'llama_index.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (9982, 9987), False, 'from llama_index.llms.utils import LLMType, resolve_llm\n'), ((10016, 10037), 'llama_index.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (10028, 10037), False, 'from llama_index.llm_predictor import LLMPredictor\n'), ((1420, 1437), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', ([], {}), '()\n', (1435, 1437), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((14377, 14399), 'llama_index.node_parser.loading.load_parser', 'load_parser', (['transform'], {}), '(transform)\n', (14388, 14399), False, 'from llama_index.node_parser.loading import load_parser\n'), ((14471, 14496), 'llama_index.extractors.loading.load_extractor', 'load_extractor', (['transform'], {}), '(transform)\n', (14485, 14496), False, 'from llama_index.extractors.loading import load_extractor\n')]

import logging from dataclasses import dataclass from typing import Any, List, Optional, cast from deprecated import deprecated import llama_index.core from llama_index.core.bridge.pydantic import BaseModel from llama_index.core.callbacks.base import CallbackManager from llama_index.core.base.embeddings.base import BaseEmbedding from llama_index.core.indices.prompt_helper import PromptHelper from llama_index.core.service_context_elements.llm_predictor import ( LLMPredictor, BaseLLMPredictor, ) from llama_index.core.llms.base import LLMMetadata from llama_index.core.llms.llm import LLM from llama_index.core.llms.utils import LLMType, resolve_llm from llama_index.core.service_context_elements.llama_logger import LlamaLogger from llama_index.core.node_parser.interface import NodeParser, TextSplitter from llama_index.core.node_parser.text.sentence import ( DEFAULT_CHUNK_SIZE, SENTENCE_CHUNK_OVERLAP, SentenceSplitter, ) from llama_index.core.prompts.base import BasePromptTemplate from llama_index.core.schema import TransformComponent from llama_index.core.types import PydanticProgramMode logger = logging.getLogger(__name__) def _get_default_node_parser( chunk_size: int = DEFAULT_CHUNK_SIZE, chunk_overlap: int = SENTENCE_CHUNK_OVERLAP, callback_manager: Optional[CallbackManager] = None, ) -> NodeParser: """Get default node parser.""" return SentenceSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap, callback_manager=callback_manager or CallbackManager(), ) def _get_default_prompt_helper( llm_metadata: LLMMetadata, context_window: Optional[int] = None, num_output: Optional[int] = None, ) -> PromptHelper: """Get default prompt helper.""" if context_window is not None: llm_metadata.context_window = context_window if num_output is not None: llm_metadata.num_output = num_output return PromptHelper.from_llm_metadata(llm_metadata=llm_metadata) class ServiceContextData(BaseModel): llm: dict llm_predictor: dict prompt_helper: dict embed_model: dict transformations: List[dict] @dataclass class ServiceContext: """Service Context container. The service context container is a utility container for LlamaIndex index and query classes. It contains the following: - llm_predictor: BaseLLMPredictor - prompt_helper: PromptHelper - embed_model: BaseEmbedding - node_parser: NodeParser - llama_logger: LlamaLogger (deprecated) - callback_manager: CallbackManager """ llm_predictor: BaseLLMPredictor prompt_helper: PromptHelper embed_model: BaseEmbedding transformations: List[TransformComponent] llama_logger: LlamaLogger callback_manager: CallbackManager @classmethod @deprecated( version="0.10.0", reason="ServiceContext is deprecated, please use `llama_index.settings.Settings` instead.", ) def from_defaults( cls, llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[Any] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # pydantic program mode (used if output_cls is specified) pydantic_program_mode: PydanticProgramMode = PydanticProgramMode.DEFAULT, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Create a ServiceContext from defaults. If an argument is specified, then use the argument value provided for that parameter. If an argument is not specified, then use the default value. You can change the base defaults by setting llama_index.global_service_context to a ServiceContext object with your desired settings. Args: llm_predictor (Optional[BaseLLMPredictor]): LLMPredictor prompt_helper (Optional[PromptHelper]): PromptHelper embed_model (Optional[BaseEmbedding]): BaseEmbedding or "local" (use local model) node_parser (Optional[NodeParser]): NodeParser llama_logger (Optional[LlamaLogger]): LlamaLogger (deprecated) chunk_size (Optional[int]): chunk_size callback_manager (Optional[CallbackManager]): CallbackManager system_prompt (Optional[str]): System-wide prompt to be prepended to all input prompts, used to guide system "decision making" query_wrapper_prompt (Optional[BasePromptTemplate]): A format to wrap passed-in input queries. Deprecated Args: chunk_size_limit (Optional[int]): renamed to chunk_size """ from llama_index.core.embeddings.utils import EmbedType, resolve_embed_model embed_model = cast(EmbedType, embed_model) if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size instead" ) chunk_size = chunk_size_limit if llama_index.core.global_service_context is not None: return cls.from_service_context( llama_index.core.global_service_context, llm=llm, llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, node_parser=node_parser, text_splitter=text_splitter, llama_logger=llama_logger, callback_manager=callback_manager, context_window=context_window, chunk_size=chunk_size, chunk_size_limit=chunk_size_limit, chunk_overlap=chunk_overlap, num_output=num_output, system_prompt=system_prompt, query_wrapper_prompt=query_wrapper_prompt, transformations=transformations, ) callback_manager = callback_manager or CallbackManager([]) if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm.system_prompt = llm.system_prompt or system_prompt llm.query_wrapper_prompt = llm.query_wrapper_prompt or query_wrapper_prompt llm.pydantic_program_mode = ( llm.pydantic_program_mode or pydantic_program_mode ) if llm_predictor is not None: print("LLMPredictor is deprecated, please use LLM instead.") llm_predictor = llm_predictor or LLMPredictor( llm=llm, pydantic_program_mode=pydantic_program_mode ) if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # NOTE: embed model should be a transformation, but the way the service # context works, we can't put in there yet. embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or [node_parser] llama_logger = llama_logger or LlamaLogger() return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @classmethod def from_service_context( cls, service_context: "ServiceContext", llm_predictor: Optional[BaseLLMPredictor] = None, llm: Optional[LLMType] = "default", prompt_helper: Optional[PromptHelper] = None, embed_model: Optional[Any] = "default", node_parser: Optional[NodeParser] = None, text_splitter: Optional[TextSplitter] = None, transformations: Optional[List[TransformComponent]] = None, llama_logger: Optional[LlamaLogger] = None, callback_manager: Optional[CallbackManager] = None, system_prompt: Optional[str] = None, query_wrapper_prompt: Optional[BasePromptTemplate] = None, # node parser kwargs chunk_size: Optional[int] = None, chunk_overlap: Optional[int] = None, # prompt helper kwargs context_window: Optional[int] = None, num_output: Optional[int] = None, # deprecated kwargs chunk_size_limit: Optional[int] = None, ) -> "ServiceContext": """Instantiate a new service context using a previous as the defaults.""" from llama_index.core.embeddings.utils import EmbedType, resolve_embed_model embed_model = cast(EmbedType, embed_model) if chunk_size_limit is not None and chunk_size is None: logger.warning( "chunk_size_limit is deprecated, please specify chunk_size", DeprecationWarning, ) chunk_size = chunk_size_limit callback_manager = callback_manager or service_context.callback_manager if llm != "default": if llm_predictor is not None: raise ValueError("Cannot specify both llm and llm_predictor") llm = resolve_llm(llm) llm_predictor = LLMPredictor(llm=llm) llm_predictor = llm_predictor or service_context.llm_predictor if isinstance(llm_predictor, LLMPredictor): llm_predictor.llm.callback_manager = callback_manager if system_prompt: llm_predictor.system_prompt = system_prompt if query_wrapper_prompt: llm_predictor.query_wrapper_prompt = query_wrapper_prompt # NOTE: the embed_model isn't used in all indices # default to using the embed model passed from the service context if embed_model == "default": embed_model = service_context.embed_model embed_model = resolve_embed_model(embed_model) embed_model.callback_manager = callback_manager prompt_helper = prompt_helper or service_context.prompt_helper if context_window is not None or num_output is not None: prompt_helper = _get_default_prompt_helper( llm_metadata=llm_predictor.metadata, context_window=context_window, num_output=num_output, ) transformations = transformations or [] node_parser_found = False for transform in service_context.transformations: if isinstance(transform, NodeParser): node_parser_found = True node_parser = transform break if text_splitter is not None and node_parser is not None: raise ValueError("Cannot specify both text_splitter and node_parser") if not node_parser_found: node_parser = ( text_splitter # text splitter extends node parser or node_parser or _get_default_node_parser( chunk_size=chunk_size or DEFAULT_CHUNK_SIZE, chunk_overlap=chunk_overlap or SENTENCE_CHUNK_OVERLAP, callback_manager=callback_manager, ) ) transformations = transformations or service_context.transformations llama_logger = llama_logger or service_context.llama_logger return cls( llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, transformations=transformations, llama_logger=llama_logger, # deprecated callback_manager=callback_manager, ) @property def llm(self) -> LLM: return self.llm_predictor.llm @property def node_parser(self) -> NodeParser: """Get the node parser.""" for transform in self.transformations: if isinstance(transform, NodeParser): return transform raise ValueError("No node parser found.") def to_dict(self) -> dict: """Convert service context to dict.""" llm_dict = self.llm_predictor.llm.to_dict() llm_predictor_dict = self.llm_predictor.to_dict() embed_model_dict = self.embed_model.to_dict() prompt_helper_dict = self.prompt_helper.to_dict() tranform_list_dict = [x.to_dict() for x in self.transformations] return ServiceContextData( llm=llm_dict, llm_predictor=llm_predictor_dict, prompt_helper=prompt_helper_dict, embed_model=embed_model_dict, transformations=tranform_list_dict, ).dict() @classmethod def from_dict(cls, data: dict) -> "ServiceContext": from llama_index.core.embeddings.loading import load_embed_model from llama_index.core.extractors.loading import load_extractor from llama_index.core.node_parser.loading import load_parser from llama_index.core.service_context_elements.llm_predictor import ( load_predictor, ) service_context_data = ServiceContextData.parse_obj(data) llm_predictor = load_predictor(service_context_data.llm_predictor) embed_model = load_embed_model(service_context_data.embed_model) prompt_helper = PromptHelper.from_dict(service_context_data.prompt_helper) transformations: List[TransformComponent] = [] for transform in service_context_data.transformations: try: transformations.append(load_parser(transform)) except ValueError: transformations.append(load_extractor(transform)) return cls.from_defaults( llm_predictor=llm_predictor, prompt_helper=prompt_helper, embed_model=embed_model, transformations=transformations, ) def set_global_service_context(service_context: Optional[ServiceContext]) -> None: """Helper function to set the global service context.""" llama_index.core.global_service_context = service_context if service_context is not None: from llama_index.core.settings import Settings Settings.llm = service_context.llm Settings.embed_model = service_context.embed_model Settings.prompt_helper = service_context.prompt_helper Settings.transformations = service_context.transformations Settings.node_parser = service_context.node_parser Settings.callback_manager = service_context.callback_manager

[((1132, 1159), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1149, 1159), False, 'import logging\n'), ((1934, 1991), 'llama_index.core.indices.prompt_helper.PromptHelper.from_llm_metadata', 'PromptHelper.from_llm_metadata', ([], {'llm_metadata': 'llm_metadata'}), '(llm_metadata=llm_metadata)\n', (1964, 1991), False, 'from llama_index.core.indices.prompt_helper import PromptHelper\n'), ((2811, 2941), 'deprecated.deprecated', 'deprecated', ([], {'version': '"""0.10.0"""', 'reason': '"""ServiceContext is deprecated, please use `llama_index.settings.Settings` instead."""'}), "(version='0.10.0', reason=\n 'ServiceContext is deprecated, please use `llama_index.settings.Settings` instead.'\n )\n", (2821, 2941), False, 'from deprecated import deprecated\n'), ((5452, 5480), 'typing.cast', 'cast', (['EmbedType', 'embed_model'], {}), '(EmbedType, embed_model)\n', (5456, 5480), False, 'from typing import Any, List, Optional, cast\n'), ((7909, 7941), 'llama_index.core.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (7928, 7941), False, 'from llama_index.core.embeddings.utils import EmbedType, resolve_embed_model\n'), ((10358, 10386), 'typing.cast', 'cast', (['EmbedType', 'embed_model'], {}), '(EmbedType, embed_model)\n', (10362, 10386), False, 'from typing import Any, List, Optional, cast\n'), ((11602, 11634), 'llama_index.core.embeddings.utils.resolve_embed_model', 'resolve_embed_model', (['embed_model'], {}), '(embed_model)\n', (11621, 11634), False, 'from llama_index.core.embeddings.utils import EmbedType, resolve_embed_model\n'), ((14838, 14888), 'llama_index.core.service_context_elements.llm_predictor.load_predictor', 'load_predictor', (['service_context_data.llm_predictor'], {}), '(service_context_data.llm_predictor)\n', (14852, 14888), False, 'from llama_index.core.service_context_elements.llm_predictor import load_predictor\n'), ((14912, 14962), 'llama_index.core.embeddings.loading.load_embed_model', 'load_embed_model', (['service_context_data.embed_model'], {}), '(service_context_data.embed_model)\n', (14928, 14962), False, 'from llama_index.core.embeddings.loading import load_embed_model\n'), ((14988, 15046), 'llama_index.core.indices.prompt_helper.PromptHelper.from_dict', 'PromptHelper.from_dict', (['service_context_data.prompt_helper'], {}), '(service_context_data.prompt_helper)\n', (15010, 15046), False, 'from llama_index.core.indices.prompt_helper import PromptHelper\n'), ((6653, 6672), 'llama_index.core.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (6668, 6672), False, 'from llama_index.core.callbacks.base import CallbackManager\n'), ((6840, 6856), 'llama_index.core.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (6851, 6856), False, 'from llama_index.core.llms.utils import LLMType, resolve_llm\n'), ((7288, 7354), 'llama_index.core.service_context_elements.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm', 'pydantic_program_mode': 'pydantic_program_mode'}), '(llm=llm, pydantic_program_mode=pydantic_program_mode)\n', (7300, 7354), False, 'from llama_index.core.service_context_elements.llm_predictor import LLMPredictor, BaseLLMPredictor\n'), ((8817, 8830), 'llama_index.core.service_context_elements.llama_logger.LlamaLogger', 'LlamaLogger', ([], {}), '()\n', (8828, 8830), False, 'from llama_index.core.service_context_elements.llama_logger import LlamaLogger\n'), ((10897, 10913), 'llama_index.core.llms.utils.resolve_llm', 'resolve_llm', (['llm'], {}), '(llm)\n', (10908, 10913), False, 'from llama_index.core.llms.utils import LLMType, resolve_llm\n'), ((10942, 10963), 'llama_index.core.service_context_elements.llm_predictor.LLMPredictor', 'LLMPredictor', ([], {'llm': 'llm'}), '(llm=llm)\n', (10954, 10963), False, 'from llama_index.core.service_context_elements.llm_predictor import LLMPredictor, BaseLLMPredictor\n'), ((1533, 1550), 'llama_index.core.callbacks.base.CallbackManager', 'CallbackManager', ([], {}), '()\n', (1548, 1550), False, 'from llama_index.core.callbacks.base import CallbackManager\n'), ((15222, 15244), 'llama_index.core.node_parser.loading.load_parser', 'load_parser', (['transform'], {}), '(transform)\n', (15233, 15244), False, 'from llama_index.core.node_parser.loading import load_parser\n'), ((15316, 15341), 'llama_index.core.extractors.loading.load_extractor', 'load_extractor', (['transform'], {}), '(transform)\n', (15330, 15341), False, 'from llama_index.core.extractors.loading import load_extractor\n')]

import itertools import logging from os import path from typing import List, Sequence import llama_index.vector_stores import ray from kfp import compiler, dsl from langchain.embeddings.fake import FakeEmbeddings from llama_index import ServiceContext, StorageContext, VectorStoreIndex from llama_index.data_structs import IndexDict from llama_index.llms import MockLLM import vectorize_fileset logging.basicConfig(level=logging.INFO) ## The default concurrency for the number of concurrent ## ray tasks DEFAULT_CPU_CONCURRENCY = 150 DEFAULT_GPU_CONCURRENCY = 10 ## The largest number of tasks we'll wait for at a time READY_BATCH_SIZE = 1 def get_fs(url: str): import fsspec return fsspec.filesystem(url.split("://", 1)[0]) def url_as_path(url: str) -> str: """Converts a URL to a path.""" return url.split("://", 1)[-1] def persist_nodes(nodes: List, vectordb_cls: str, vectordb_kwargs: dict): if vectordb_cls is None: logging.warn("Unable to persist nodes, there is no vector store specified") return if len(nodes) == 0: return cls = getattr(llama_index.vector_stores, vectordb_cls) vectordb_kwargs["dim"] = len(nodes[0].embedding) vector_store = cls(**vectordb_kwargs) service_context = ServiceContext.from_defaults( llm=MockLLM(), embed_model=FakeEmbeddings(size=len(nodes[0].embedding)) ) storage_context = StorageContext.from_defaults(vector_store=vector_store) vector_store_index = VectorStoreIndex( storage_context=storage_context, index_struct=IndexDict(), service_context=service_context, ) logging.info(f"Persisting {len(nodes)} nodes to vector store") vector_store_index.insert_nodes(nodes) def partition(lst: Sequence, size: int): for i in range(0, len(lst), size): yield lst[i : i + size] def ray_vectorize_dataset( ray_address: str, root_uri: str, files: List[str], batch_size=1000, vectordb_cls: str = None, vectordb_kwargs: dict = None, concurrency: int = None, use_gpu: bool = False, ): runtime_env = { "working_dir": ".", "py_modules": [vectorize_fileset], "conda": { "dependencies": [ "pip", { "pip": [ "gcsfs~=2023.9", "s3fs~=2023.9", "fsspec~=2023.9", "llama_index~=0.8.29", "langchain~=0.0.298", "sentence-transformers~=2.2", "nltk", ] }, ], }, } ray.init(address=ray_address, runtime_env=runtime_env) num_cpus = 2 if not use_gpu else 1 num_gpus = 1 if use_gpu else 0 ## Make remote versions of the functions we'll need remote_vectorize_fileset = ray.remote(vectorize_fileset.vectorize_fileset) remote_vectorize_fileset = remote_vectorize_fileset.options( num_cpus=num_cpus, num_gpus=num_gpus ) if concurrency is None: concurrency = DEFAULT_GPU_CONCURRENCY if use_gpu else DEFAULT_CPU_CONCURRENCY ## Partition the file lists into batches and submit them to ray result_refs = [] for p in partition(files, size=batch_size): results = None if len(result_refs) >= concurrency: ready_refs, result_refs = ray.wait( result_refs, num_returns=min(READY_BATCH_SIZE, len(result_refs)) ) results = ray.get(ready_refs) result_refs.append(remote_vectorize_fileset.remote(root_uri, p)) if results: persist_nodes( list(itertools.chain(*results)), vectordb_cls=vectordb_cls, vectordb_kwargs=vectordb_kwargs, ) while result_refs: ready_refs, result_refs = ray.wait( result_refs, num_returns=min(READY_BATCH_SIZE, len(result_refs)) ) results = ray.get(ready_refs) persist_nodes( list(itertools.chain(*results)), vectordb_cls=vectordb_cls, vectordb_kwargs=vectordb_kwargs, ) @dsl.component( target_image="us-central1-docker.pkg.dev/kflow-artifacts/kfp-components/kfp-vectorize-dataset:latest", base_image="python:3.10-slim", packages_to_install=[ "ray[client]~=2.7", "gcsfs~=2023.9", "s3fs~=2023.9", "fsspec~=2023.9", "llama_index~=0.8.29", "pymilvus~=2.3", ], ) def vectorize_dataset( dataset_url: str, vectordb_cls: str, vectordb_kwargs: dict, ray_address: str, batch_size: int, concurrency: int, use_gpu: bool, ): """ Vectorizes each file ina dataset and persists them to a datastore If `ray_address` is provided, then the component will use ray tasks to vectorize batches of the files in parallel. Otherwise, it will vectorize the files sequentially. Args: dataset_url: The URL of the dataset to vectorize. This should be a directory of separate documents. All files in the directory and any subdirectory will be vectorized. The URL should be in the form of a supported fsspec URL (e.g. `gs://` for Google Cloud Storage, `s3://` for S3, etc.) vectordb_cls: The class of the vector store to persist the vectors to. This should be a class from `llama_index.vector_stores`. If `None`, then the vectors will not be persisted. vectordb_kwargs: The keyword arguments to pass to the vector store class constructor. ray_address: The address of the ray cluster to use for parallelization. If `None`, then the files will be vectorized sequentially. batch_size: The number of files to vectorize in each batch. This is only used if `ray_address` is provided. concurrency: The maximum number of concurrent ray tasks to run. This is only used if `ray_address` is provided. """ fs = get_fs(dataset_url) dataset_path = url_as_path(dataset_url) dataset_path = dataset_path.rstrip("/") + "/" ## Ensure the path ends with a slash all_files = list( itertools.chain( *[ [path.join(dirpath.replace(dataset_path, ""), f) for f in files] for dirpath, _, files in fs.walk(dataset_path) ] ) ) if ray_address is not None: ray_vectorize_dataset( ray_address, dataset_url, all_files, vectordb_cls=vectordb_cls, vectordb_kwargs=vectordb_kwargs, batch_size=batch_size, concurrency=concurrency, use_gpu=use_gpu, ) else: nodes = vectorize_fileset(dataset_url, all_files) persist_nodes(nodes, vectordb_cls=vectordb_cls, vectordb_kwargs=vectordb_kwargs) if __name__ == "__main__": compiler.Compiler().compile( vectorize_dataset, path.join(path.dirname(__file__), "..", "component.yaml") )

[((397, 436), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (416, 436), False, 'import logging\n'), ((4202, 4501), 'kfp.dsl.component', 'dsl.component', ([], {'target_image': '"""us-central1-docker.pkg.dev/kflow-artifacts/kfp-components/kfp-vectorize-dataset:latest"""', 'base_image': '"""python:3.10-slim"""', 'packages_to_install': "['ray[client]~=2.7', 'gcsfs~=2023.9', 's3fs~=2023.9', 'fsspec~=2023.9',\n 'llama_index~=0.8.29', 'pymilvus~=2.3']"}), "(target_image=\n 'us-central1-docker.pkg.dev/kflow-artifacts/kfp-components/kfp-vectorize-dataset:latest'\n , base_image='python:3.10-slim', packages_to_install=[\n 'ray[client]~=2.7', 'gcsfs~=2023.9', 's3fs~=2023.9', 'fsspec~=2023.9',\n 'llama_index~=0.8.29', 'pymilvus~=2.3'])\n", (4215, 4501), False, 'from kfp import compiler, dsl\n'), ((1410, 1465), 'llama_index.StorageContext.from_defaults', 'StorageContext.from_defaults', ([], {'vector_store': 'vector_store'}), '(vector_store=vector_store)\n', (1438, 1465), False, 'from llama_index import ServiceContext, StorageContext, VectorStoreIndex\n'), ((2680, 2734), 'ray.init', 'ray.init', ([], {'address': 'ray_address', 'runtime_env': 'runtime_env'}), '(address=ray_address, runtime_env=runtime_env)\n', (2688, 2734), False, 'import ray\n'), ((2898, 2945), 'ray.remote', 'ray.remote', (['vectorize_fileset.vectorize_fileset'], {}), '(vectorize_fileset.vectorize_fileset)\n', (2908, 2945), False, 'import ray\n'), ((962, 1037), 'logging.warn', 'logging.warn', (['"""Unable to persist nodes, there is no vector store specified"""'], {}), "('Unable to persist nodes, there is no vector store specified')\n", (974, 1037), False, 'import logging\n'), ((4017, 4036), 'ray.get', 'ray.get', (['ready_refs'], {}), '(ready_refs)\n', (4024, 4036), False, 'import ray\n'), ((6788, 6829), 'vectorize_fileset', 'vectorize_fileset', (['dataset_url', 'all_files'], {}), '(dataset_url, all_files)\n', (6805, 6829), False, 'import vectorize_fileset\n'), ((1314, 1323), 'llama_index.llms.MockLLM', 'MockLLM', ([], {}), '()\n', (1321, 1323), False, 'from llama_index.llms import MockLLM\n'), ((1571, 1582), 'llama_index.data_structs.IndexDict', 'IndexDict', ([], {}), '()\n', (1580, 1582), False, 'from llama_index.data_structs import IndexDict\n'), ((3548, 3567), 'ray.get', 'ray.get', (['ready_refs'], {}), '(ready_refs)\n', (3555, 3567), False, 'import ray\n'), ((6952, 6971), 'kfp.compiler.Compiler', 'compiler.Compiler', ([], {}), '()\n', (6969, 6971), False, 'from kfp import compiler, dsl\n'), ((7018, 7040), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (7030, 7040), False, 'from os import path\n'), ((4077, 4102), 'itertools.chain', 'itertools.chain', (['*results'], {}), '(*results)\n', (4092, 4102), False, 'import itertools\n'), ((3710, 3735), 'itertools.chain', 'itertools.chain', (['*results'], {}), '(*results)\n', (3725, 3735), False, 'import itertools\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. """Module for configuring objects used to create OpenTelemetry traces.""" import os from opentelemetry import trace, context from opentelemetry.sdk.resources import SERVICE_NAME, Resource from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import SimpleSpanProcessor from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator from opentelemetry.propagate import set_global_textmap, get_global_textmap from opentelemetry.propagators.composite import CompositePropagator from tools.observability.llamaindex import opentelemetry_callback import llama_index from llama_index.callbacks.base import CallbackManager from functools import wraps # Configure tracer used by the Chain Server to create spans resource = Resource.create({SERVICE_NAME: "chain-server"}) provider = TracerProvider(resource=resource) if os.environ.get("ENABLE_TRACING") == "true": processor = SimpleSpanProcessor(OTLPSpanExporter()) provider.add_span_processor(processor) trace.set_tracer_provider(provider) tracer = trace.get_tracer("chain-server") # Configure Propagator used for processing trace context received by the Chain Server if os.environ.get("ENABLE_TRACING") == "true": propagator = TraceContextTextMapPropagator() # Llamaindex global handler set to pass callbacks into the OpenTelemetry handler llama_index.global_handler = opentelemetry_callback.OpenTelemetryCallbackHandler(tracer) else: propagator = CompositePropagator([]) # No-op propagator set_global_textmap(propagator) # Wrapper Function to perform instrumentation def instrumentation_wrapper(func): @wraps(func) async def wrapper(*args, **kwargs): request = kwargs.get("request") prompt = kwargs.get("prompt") ctx = get_global_textmap().extract(request.headers) if ctx is not None: context.attach(ctx) if prompt is not None and prompt.use_knowledge_base == False: # Hack to get the LLM event for no knowledge base queries to show up. # A trace is not generated by Llamaindex for these calls so we need to generate it instead. callback_manager = CallbackManager([]) with callback_manager.as_trace("query"): result = func(*args, **kwargs) else: result = func(*args, **kwargs) return await result return wrapper

[((1536, 1583), 'opentelemetry.sdk.resources.Resource.create', 'Resource.create', (["{SERVICE_NAME: 'chain-server'}"], {}), "({SERVICE_NAME: 'chain-server'})\n", (1551, 1583), False, 'from opentelemetry.sdk.resources import SERVICE_NAME, Resource\n'), ((1595, 1628), 'opentelemetry.sdk.trace.TracerProvider', 'TracerProvider', ([], {'resource': 'resource'}), '(resource=resource)\n', (1609, 1628), False, 'from opentelemetry.sdk.trace import TracerProvider\n'), ((1775, 1810), 'opentelemetry.trace.set_tracer_provider', 'trace.set_tracer_provider', (['provider'], {}), '(provider)\n', (1800, 1810), False, 'from opentelemetry import trace, context\n'), ((1820, 1852), 'opentelemetry.trace.get_tracer', 'trace.get_tracer', (['"""chain-server"""'], {}), "('chain-server')\n", (1836, 1852), False, 'from opentelemetry import trace, context\n'), ((2280, 2310), 'opentelemetry.propagate.set_global_textmap', 'set_global_textmap', (['propagator'], {}), '(propagator)\n', (2298, 2310), False, 'from opentelemetry.propagate import set_global_textmap, get_global_textmap\n'), ((1632, 1664), 'os.environ.get', 'os.environ.get', (['"""ENABLE_TRACING"""'], {}), "('ENABLE_TRACING')\n", (1646, 1664), False, 'import os\n'), ((1943, 1975), 'os.environ.get', 'os.environ.get', (['"""ENABLE_TRACING"""'], {}), "('ENABLE_TRACING')\n", (1957, 1975), False, 'import os\n'), ((2004, 2035), 'opentelemetry.trace.propagation.tracecontext.TraceContextTextMapPropagator', 'TraceContextTextMapPropagator', ([], {}), '()\n', (2033, 2035), False, 'from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator\n'), ((2154, 2213), 'tools.observability.llamaindex.opentelemetry_callback.OpenTelemetryCallbackHandler', 'opentelemetry_callback.OpenTelemetryCallbackHandler', (['tracer'], {}), '(tracer)\n', (2205, 2213), False, 'from tools.observability.llamaindex import opentelemetry_callback\n'), ((2237, 2260), 'opentelemetry.propagators.composite.CompositePropagator', 'CompositePropagator', (['[]'], {}), '([])\n', (2256, 2260), False, 'from opentelemetry.propagators.composite import CompositePropagator\n'), ((2398, 2409), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (2403, 2409), False, 'from functools import wraps\n'), ((1712, 1730), 'opentelemetry.exporter.otlp.proto.grpc.trace_exporter.OTLPSpanExporter', 'OTLPSpanExporter', ([], {}), '()\n', (1728, 1730), False, 'from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter\n'), ((2628, 2647), 'opentelemetry.context.attach', 'context.attach', (['ctx'], {}), '(ctx)\n', (2642, 2647), False, 'from opentelemetry import trace, context\n'), ((2935, 2954), 'llama_index.callbacks.base.CallbackManager', 'CallbackManager', (['[]'], {}), '([])\n', (2950, 2954), False, 'from llama_index.callbacks.base import CallbackManager\n'), ((2542, 2562), 'opentelemetry.propagate.get_global_textmap', 'get_global_textmap', ([], {}), '()\n', (2560, 2562), False, 'from opentelemetry.propagate import set_global_textmap, get_global_textmap\n')]

import json import os import time import fitz # PyMuPDF import llama_index import openai import weaviate from weaviate.gql.get import HybridFusion from unstructured.cleaners.core import clean from llama_index.vector_stores import WeaviateVectorStore from llama_index import VectorStoreIndex, ServiceContext, set_global_service_context from llama_index.response.pprint_utils import pprint_source_node import os import weaviate from langchain.document_loaders import GutenbergLoader from langchain.embeddings.openai import OpenAIEmbeddings from langchain.text_splitter import CharacterTextSplitter from langchain.vectorstores import Weaviate # Grimms' Fairy Tales by Jacob Grimm and Wilhelm Grimm loader = GutenbergLoader("https://www.gutenberg.org/files/2591/2591-0.txt") documents = loader.load() text_splitter = CharacterTextSplitter( chunk_size=500, chunk_overlap=0, length_function=len ) docs = text_splitter.split_documents(documents) WEAVIATE_URL = "http://weaviate:8080" client = weaviate.Client( url=WEAVIATE_URL, additional_headers={"X-OpenAI-Api-Key": os.environ["OPENAI_API_KEY"]}, ) client.schema.delete_all() client.schema.get() schema = { "classes": [ { "class": "Test", "description": "A written paragraph", "vectorizer": "text2vec-openai", "moduleConfig": {"text2vec-openai": {"model": "ada", "type": "text"}}, }, ] } client.schema.create(schema) vectorstore = Weaviate(client, "Paragraph", "content") text_meta_pair = [(doc.page_content, doc.metadata) for doc in docs] texts, meta = list(zip(*text_meta_pair)) vectorstore.add_texts(texts, meta) query = "the part where with talking animals" docs = vectorstore.similarity_search(query) for doc in docs: print(doc.page_content) print("*" * 80) azure_openai_key = os.getenv("AZURE_OPENAI_KEY") azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT") resource_name = os.getenv("RESOURCE_NAME") azure_client = openai.lib.azure.AzureOpenAI( azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"), api_key=os.getenv("AZURE_OPENAI_KEY"), api_version="2023-05-15" ) headers = { "X-Azure-Api-Key": azure_openai_key, } def query_openai(messages): return azure_client.chat.completions.create( model="gpt-35-16k", # model = "deployment_name". messages=messages ) def prompt(query): return f""" You are a university professor. Answer the following question using only the provided context. If you can't find the answer, do not pretend you know it, ask for more information" Answer in the same langauge as the question. If you used your own knowledge apart from the context provided mention that. Question: {query} """ def chunk_files(subdirectory_path, subdirectory): data = [] # Process each PDF file in this subdirectory for filename in os.listdir(subdirectory_path): if filename.endswith('.pdf'): file_path = os.path.join(subdirectory_path, filename) str_five = "" # Open the PDF with fitz.open(file_path) as doc: for page_num in range(len(doc)): page_text = doc[page_num].get_text() page_text = clean(page_text, bullets=True, extra_whitespace=True) slide_id = filename + str(page_num) if page_num % 5 == 0: if page_num != 0: # Avoid appending empty content for the first page data.append({ "content": str_five, "slide_id": slide_id, "page_interval": str(str(page_num - 5) + "->" + str(page_num)), "lecture_id": subdirectory # Save the subdirectory name }) last_page = doc[page_num - 1].get_text() if page_num > 0 else "" last_page = clean(last_page, bullets=True, extra_whitespace=True) str_five = last_page + page_text else: str_five += "\n\n" + page_text # Append the last accumulated text if it's not empty if str_five: data.append({ "content": str_five, "slide_id": subdirectory_path + str(len(doc)), "page_interval": str(str(len(doc) - 10) + "->" + str(len(doc))), "lecture_id": subdirectory # Save the subdirectory name }) return data class AI: def __init__(self): api_key_header = { "X-Azure-Api-Key": azure_openai_key, # Replace with your inference API key } self.client = weaviate.Client( url="http://localhost:8080", # Replace with your endpoint additional_headers=api_key_header ) def create_class(self): t2v = { "model": "ada", "modelVersion": "002", "type": "text", "baseURL": azure_endpoint, "resourceName": resource_name, "deploymentId": "te-ada-002", } self.client.schema.delete_class("Lectures") if not self.client.schema.exists("Lectures"): class_obj = { "class": "Lectures", "vectorizer": "text2vec-openai", "properties": [ { "dataType": ["text"], "name": "content", "moduleConfig": { "text2vec-openai": { "vectorizePropertyName": False } }, }, { "dataType": ["text"], "name": "slide_id", "moduleConfig": { "text2vec-openai": { "vectorizePropertyName": False } }, }, { "dataType": ["text"], "name": "page_interval", "moduleConfig": { "text2vec-openai": { "vectorizePropertyName": False } }, }, { "dataType": ["text"], "name": "lecture_id", "moduleConfig": { "text2vec-openai": { "vectorizePropertyName": False } }, } ], "moduleConfig": { "text2vec-openai": t2v, "generative-openai": { "baseURL": azure_endpoint, "resourceName": resource_name, "deploymentId": "gpt-35-16k", "waitForModel": True, "useGPU": False, "useCache": True } }, } self.client.schema.create_class(class_obj) print("Schema created") directory_path = "../../lectures" print("Importing data into the batch") # Iterate through each subdirectory in the root directory for subdirectory in os.listdir(directory_path): subdirectory_path = os.path.join(directory_path, subdirectory) if os.path.isdir(subdirectory_path): self.batch_import(subdirectory_path, subdirectory) print("Import Finished") def batch_import(self, directory_path, subdirectory): data = chunk_files(directory_path, subdirectory) # Configure a batch process self.client.batch.configure( # `batch_size` takes an `int` value to enable auto-batching # dynamically update the `batch_size` based on import speed dynamic=True, timeout_retries=0 ) with self.client.batch as batch: # Batch import all Questions for i, d in enumerate(data): embeddings_created = False properties = { "content": d["content"], "slide_id": d["slide_id"], "page_interval": d["page_interval"], "lecture_id": d["lecture_id"] } # Initialize the flag embeddings_created = False # create embeddings (exponential backoff to avoid RateLimitError) for j in range(5): # max 5 retries # Only attempt to create embeddings if not already created if not embeddings_created: try: batch.add_data_object( properties, "Lectures" ) embeddings_created = True # Set flag to True on success break # Break the loop as embedding creation was successful except openai.error.RateLimitError: time.sleep(2 ** j) # wait 2^j seconds before retrying print("Retrying import...") else: break # Exit loop if embeddings already created # Raise an error if embeddings were not created after retries if not embeddings_created: raise RuntimeError("Failed to create embeddings.") def generate_response(self, user_message, lecture_id): completion = query_openai(messages=[{ "role": "user", "content": f""" Please give back lecture content that can answer this inquiry: Do not add anything else. "{user_message}".\n """}]) generated_lecture = completion.choices[0].message.content if lecture_id == "CIT5230000": llm = llama_index.llms.AzureOpenAI(model="gpt-35-turbo-16k", deployment_name="gpt-35-16k", api_key=azure_openai_key, azure_endpoint=azure_endpoint, api_version="2023-03-15-preview") embed_model = llama_index.embeddings.AzureOpenAIEmbedding( model="text-embedding-ada-002", deployment_name="te-ada-002", api_key=azure_openai_key, azure_endpoint=azure_endpoint, api_version="2023-03-15-preview" ) service_context = ServiceContext.from_defaults(llm=llm, embed_model=embed_model) vector_store = WeaviateVectorStore( weaviate_client=self.client, index_name="Lectures", text_key="content" ) retriever = VectorStoreIndex.from_vector_store(vector_store, service_context=service_context).as_retriever( similarity_top_k=1 ) nodes = retriever.retrieve(generated_lecture) pprint_source_node(nodes[0]) print(nodes[0].node.metadata) # add hypothetical document embeddings (hyde) if lecture_id != "" and lecture_id is not None: response = ( self.client.query .get("Lectures", ["content", "slide_id", "page_interval", ]) .with_where({ "path": ["lecture_id"], "operator": "Equal", "valueText": lecture_id }) .with_near_text({"concepts": generated_lecture}) #w.with_additional(f'rerank( query: "{user_message}", property: "content"){{score}}') .with_generate(grouped_task=prompt(user_message)) .with_limit(1) .do() ) generated_response = response["data"]["Get"]["Lectures"][0]["_additional"]["generate"]["groupedResult"] else: response = ( self.client.query .get("Lectures", ["content", "slide_id", "page_interval", "lecture_id"]) # alpha = 0 forces using a pure keyword search method (BM25) # alpha = 1 forces using a pure vector search method .with_hybrid(query=user_message, alpha=1, fusion_type=HybridFusion.RELATIVE_SCORE ) # .with_additional(f'rerank( query: "{user_message}", property: "content"){{score}}') .with_generate(grouped_task=prompt(user_message)) .with_limit(3) .do() ) generated_response = response["data"]["Get"]["Lectures"][0]["_additional"]["generate"]["groupedResult"] slides = response["data"]["Get"]["Lectures"][0]["slide_id"] page_interval = response["data"]["Get"]["Lectures"][0]["page_interval"] print(json.dumps(response, indent=2)) return generated_response + f"""\n\nMore relevant information on the slides {slides} "pages":{page_interval} """

[((707, 773), 'langchain.document_loaders.GutenbergLoader', 'GutenbergLoader', (['"""https://www.gutenberg.org/files/2591/2591-0.txt"""'], {}), "('https://www.gutenberg.org/files/2591/2591-0.txt')\n", (722, 773), False, 'from langchain.document_loaders import GutenbergLoader\n'), ((817, 892), 'langchain.text_splitter.CharacterTextSplitter', 'CharacterTextSplitter', ([], {'chunk_size': '(500)', 'chunk_overlap': '(0)', 'length_function': 'len'}), '(chunk_size=500, chunk_overlap=0, length_function=len)\n', (838, 892), False, 'from langchain.text_splitter import CharacterTextSplitter\n'), ((994, 1102), 'weaviate.Client', 'weaviate.Client', ([], {'url': 'WEAVIATE_URL', 'additional_headers': "{'X-OpenAI-Api-Key': os.environ['OPENAI_API_KEY']}"}), "(url=WEAVIATE_URL, additional_headers={'X-OpenAI-Api-Key':\n os.environ['OPENAI_API_KEY']})\n", (1009, 1102), False, 'import weaviate\n'), ((1464, 1504), 'langchain.vectorstores.Weaviate', 'Weaviate', (['client', '"""Paragraph"""', '"""content"""'], {}), "(client, 'Paragraph', 'content')\n", (1472, 1504), False, 'from langchain.vectorstores import Weaviate\n'), ((1827, 1856), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_KEY"""'], {}), "('AZURE_OPENAI_KEY')\n", (1836, 1856), False, 'import os\n'), ((1874, 1908), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_ENDPOINT"""'], {}), "('AZURE_OPENAI_ENDPOINT')\n", (1883, 1908), False, 'import os\n'), ((1925, 1951), 'os.getenv', 'os.getenv', (['"""RESOURCE_NAME"""'], {}), "('RESOURCE_NAME')\n", (1934, 1951), False, 'import os\n'), ((2862, 2891), 'os.listdir', 'os.listdir', (['subdirectory_path'], {}), '(subdirectory_path)\n', (2872, 2891), False, 'import os\n'), ((2016, 2050), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_ENDPOINT"""'], {}), "('AZURE_OPENAI_ENDPOINT')\n", (2025, 2050), False, 'import os\n'), ((2064, 2093), 'os.getenv', 'os.getenv', (['"""AZURE_OPENAI_KEY"""'], {}), "('AZURE_OPENAI_KEY')\n", (2073, 2093), False, 'import os\n'), ((4802, 4881), 'weaviate.Client', 'weaviate.Client', ([], {'url': '"""http://localhost:8080"""', 'additional_headers': 'api_key_header'}), "(url='http://localhost:8080', additional_headers=api_key_header)\n", (4817, 4881), False, 'import weaviate\n'), ((2955, 2996), 'os.path.join', 'os.path.join', (['subdirectory_path', 'filename'], {}), '(subdirectory_path, filename)\n', (2967, 2996), False, 'import os\n'), ((7628, 7654), 'os.listdir', 'os.listdir', (['directory_path'], {}), '(directory_path)\n', (7638, 7654), False, 'import os\n'), ((10504, 10688), 'llama_index.llms.AzureOpenAI', 'llama_index.llms.AzureOpenAI', ([], {'model': '"""gpt-35-turbo-16k"""', 'deployment_name': '"""gpt-35-16k"""', 'api_key': 'azure_openai_key', 'azure_endpoint': 'azure_endpoint', 'api_version': '"""2023-03-15-preview"""'}), "(model='gpt-35-turbo-16k', deployment_name=\n 'gpt-35-16k', api_key=azure_openai_key, azure_endpoint=azure_endpoint,\n api_version='2023-03-15-preview')\n", (10532, 10688), False, 'import llama_index\n'), ((10800, 11005), 'llama_index.embeddings.AzureOpenAIEmbedding', 'llama_index.embeddings.AzureOpenAIEmbedding', ([], {'model': '"""text-embedding-ada-002"""', 'deployment_name': '"""te-ada-002"""', 'api_key': 'azure_openai_key', 'azure_endpoint': 'azure_endpoint', 'api_version': '"""2023-03-15-preview"""'}), "(model='text-embedding-ada-002',\n deployment_name='te-ada-002', api_key=azure_openai_key, azure_endpoint=\n azure_endpoint, api_version='2023-03-15-preview')\n", (10843, 11005), False, 'import llama_index\n'), ((11121, 11183), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm': 'llm', 'embed_model': 'embed_model'}), '(llm=llm, embed_model=embed_model)\n', (11149, 11183), False, 'from llama_index import VectorStoreIndex, ServiceContext, set_global_service_context\n'), ((11213, 11308), 'llama_index.vector_stores.WeaviateVectorStore', 'WeaviateVectorStore', ([], {'weaviate_client': 'self.client', 'index_name': '"""Lectures"""', 'text_key': '"""content"""'}), "(weaviate_client=self.client, index_name='Lectures',\n text_key='content')\n", (11232, 11308), False, 'from llama_index.vector_stores import WeaviateVectorStore\n'), ((11574, 11602), 'llama_index.response.pprint_utils.pprint_source_node', 'pprint_source_node', (['nodes[0]'], {}), '(nodes[0])\n', (11592, 11602), False, 'from llama_index.response.pprint_utils import pprint_source_node\n'), ((13511, 13541), 'json.dumps', 'json.dumps', (['response'], {'indent': '(2)'}), '(response, indent=2)\n', (13521, 13541), False, 'import json\n'), ((3067, 3087), 'fitz.open', 'fitz.open', (['file_path'], {}), '(file_path)\n', (3076, 3087), False, 'import fitz\n'), ((7692, 7734), 'os.path.join', 'os.path.join', (['directory_path', 'subdirectory'], {}), '(directory_path, subdirectory)\n', (7704, 7734), False, 'import os\n'), ((7754, 7786), 'os.path.isdir', 'os.path.isdir', (['subdirectory_path'], {}), '(subdirectory_path)\n', (7767, 7786), False, 'import os\n'), ((3234, 3287), 'unstructured.cleaners.core.clean', 'clean', (['page_text'], {'bullets': '(True)', 'extra_whitespace': '(True)'}), '(page_text, bullets=True, extra_whitespace=True)\n', (3239, 3287), False, 'from unstructured.cleaners.core import clean\n'), ((11359, 11445), 'llama_index.VectorStoreIndex.from_vector_store', 'VectorStoreIndex.from_vector_store', (['vector_store'], {'service_context': 'service_context'}), '(vector_store, service_context=\n service_context)\n', (11393, 11445), False, 'from llama_index import VectorStoreIndex, ServiceContext, set_global_service_context\n'), ((3970, 4023), 'unstructured.cleaners.core.clean', 'clean', (['last_page'], {'bullets': '(True)', 'extra_whitespace': '(True)'}), '(last_page, bullets=True, extra_whitespace=True)\n', (3975, 4023), False, 'from unstructured.cleaners.core import clean\n'), ((9510, 9528), 'time.sleep', 'time.sleep', (['(2 ** j)'], {}), '(2 ** j)\n', (9520, 9528), False, 'import time\n')]

"""Elasticsearch vector store.""" import asyncio import uuid from logging import getLogger from typing import Any, Callable, Dict, List, Literal, Optional, Union, cast import nest_asyncio import numpy as np from llama_index.schema import BaseNode, MetadataMode, TextNode from llama_index.vector_stores.types import ( MetadataFilters, VectorStore, VectorStoreQuery, VectorStoreQueryMode, VectorStoreQueryResult, ) from llama_index.vector_stores.utils import metadata_dict_to_node, node_to_metadata_dict logger = getLogger(__name__) DISTANCE_STRATEGIES = Literal[ "COSINE", "DOT_PRODUCT", "EUCLIDEAN_DISTANCE", ] def _get_elasticsearch_client( *, es_url: Optional[str] = None, cloud_id: Optional[str] = None, api_key: Optional[str] = None, username: Optional[str] = None, password: Optional[str] = None, ) -> Any: """Get AsyncElasticsearch client. Args: es_url: Elasticsearch URL. cloud_id: Elasticsearch cloud ID. api_key: Elasticsearch API key. username: Elasticsearch username. password: Elasticsearch password. Returns: AsyncElasticsearch client. Raises: ConnectionError: If Elasticsearch client cannot connect to Elasticsearch. """ try: import elasticsearch except ImportError: raise ImportError( "Could not import elasticsearch python package. " "Please install it with `pip install elasticsearch`." ) if es_url and cloud_id: raise ValueError( "Both es_url and cloud_id are defined. Please provide only one." ) if es_url and cloud_id: raise ValueError( "Both es_url and cloud_id are defined. Please provide only one." ) connection_params: Dict[str, Any] = {} if es_url: connection_params["hosts"] = [es_url] elif cloud_id: connection_params["cloud_id"] = cloud_id else: raise ValueError("Please provide either elasticsearch_url or cloud_id.") if api_key: connection_params["api_key"] = api_key elif username and password: connection_params["basic_auth"] = (username, password) sync_es_client = elasticsearch.Elasticsearch( **connection_params, headers={"user-agent": ElasticsearchStore.get_user_agent()} ) async_es_client = elasticsearch.AsyncElasticsearch(**connection_params) try: sync_es_client.info() # so don't have to 'await' to just get info except Exception as e: logger.error(f"Error connecting to Elasticsearch: {e}") raise return async_es_client def _to_elasticsearch_filter(standard_filters: MetadataFilters) -> Dict[str, Any]: """Convert standard filters to Elasticsearch filter. Args: standard_filters: Standard Llama-index filters. Returns: Elasticsearch filter. """ if len(standard_filters.filters) == 1: filter = standard_filters.filters[0] return { "term": { f"metadata.{filter.key}.keyword": { "value": filter.value, } } } else: operands = [] for filter in standard_filters.filters: operands.append( { "term": { f"metadata.{filter.key}.keyword": { "value": filter.value, } } } ) return {"bool": {"must": operands}} def _to_llama_similarities(scores: List[float]) -> List[float]: if scores is None or len(scores) == 0: return [] scores_to_norm: np.ndarray = np.array(scores) return np.exp(scores_to_norm - np.max(scores_to_norm)).tolist() class ElasticsearchStore(VectorStore): """Elasticsearch vector store. Args: index_name: Name of the Elasticsearch index. es_client: Optional. Pre-existing AsyncElasticsearch client. es_url: Optional. Elasticsearch URL. es_cloud_id: Optional. Elasticsearch cloud ID. es_api_key: Optional. Elasticsearch API key. es_user: Optional. Elasticsearch username. es_password: Optional. Elasticsearch password. text_field: Optional. Name of the Elasticsearch field that stores the text. vector_field: Optional. Name of the Elasticsearch field that stores the embedding. batch_size: Optional. Batch size for bulk indexing. Defaults to 200. distance_strategy: Optional. Distance strategy to use for similarity search. Defaults to "COSINE". Raises: ConnectionError: If AsyncElasticsearch client cannot connect to Elasticsearch. ValueError: If neither es_client nor es_url nor es_cloud_id is provided. """ stores_text: bool = True def __init__( self, index_name: str, es_client: Optional[Any] = None, es_url: Optional[str] = None, es_cloud_id: Optional[str] = None, es_api_key: Optional[str] = None, es_user: Optional[str] = None, es_password: Optional[str] = None, text_field: str = "content", vector_field: str = "embedding", batch_size: int = 200, distance_strategy: Optional[DISTANCE_STRATEGIES] = "COSINE", ) -> None: nest_asyncio.apply() self.index_name = index_name self.text_field = text_field self.vector_field = vector_field self.batch_size = batch_size self.distance_strategy = distance_strategy if es_client is not None: self._client = es_client.options( headers={"user-agent": self.get_user_agent()} ) elif es_url is not None or es_cloud_id is not None: self._client = _get_elasticsearch_client( es_url=es_url, username=es_user, password=es_password, cloud_id=es_cloud_id, api_key=es_api_key, ) else: raise ValueError( """Either provide a pre-existing AsyncElasticsearch or valid \ credentials for creating a new connection.""" ) @property def client(self) -> Any: """Get async elasticsearch client.""" return self._client @staticmethod def get_user_agent() -> str: """Get user agent for elasticsearch client.""" import llama_index return f"llama_index-py-vs/{llama_index.__version__}" async def _create_index_if_not_exists( self, index_name: str, dims_length: Optional[int] = None ) -> None: """Create the AsyncElasticsearch index if it doesn't already exist. Args: index_name: Name of the AsyncElasticsearch index to create. dims_length: Length of the embedding vectors. """ if await self.client.indices.exists(index=index_name): logger.debug(f"Index {index_name} already exists. Skipping creation.") else: if dims_length is None: raise ValueError( "Cannot create index without specifying dims_length " "when the index doesn't already exist. We infer " "dims_length from the first embedding. Check that " "you have provided an embedding function." ) if self.distance_strategy == "COSINE": similarityAlgo = "cosine" elif self.distance_strategy == "EUCLIDEAN_DISTANCE": similarityAlgo = "l2_norm" elif self.distance_strategy == "DOT_PRODUCT": similarityAlgo = "dot_product" else: raise ValueError(f"Similarity {self.distance_strategy} not supported.") index_settings = { "mappings": { "properties": { self.vector_field: { "type": "dense_vector", "dims": dims_length, "index": True, "similarity": similarityAlgo, }, self.text_field: {"type": "text"}, "metadata": { "properties": { "document_id": {"type": "keyword"}, "doc_id": {"type": "keyword"}, "ref_doc_id": {"type": "keyword"}, } }, } } } logger.debug( f"Creating index {index_name} with mappings {index_settings['mappings']}" ) await self.client.indices.create(index=index_name, **index_settings) def add( self, nodes: List[BaseNode], *, create_index_if_not_exists: bool = True, **add_kwargs: Any, ) -> List[str]: """Add nodes to Elasticsearch index. Args: nodes: List of nodes with embeddings. create_index_if_not_exists: Optional. Whether to create the Elasticsearch index if it doesn't already exist. Defaults to True. Returns: List of node IDs that were added to the index. Raises: ImportError: If elasticsearch['async'] python package is not installed. BulkIndexError: If AsyncElasticsearch async_bulk indexing fails. """ return asyncio.get_event_loop().run_until_complete( self.async_add(nodes, create_index_if_not_exists=create_index_if_not_exists) ) async def async_add( self, nodes: List[BaseNode], *, create_index_if_not_exists: bool = True, **add_kwargs: Any, ) -> List[str]: """Asynchronous method to add nodes to Elasticsearch index. Args: nodes: List of nodes with embeddings. create_index_if_not_exists: Optional. Whether to create the AsyncElasticsearch index if it doesn't already exist. Defaults to True. Returns: List of node IDs that were added to the index. Raises: ImportError: If elasticsearch python package is not installed. BulkIndexError: If AsyncElasticsearch async_bulk indexing fails. """ try: from elasticsearch.helpers import BulkIndexError, async_bulk except ImportError: raise ImportError( "Could not import elasticsearch[async] python package. " "Please install it with `pip install 'elasticsearch[async]'`." ) if len(nodes) == 0: return [] if create_index_if_not_exists: dims_length = len(nodes[0].get_embedding()) await self._create_index_if_not_exists( index_name=self.index_name, dims_length=dims_length ) embeddings: List[List[float]] = [] texts: List[str] = [] metadatas: List[dict] = [] ids: List[str] = [] for node in nodes: ids.append(node.node_id) embeddings.append(node.get_embedding()) texts.append(node.get_content(metadata_mode=MetadataMode.NONE)) metadatas.append(node_to_metadata_dict(node, remove_text=True)) requests = [] return_ids = [] for i, text in enumerate(texts): metadata = metadatas[i] if metadatas else {} _id = ids[i] if ids else str(uuid.uuid4()) request = { "_op_type": "index", "_index": self.index_name, self.vector_field: embeddings[i], self.text_field: text, "metadata": metadata, "_id": _id, } requests.append(request) return_ids.append(_id) await async_bulk( self.client, requests, chunk_size=self.batch_size, refresh=True ) try: success, failed = await async_bulk( self.client, requests, stats_only=True, refresh=True ) logger.debug(f"Added {success} and failed to add {failed} texts to index") logger.debug(f"added texts {ids} to index") return return_ids except BulkIndexError as e: logger.error(f"Error adding texts: {e}") firstError = e.errors[0].get("index", {}).get("error", {}) logger.error(f"First error reason: {firstError.get('reason')}") raise def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None: """Delete node from Elasticsearch index. Args: ref_doc_id: ID of the node to delete. delete_kwargs: Optional. Additional arguments to pass to Elasticsearch delete_by_query. Raises: Exception: If Elasticsearch delete_by_query fails. """ return asyncio.get_event_loop().run_until_complete( self.adelete(ref_doc_id, **delete_kwargs) ) async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None: """Async delete node from Elasticsearch index. Args: ref_doc_id: ID of the node to delete. delete_kwargs: Optional. Additional arguments to pass to AsyncElasticsearch delete_by_query. Raises: Exception: If AsyncElasticsearch delete_by_query fails. """ try: async with self.client as client: res = await client.delete_by_query( index=self.index_name, query={"term": {"metadata.ref_doc_id": ref_doc_id}}, refresh=True, **delete_kwargs, ) if res["deleted"] == 0: logger.warning(f"Could not find text {ref_doc_id} to delete") else: logger.debug(f"Deleted text {ref_doc_id} from index") except Exception: logger.error(f"Error deleting text: {ref_doc_id}") raise def query( self, query: VectorStoreQuery, custom_query: Optional[ Callable[[Dict, Union[VectorStoreQuery, None]], Dict] ] = None, es_filter: Optional[List[Dict]] = None, **kwargs: Any, ) -> VectorStoreQueryResult: """Query index for top k most similar nodes. Args: query_embedding (List[float]): query embedding custom_query: Optional. custom query function that takes in the es query body and returns a modified query body. This can be used to add additional query parameters to the Elasticsearch query. es_filter: Optional. Elasticsearch filter to apply to the query. If filter is provided in the query, this filter will be ignored. Returns: VectorStoreQueryResult: Result of the query. Raises: Exception: If Elasticsearch query fails. """ return asyncio.get_event_loop().run_until_complete( self.aquery(query, custom_query, es_filter, **kwargs) ) async def aquery( self, query: VectorStoreQuery, custom_query: Optional[ Callable[[Dict, Union[VectorStoreQuery, None]], Dict] ] = None, es_filter: Optional[List[Dict]] = None, **kwargs: Any, ) -> VectorStoreQueryResult: """Asynchronous query index for top k most similar nodes. Args: query_embedding (VectorStoreQuery): query embedding custom_query: Optional. custom query function that takes in the es query body and returns a modified query body. This can be used to add additional query parameters to the AsyncElasticsearch query. es_filter: Optional. AsyncElasticsearch filter to apply to the query. If filter is provided in the query, this filter will be ignored. Returns: VectorStoreQueryResult: Result of the query. Raises: Exception: If AsyncElasticsearch query fails. """ query_embedding = cast(List[float], query.query_embedding) es_query = {} if query.filters is not None and len(query.filters.filters) > 0: filter = [_to_elasticsearch_filter(query.filters)] else: filter = es_filter or [] if query.mode in ( VectorStoreQueryMode.DEFAULT, VectorStoreQueryMode.HYBRID, ): es_query["knn"] = { "filter": filter, "field": self.vector_field, "query_vector": query_embedding, "k": query.similarity_top_k, "num_candidates": query.similarity_top_k * 10, } if query.mode in ( VectorStoreQueryMode.TEXT_SEARCH, VectorStoreQueryMode.HYBRID, ): es_query["query"] = { "bool": { "must": {"match": {self.text_field: {"query": query.query_str}}}, "filter": filter, } } if query.mode == VectorStoreQueryMode.HYBRID: es_query["rank"] = {"rrf": {}} if custom_query is not None: es_query = custom_query(es_query, query) logger.debug(f"Calling custom_query, Query body now: {es_query}") async with self.client as client: response = await client.search( index=self.index_name, **es_query, size=query.similarity_top_k, _source={"excludes": [self.vector_field]}, ) top_k_nodes = [] top_k_ids = [] top_k_scores = [] hits = response["hits"]["hits"] for hit in hits: source = hit["_source"] metadata = source.get("metadata", None) text = source.get(self.text_field, None) node_id = hit["_id"] try: node = metadata_dict_to_node(metadata) node.text = text except Exception: # Legacy support for old metadata format logger.warning( f"Could not parse metadata from hit {hit['_source']['metadata']}" ) node_info = source.get("node_info") relationships = source.get("relationships") start_char_idx = None end_char_idx = None if isinstance(node_info, dict): start_char_idx = node_info.get("start", None) end_char_idx = node_info.get("end", None) node = TextNode( text=text, metadata=metadata, id_=node_id, start_char_idx=start_char_idx, end_char_idx=end_char_idx, relationships=relationships, ) top_k_nodes.append(node) top_k_ids.append(node_id) top_k_scores.append(hit.get("_rank", hit["_score"])) if query.mode == VectorStoreQueryMode.HYBRID: total_rank = sum(top_k_scores) top_k_scores = [total_rank - rank / total_rank for rank in top_k_scores] return VectorStoreQueryResult( nodes=top_k_nodes, ids=top_k_ids, similarities=_to_llama_similarities(top_k_scores), )

[((534, 553), 'logging.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (543, 553), False, 'from logging import getLogger\n'), ((2379, 2432), 'elasticsearch.AsyncElasticsearch', 'elasticsearch.AsyncElasticsearch', ([], {}), '(**connection_params)\n', (2411, 2432), False, 'import elasticsearch\n'), ((3728, 3744), 'numpy.array', 'np.array', (['scores'], {}), '(scores)\n', (3736, 3744), True, 'import numpy as np\n'), ((5409, 5429), 'nest_asyncio.apply', 'nest_asyncio.apply', ([], {}), '()\n', (5427, 5429), False, 'import nest_asyncio\n'), ((16807, 16847), 'typing.cast', 'cast', (['List[float]', 'query.query_embedding'], {}), '(List[float], query.query_embedding)\n', (16811, 16847), False, 'from typing import Any, Callable, Dict, List, Literal, Optional, Union, cast\n'), ((12293, 12368), 'elasticsearch.helpers.async_bulk', 'async_bulk', (['self.client', 'requests'], {'chunk_size': 'self.batch_size', 'refresh': '(True)'}), '(self.client, requests, chunk_size=self.batch_size, refresh=True)\n', (12303, 12368), False, 'from elasticsearch.helpers import BulkIndexError, async_bulk\n'), ((9758, 9782), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (9780, 9782), False, 'import asyncio\n'), ((11685, 11730), 'llama_index.vector_stores.utils.node_to_metadata_dict', 'node_to_metadata_dict', (['node'], {'remove_text': '(True)'}), '(node, remove_text=True)\n', (11706, 11730), False, 'from llama_index.vector_stores.utils import metadata_dict_to_node, node_to_metadata_dict\n'), ((12440, 12504), 'elasticsearch.helpers.async_bulk', 'async_bulk', (['self.client', 'requests'], {'stats_only': '(True)', 'refresh': '(True)'}), '(self.client, requests, stats_only=True, refresh=True)\n', (12450, 12504), False, 'from elasticsearch.helpers import BulkIndexError, async_bulk\n'), ((13378, 13402), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (13400, 13402), False, 'import asyncio\n'), ((15585, 15609), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (15607, 15609), False, 'import asyncio\n'), ((18698, 18729), 'llama_index.vector_stores.utils.metadata_dict_to_node', 'metadata_dict_to_node', (['metadata'], {}), '(metadata)\n', (18719, 18729), False, 'from llama_index.vector_stores.utils import metadata_dict_to_node, node_to_metadata_dict\n'), ((3780, 3802), 'numpy.max', 'np.max', (['scores_to_norm'], {}), '(scores_to_norm)\n', (3786, 3802), True, 'import numpy as np\n'), ((11919, 11931), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (11929, 11931), False, 'import uuid\n'), ((19372, 19515), 'llama_index.schema.TextNode', 'TextNode', ([], {'text': 'text', 'metadata': 'metadata', 'id_': 'node_id', 'start_char_idx': 'start_char_idx', 'end_char_idx': 'end_char_idx', 'relationships': 'relationships'}), '(text=text, metadata=metadata, id_=node_id, start_char_idx=\n start_char_idx, end_char_idx=end_char_idx, relationships=relationships)\n', (19380, 19515), False, 'from llama_index.schema import BaseNode, MetadataMode, TextNode\n')]

import json import logging import os import re import time import xml.etree.ElementTree as ET from collections import defaultdict, deque from functools import partial import backoff import llama_index import markdown import openai import tiktoken from colorama import Fore from langchain import OpenAI from langchain.chat_models import ChatOpenAI from llama_index import ( Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage, ) from llama_index.indices.composability import ComposableGraph from llama_index.query_engine import RetrieverQueryEngine from llama_index.retrievers import VectorIndexRetriever from api.mygene_api import mygene_api from api.myvariant_api import myvariant_api from api.pubmed_api import pubmed_api from config import OPENAI_API_KEY logging.getLogger("llama_index").setLevel(logging.WARNING) # file_handler = logging.FileHandler('utils.log') # Configure the logging settings # logging.basicConfig(level=logging.INFO, handlers=[file_handler]) MAX_TOKENS = 4097 api_info_mapping = { "mygene": mygene_api, "PubMed": pubmed_api, "myvariant": myvariant_api, } api_key = OPENAI_API_KEY or os.environ["OPENAI_API_KEY"] openai.api_key = api_key def get_input(prompt, type_=None, min_=None, max_=None, range_=None): if min_ is not None and max_ is not None and max_ < min_: raise ValueError("min_ must be less than or equal to max_.") while True: ui = input(prompt) if type_ is not None: try: ui = type_(ui) except ValueError: print(f"Input type must be {type_.__name__}!") continue if max_ is not None and ui > max_: print(f"Input must be less than or equal to {max_}.") elif min_ is not None and ui < min_: print(f"Input must be greater than or equal to {min_}.") elif range_ is not None and ui not in range_: if isinstance(range_, range): template = "Input must be between {} and {}." print(template.format(range_.start, range_.stop)) else: template = "Input must be {}." print(template.format(", ".join(map(str, range_)))) else: return ui def select_task(task_list): # Task list is actually a Queue task_list = list(task_list) print("\n\n") choice = get_input( Fore.LIGHTGREEN_EX + "\033[1mWhich task would you like to execute? Type 0 to create your own task! \033[0m", type_=int, min_=0, max_=len(task_list), ) if choice == 0: task = input(Fore.LIGHTGREEN_EX + "\033[1mWrite your task! \033[0m") else: task = task_list.pop(choice - 1) return task, deque(task_list) def num_tokens_from_string(string: str, encoding_name: str = "gpt2") -> int: """Returns the number of tokens in a text string.""" encoding = tiktoken.get_encoding(encoding_name) num_tokens = len(encoding.encode(string)) return num_tokens def get_key_results(index, objective, top_k=20, additional_queries=[]): """Run final queries over retrieved documents and store in doc_store.""" if not index.docstore.docs: print( Fore.RED + "\033[1m\n! WARNING: NO TASKS RETURNED RESULTS. PLEASE TWEAK YOUR OBJECTIVE AND CHECK SPELLING. !\n\033[0m" ) return [] print(Fore.CYAN + "\033[1m\n*****COMPILING KEY RESULTS*****\n\033[0m") key_results = [] queries = [ "Give a brief high level summary of all the data.", "Briefly list all the main points that the data covers.", "Generate several creative hypotheses given the data.", "What are some high level research directions to explore further given the data?", f"Do your best to answer the objective: {objective} given the information.", ] for query in queries: print(Fore.CYAN + f"\nCOMPILING RESULT {query}\n") res = None try: res, citation_data = query_knowledge_base( index=index, query=query, list_index=False, top_k=top_k ) except Exception as e: print(f"Exception getting key result {query}, error {e}") if res: query = f"## {query}\n\n" res_html = markdown.markdown(res) res_citation = markdown.markdown(citation_data) key_results.append( (query, f"{res_html}\n\n### Citations\n\n{res_citation}\n\n") ) print(Fore.CYAN + f"\nRESULTS COMPILED. SAVED TO DIRECTORY `out`\n") return key_results def get_max_completion_len(prompt): tokens = num_tokens_from_string(prompt) return MAX_TOKENS - tokens def execute_python(code: str): # ret is defined in the code string loc = {} try: exec(code, globals(), loc) except Exception as e: print(f"Exception executing code {code}, {e}") return return loc["ret"] def process_myvariant_result(results): processed_result = [] if not isinstance(results, list): results = [results] for result in results: variant_name = result.get("_id") gene_affected = result.get("cadd", {}).get("gene", {}).get("genename") consequence = result.get("cadd", {}).get("consequence") cadd_score = result.get("cadd", {}).get("phred") rsid = result.get("dbsnp", {}).get("rsid") variant_data = "" citation_data = "" if variant_name: variant_data += f"Variant Name: {variant_name}\n" if gene_affected: variant_data += f"Gene Affected: {gene_affected}\n" if consequence: variant_data += f"Consequence: {consequence}\n" if cadd_score is not None: variant_data += f"CADD Score: {cadd_score}\n" if rsid: variant_data += f"rsID: {rsid}\n" processed_result.append((variant_data, {"citation_data": citation_data})) return processed_result def process_mygene_result(results): processed_result = [] if not isinstance(results, list): results = [results] # Each result will be split into 2 documents: summary and pathway for json_data in results: name = json_data.get("name") refseq_genomic = json_data.get("refseq", {}).get("genomic", []) refseq_rna = json_data.get("refseq", {}).get("rna", []) symbol = json_data.get("symbol") taxid = json_data.get("taxid") type_of_gene = json_data.get("type_of_gene") pos = json_data.get("genomic_pos_hg19") summary = json_data.get("summary") generif = json_data.get("generif") output_summary = "" citation_data = "" # Summary if name: output_summary += f"Gene Name: {name}\n" if refseq_genomic: output_summary += f"RefSeq genomic: {', '.join(refseq_genomic)}\n" if refseq_rna: output_summary += f"RefSeq rna: {', '.join(refseq_rna)}\n" if symbol: output_summary += f"Symbol: {symbol}\n" if taxid: output_summary += f"Tax ID: {taxid}\n" if type_of_gene and type_of_gene != "unknown": output_summary += f"Type of gene: {type_of_gene}\n" if pos: output_summary += f"Position: {pos}\n" if summary: output_summary += f"Summary of {name}: {summary}\n" else: # If not summary, use generifs. if generif: # Take 20 rifs max. Some genes have hundreds of rifs and the results size explodes. for rif in generif[:20]: pubmed = rif.get("pubmed") text = rif.get("text") if text: output_summary += text if pubmed: citation_data += f" Pubmed ID: {pubmed}" output_summary = output_summary.strip() # logging.info(f"Mygene Summary result {name}, length is {str(len(output_summary))}") if output_summary: processed_result.append((output_summary, {"citation_data": citation_data})) # Pathway pathway = json_data.get("pathway") if pathway: kegg = pathway.get("kegg", []) pid = pathway.get("pid", []) reactome = pathway.get("reactome", []) wikipathways = pathway.get("wikipathways", []) netpath = pathway.get("netpath", []) biocarta = pathway.get("biocarta", []) pathway_elements = { "kegg": kegg, "pid": pid, "reactome": reactome, "wikipathways": wikipathways, "netpath": netpath, "biocarta": biocarta, } # mygene returns dicts instead of lists if singleton # Wrap with list if not list for k, v in pathway_elements.items(): if type(v) is not list: pathway_elements[k] = [v] output_pathway = "" citation_data = "" if name: output_pathway += f"Gene Name: {name}\n" if symbol: output_pathway += f"Symbol: {symbol}\n" if taxid: output_pathway += f"Tax ID: {taxid}\n" if type_of_gene and type_of_gene != "unknown": output_pathway += f"Type of gene: {type_of_gene}\n" if refseq_genomic: output_pathway += f"RefSeq genomic: {', '.join(refseq_genomic)}\n" if refseq_rna: output_pathway += f"RefSeq rna: {', '.join(refseq_rna)}\n" if pos: output_pathway += f"Position: {pos}\n" output_pathway += f"PATHWAYS\n\n" for k, v in pathway_elements.items(): output_pathway += f"\n{k}:\n" for item in v: output_pathway += f" ID: {item.get('id', '')}" output_pathway += f" Name: {item.get('name', '')}" # logging.info(f"Mygene Pathway result {name}, length is {len(output_pathway)}") output_pathway = output_pathway.strip() if output_pathway: processed_result.append( (output_pathway, {"citation_data": citation_data}) ) return processed_result def process_pubmed_result(result): try: root = ET.fromstring(result) except Exception as e: print(f"Cannot parse pubmed result, expected xml. {e}") print("Adding whole document. Note this will lead to suboptimal results.") return result if isinstance(result, list) else [result] processed_result = [] for article in root: res_ = "" citation_data = "" for title in article.iter("Title"): res_ += f"{title.text}\n" citation_data += f"{title.text}\n" for abstract in article.iter("AbstractText"): res_ += f"{abstract.text}\n" for author in article.iter("Author"): try: citation_data += f"{author.find('LastName').text}" citation_data += f", {author.find('ForeName').text}\n" except: pass for journal in article.iter("Journal"): res_ += f"{journal.find('Title').text}\n" citation_data += f"{journal.find('Title').text}\n" for volume in article.iter("Volume"): citation_data += f"{volume.text}\n" for issue in article.iter("Issue"): citation_data += f"{issue.text}\n" for pubdate in article.iter("PubDate"): try: year = pubdate.find("Year").text citation_data += f"{year}" month = pubdate.find("Month").text citation_data += f"-{month}" day = pubdate.find("Day").text citation_data += f"-{day}\n" except: pass for doi in article.iter("ELocationID"): if doi.get("EIdType") == "doi": res_ += f"{doi.text}\n" if res_: processed_result.append((res_, {"citation_data": citation_data})) return processed_result def get_code_params(code: str, preparam_text: str, postparam_text: str): l = len(preparam_text) preparam_index = code.find(preparam_text) postparam_index = code.find(postparam_text) if preparam_index == -1 or postparam_index == -1: return params = code[preparam_index + l : postparam_index].strip() if params == "": return return params def validate_llm_response(goal, response): validation_prompt = f"I gave an LLM this goal: '{goal}' and it gave this response: '{response}'. Is this reasonable, or did something go wrong? [yes|no]" validation_response = ( openai.Completion.create( engine="text-davinci-003", prompt=validation_prompt, temperature=0.0 ) .choices[0] .text.strip() ) if validation_response.lower() == "yes": return True else: return False def generate_tool_prompt(task): if "MYVARIANT" in task: api_name = "myvariant" elif "MYGENE" in task: api_name = "mygene" elif "PUBMED" in task: api_name = "PubMed" else: print(f"Error. Tool not found in task: {task}") return None api_info = api_info_mapping[api_name] prompt = f"""You have access to query the {api_name} API. If a task starts with '{api_name.upper()}:' then you should create the code to query the {api_name} API based off the documentation and return the code to complete your task. If you use the {api_name} API, do not answer with words, simply write the parameters used to call the function then cease output. Be sure it is valid python that will execute in a python interpreter. --- Here is the {api_name} documentation {api_info} --- You should change the parameters to fit your specific task. """.strip() return prompt def get_ada_embedding(text): ada_embedding_max_size = 8191 text = text.replace("\n", " ") if num_tokens_from_string(text) > ada_embedding_max_size: # There must be a better way to do this. text = text[:ada_embedding_max_size] return openai.Embedding.create(input=[text], model="text-embedding-ada-002")[ "data" ][0]["embedding"] def insert_doc_llama_index(index, doc_id, data, metadata={}, embedding=None): if not embedding: embedding = get_ada_embedding(data) doc = Document(text=data, embedding=embedding, doc_id=doc_id, metadata=metadata) doc.excluded_llm_metadata_keys = ["citation_data"] doc.excluded_embed_metadata_keys = ["citation_data"] index.insert(doc) def handle_python_result(result, cache, task, doc_store, doc_store_task_key): results_returned = True params = result doc_store["tasks"][doc_store_task_key]["result_code"] = result tool = task.split(":")[0] if tool == "MYGENE": result = ( "from api.mygene_wrapper import mygene_wrapper\n" + result + "\nret = mygene_wrapper(query_term, size, from_)" ) elif tool == "MYVARIANT": result = ( "from api.myvariant_wrapper import myvariant_wrapper\n" + result + "\nret = myvariant_wrapper(query_term)" ) elif tool == "PUBMED": result = ( "from api.pubmed_wrapper import pubmed_wrapper\n" + result + "\nret = pubmed_wrapper(query_term, retmax, retstart)" ) executed_result = execute_python(result) if type(executed_result) is list: executed_result = list(filter(lambda x: x, executed_result)) if (executed_result is not None) and ( not executed_result ): # Execution complete succesfully, but executed result was empty list results_returned = False result = "NOTE: Code returned no results\n\n" + result print(Fore.BLUE + f"\nTask '{task}' completed but returned no results") if "MYVARIANT" in task: if results_returned: cache["MYVARIANT"].append(f"---\n{params}---\n") else: cache["MYVARIANT"].append( f"---\nNote: This call returned no results\n{params}---\n" ) processed_result = process_myvariant_result(executed_result) if "MYGENE" in task: if results_returned: cache["MYGENE"].append(f"---\n{params}---\n") else: cache["MYGENE"].append( f"---\nNote: This call returned no results\n{params}---\n" ) processed_result = process_mygene_result(executed_result) if "PUBMED" in task: if results_returned: cache["PUBMED"].append(f"---\n{params}---\n") else: cache["PUBMED"].append( f"---\nNote: This call returned no results\n{params}---\n" ) processed_result = process_pubmed_result(executed_result) if executed_result is None: result = "NOTE: Code did not run succesfully\n\n" + result print( Fore.BLUE + f"Task '{task}' failed. Code {result} did not run succesfully." ) if "MYGENE" in task: cache["MYGENE"].append( f"---\nNote: This call did not run succesfully\n{params}---\n" ) if "PUBMED" in task: cache["PUBMED"].append( f"---\nNote: This call did not run succesfully\n{params}---\n" ) if "MYVARIANT" in task: cache["MYVARIANT"].append( f"---\nNote: This call did not run succesfully\n{params}---\n" ) return return processed_result def handle_results( result, index, doc_store, doc_store_key, task_id_counter, RESULT_CUTOFF ): for i, r in enumerate(result): res, metadata = r[0], r[1] res = str(res)[ :RESULT_CUTOFF ] # Occasionally an enormous result will slow the program to a halt. Not ideal to lose results but putting in place for now. vectorized_data = get_ada_embedding(res) task_id = f"doc_id_{task_id_counter}_{i}" insert_doc_llama_index( index=index, doc_id=task_id, data=res, metadata=metadata, embedding=vectorized_data, ) doc_store["tasks"][doc_store_key]["results"].append( { "task_id_counter": task_id_counter, "vectorized_data": vectorized_data, "output": res, "metadata": metadata, } ) def query_knowledge_base( index, query="Give a detailed but terse overview of all the information. Start with a high level summary and then go into details. Do not include any further instruction. Do not include filler words.", response_mode="tree_summarize", top_k=50, list_index=False, ): if not index.docstore.docs: print(Fore.RED + "NO INFORMATION IN LLAMA INDEX") return # configure retriever retriever = VectorIndexRetriever( index=index, similarity_top_k=top_k, ) # configure response synthesizer response_synthesizer = ResponseSynthesizer.from_args( response_mode="tree_summarize", ) # assemble query engine query_engine = RetrieverQueryEngine( retriever=retriever, response_synthesizer=response_synthesizer, ) if list_index: query_response = index.query(query, response_mode="default") else: # From llama index docs: Empirically, setting response_mode="tree_summarize" also leads to better summarization results. query_response = query_engine.query(query) extra_info = "" if query_response.metadata: try: extra_info = [ x.get("citation_data") for x in query_response.metadata.values() ] if not any(extra_info): extra_info = [] except Exception as e: print("Issue getting extra info from llama index") return query_response.response, "\n\n".join(extra_info) def create_index( api_key, summaries=[], temperature=0.0, model_name="gpt-3.5-turbo-16k", max_tokens=6000, ): llm_predictor = LLMPredictor( llm=ChatOpenAI( temperature=temperature, openai_api_key=api_key, model_name=model_name, max_tokens=max_tokens, ) ) documents = [] for i, summary in enumerate(summaries): doc = Document(text=summary, doc_id=str(i)) doc.excluded_llm_metadata_keys = ["citation_data"] doc.excluded_embed_metadata_keys = ["citation_data"] documents.append(doc) service_context = ServiceContext.from_defaults( llm_predictor=llm_predictor, chunk_size=4000 ) return GPTVectorStoreIndex(documents, service_context=service_context) def create_graph_index( api_key, indicies=[], summaries=[], temperature=0.0, model_name="text-davinci-003", max_tokens=2000, ): llm_predictor = LLMPredictor( llm=OpenAI( temperature=temperature, openai_api_key=api_key, model_name=model_name, max_tokens=max_tokens, ) ) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor) graph = ComposableGraph.from_indices( GPTListIndex, indicies, index_summaries=summaries, service_context=service_context, ) return graph def create_list_index( api_key, summaries=[], temperature=0.0, model_name="text-davinci-003", max_tokens=2000, ): llm_predictor = LLMPredictor( llm=OpenAI( temperature=temperature, openai_api_key=api_key, model_name=model_name, max_tokens=max_tokens, ) ) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor) documents = [] for i, summary in enumerate(summaries): documents.append(Document(text=summary, doc_id=str(i))) index = GPTListIndex.from_documents(documents, service_context=service_context) return index @backoff.on_exception( partial(backoff.expo, max_value=50), ( openai.error.RateLimitError, openai.error.APIError, openai.error.APIConnectionError, openai.error.ServiceUnavailableError, openai.error.Timeout, ), ) def get_gpt_completion( prompt, temp=0.0, engine="text-davinci-003", top_p=1, frequency_penalty=0, presence_penalty=0, ): response = openai.Completion.create( engine=engine, prompt=prompt, temperature=temp, max_tokens=get_max_completion_len(prompt), top_p=top_p, frequency_penalty=frequency_penalty, presence_penalty=presence_penalty, ) return response.choices[0].text.strip() @backoff.on_exception( partial(backoff.expo, max_value=50), ( openai.error.RateLimitError, openai.error.APIError, openai.error.APIConnectionError, openai.error.ServiceUnavailableError, openai.error.Timeout, ), ) def get_gpt_chat_completion( system_prompt, user_prompt, model="gpt-3.5-turbo-16k", temp=0.0 ): response = openai.ChatCompletion.create( model=model, messages=[ {"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}, ], temperature=temp, ) return response.choices[0]["message"]["content"].strip() ### FILE UTILS ### def make_dir(path): if not os.path.exists(path): os.makedirs(path) def write_file(path, contents, mode="w"): with open(path, mode) as f: f.write(contents) def read_file(path, mode="r"): with open(path, mode) as f: contents = f.read() if not contents: print(f"WARNING: file {path} empty") return contents def sanitize_dir_name(dir_name): # Remove invalid characters dir_name = re.sub(r'[<>:"/\|?*]', "_", dir_name) dir_name = dir_name.replace(" ", "_") # Remove leading period if dir_name.startswith("."): dir_name = dir_name[1:] return dir_name def save( index, doc_store, OBJECTIVE, current_datetime, task_id_counter, task_list, completed_tasks, cache, reload_count, summaries, ): # Make basepath. path = os.path.join("./out", sanitize_dir_name(OBJECTIVE) + "_" + current_datetime) make_dir(path) # Save llama index. index.storage_context.persist(persist_dir=os.path.join(path, "index.json")) # Save program state. state = { "summaries": summaries, "reload_count": reload_count, "task_id_counter": task_id_counter, "task_list": list(task_list), "completed_tasks": completed_tasks, "cache": dict(cache), "current_datetime": current_datetime, "objective": OBJECTIVE, } with open(os.path.join(path, "state.json"), "w") as outfile: json.dump(state, outfile) # Save results. if "key_results" in doc_store: if reload_count: new_time = str(time.strftime("%Y-%m-%d_%H-%M-%S")) header = f"# {OBJECTIVE}\nDate: {new_time}\n\n" else: header = f"# {OBJECTIVE}\nDate: {current_datetime}\n\n" key_findings_path = os.path.join(path, f"key_findings_{reload_count}.md") write_file(key_findings_path, header, mode="a+") for res in doc_store["key_results"]: content = f"{res[0]}{res[1]}" write_file(key_findings_path, content, mode="a+") for task, doc in doc_store["tasks"].items(): doc_path = os.path.join(path, task) make_dir(doc_path) result_path = os.path.join(doc_path, "results") make_dir(result_path) if "executive_summary" in doc: write_file( os.path.join(result_path, "executive_summary.txt"), doc["executive_summary"], ) if "result_code" in doc: write_file(os.path.join(result_path, "api_call.txt"), doc["result_code"]) for i, result in enumerate(doc["results"]): result_path_i = os.path.join(result_path, str(i)) make_dir(result_path_i) write_file(os.path.join(result_path_i, "output.txt"), result["output"]) write_file( os.path.join(result_path_i, "vector.txt"), str(result["vectorized_data"]), ) def load(path): llm_predictor = LLMPredictor( llm=ChatOpenAI( temperature=0, openai_api_key=api_key, model_name="gpt-3.5-turbo-16k", max_tokens=6000, ) ) service_context = ServiceContext.from_defaults( llm_predictor=llm_predictor, chunk_size=4000 ) # rebuild storage context storage_context = StorageContext.from_defaults( persist_dir=os.path.join(path, "index.json") ) index = load_index_from_storage( storage_context=storage_context, service_context=service_context ) state_path = os.path.join(path, "state.json") if os.path.exists(state_path): with open(state_path, "r") as f: json_data = json.load(f) try: reload_count = json_data["reload_count"] + 1 task_id_counter = json_data["task_id_counter"] task_list = json_data["task_list"] completed_tasks = json_data["completed_tasks"] cache = defaultdict(list, json_data["cache"]) current_datetime = json_data["current_datetime"] objective = json_data["objective"] summaries = json_data["summaries"] except KeyError as e: raise Exception( f"Missing key '{e.args[0]}' in JSON file at path '{state_path}'" ) return ( index, task_id_counter, deque(task_list), completed_tasks, cache, current_datetime, objective, reload_count, summaries, )

[((3048, 3084), 'tiktoken.get_encoding', 'tiktoken.get_encoding', (['encoding_name'], {}), '(encoding_name)\n', (3069, 3084), False, 'import tiktoken\n'), ((14814, 14888), 'llama_index.Document', 'Document', ([], {'text': 'data', 'embedding': 'embedding', 'doc_id': 'doc_id', 'metadata': 'metadata'}), '(text=data, embedding=embedding, doc_id=doc_id, metadata=metadata)\n', (14822, 14888), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((19422, 19479), 'llama_index.retrievers.VectorIndexRetriever', 'VectorIndexRetriever', ([], {'index': 'index', 'similarity_top_k': 'top_k'}), '(index=index, similarity_top_k=top_k)\n', (19442, 19479), False, 'from llama_index.retrievers import VectorIndexRetriever\n'), ((19568, 19629), 'llama_index.ResponseSynthesizer.from_args', 'ResponseSynthesizer.from_args', ([], {'response_mode': '"""tree_summarize"""'}), "(response_mode='tree_summarize')\n", (19597, 19629), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((19693, 19782), 'llama_index.query_engine.RetrieverQueryEngine', 'RetrieverQueryEngine', ([], {'retriever': 'retriever', 'response_synthesizer': 'response_synthesizer'}), '(retriever=retriever, response_synthesizer=\n response_synthesizer)\n', (19713, 19782), False, 'from llama_index.query_engine import RetrieverQueryEngine\n'), ((21128, 21202), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'chunk_size': '(4000)'}), '(llm_predictor=llm_predictor, chunk_size=4000)\n', (21156, 21202), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((21228, 21291), 'llama_index.GPTVectorStoreIndex', 'GPTVectorStoreIndex', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (21247, 21291), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((21681, 21738), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor'}), '(llm_predictor=llm_predictor)\n', (21709, 21738), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((21752, 21869), 'llama_index.indices.composability.ComposableGraph.from_indices', 'ComposableGraph.from_indices', (['GPTListIndex', 'indicies'], {'index_summaries': 'summaries', 'service_context': 'service_context'}), '(GPTListIndex, indicies, index_summaries=\n summaries, service_context=service_context)\n', (21780, 21869), False, 'from llama_index.indices.composability import ComposableGraph\n'), ((22293, 22350), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor'}), '(llm_predictor=llm_predictor)\n', (22321, 22350), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((22491, 22562), 'llama_index.GPTListIndex.from_documents', 'GPTListIndex.from_documents', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (22518, 22562), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((22609, 22644), 'functools.partial', 'partial', (['backoff.expo'], {'max_value': '(50)'}), '(backoff.expo, max_value=50)\n', (22616, 22644), False, 'from functools import partial\n'), ((23696, 23862), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'model', 'messages': "[{'role': 'system', 'content': system_prompt}, {'role': 'user', 'content':\n user_prompt}]", 'temperature': 'temp'}), "(model=model, messages=[{'role': 'system',\n 'content': system_prompt}, {'role': 'user', 'content': user_prompt}],\n temperature=temp)\n", (23724, 23862), False, 'import openai\n'), ((23344, 23379), 'functools.partial', 'partial', (['backoff.expo'], {'max_value': '(50)'}), '(backoff.expo, max_value=50)\n', (23351, 23379), False, 'from functools import partial\n'), ((24449, 24486), 're.sub', 're.sub', (['"""[<>:"/\\\\|?*]"""', '"""_"""', 'dir_name'], {}), '(\'[<>:"/\\\\|?*]\', \'_\', dir_name)\n', (24455, 24486), False, 'import re\n'), ((27227, 27301), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'chunk_size': '(4000)'}), '(llm_predictor=llm_predictor, chunk_size=4000)\n', (27255, 27301), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((27471, 27565), 'llama_index.load_index_from_storage', 'load_index_from_storage', ([], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(storage_context=storage_context, service_context=\n service_context)\n', (27494, 27565), False, 'from llama_index import Document, GPTListIndex, GPTVectorStoreIndex, LLMPredictor, ResponseSynthesizer, ServiceContext, StorageContext, VectorStoreIndex, load_index_from_storage\n'), ((27592, 27624), 'os.path.join', 'os.path.join', (['path', '"""state.json"""'], {}), "(path, 'state.json')\n", (27604, 27624), False, 'import os\n'), ((27632, 27658), 'os.path.exists', 'os.path.exists', (['state_path'], {}), '(state_path)\n', (27646, 27658), False, 'import os\n'), ((899, 931), 'logging.getLogger', 'logging.getLogger', (['"""llama_index"""'], {}), "('llama_index')\n", (916, 931), False, 'import logging\n'), ((2879, 2895), 'collections.deque', 'deque', (['task_list'], {}), '(task_list)\n', (2884, 2895), False, 'from collections import defaultdict, deque\n'), ((10649, 10670), 'xml.etree.ElementTree.fromstring', 'ET.fromstring', (['result'], {}), '(result)\n', (10662, 10670), True, 'import xml.etree.ElementTree as ET\n'), ((24036, 24056), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (24050, 24056), False, 'import os\n'), ((24066, 24083), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (24077, 24083), False, 'import os\n'), ((25481, 25506), 'json.dump', 'json.dump', (['state', 'outfile'], {}), '(state, outfile)\n', (25490, 25506), False, 'import json\n'), ((25821, 25874), 'os.path.join', 'os.path.join', (['path', 'f"""key_findings_{reload_count}.md"""'], {}), "(path, f'key_findings_{reload_count}.md')\n", (25833, 25874), False, 'import os\n'), ((26151, 26175), 'os.path.join', 'os.path.join', (['path', 'task'], {}), '(path, task)\n', (26163, 26175), False, 'import os\n'), ((26225, 26258), 'os.path.join', 'os.path.join', (['doc_path', '"""results"""'], {}), "(doc_path, 'results')\n", (26237, 26258), False, 'import os\n'), ((28455, 28471), 'collections.deque', 'deque', (['task_list'], {}), '(task_list)\n', (28460, 28471), False, 'from collections import defaultdict, deque\n'), ((4448, 4470), 'markdown.markdown', 'markdown.markdown', (['res'], {}), '(res)\n', (4465, 4470), False, 'import markdown\n'), ((4498, 4530), 'markdown.markdown', 'markdown.markdown', (['citation_data'], {}), '(citation_data)\n', (4515, 4530), False, 'import markdown\n'), ((20669, 20779), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': 'temperature', 'openai_api_key': 'api_key', 'model_name': 'model_name', 'max_tokens': 'max_tokens'}), '(temperature=temperature, openai_api_key=api_key, model_name=\n model_name, max_tokens=max_tokens)\n', (20679, 20779), False, 'from langchain.chat_models import ChatOpenAI\n'), ((21492, 21598), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': 'temperature', 'openai_api_key': 'api_key', 'model_name': 'model_name', 'max_tokens': 'max_tokens'}), '(temperature=temperature, openai_api_key=api_key, model_name=\n model_name, max_tokens=max_tokens)\n', (21498, 21598), False, 'from langchain import OpenAI\n'), ((22104, 22210), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': 'temperature', 'openai_api_key': 'api_key', 'model_name': 'model_name', 'max_tokens': 'max_tokens'}), '(temperature=temperature, openai_api_key=api_key, model_name=\n model_name, max_tokens=max_tokens)\n', (22110, 22210), False, 'from langchain import OpenAI\n'), ((25023, 25055), 'os.path.join', 'os.path.join', (['path', '"""index.json"""'], {}), "(path, 'index.json')\n", (25035, 25055), False, 'import os\n'), ((25422, 25454), 'os.path.join', 'os.path.join', (['path', '"""state.json"""'], {}), "(path, 'state.json')\n", (25434, 25454), False, 'import os\n'), ((27041, 27144), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'openai_api_key': 'api_key', 'model_name': '"""gpt-3.5-turbo-16k"""', 'max_tokens': '(6000)'}), "(temperature=0, openai_api_key=api_key, model_name=\n 'gpt-3.5-turbo-16k', max_tokens=6000)\n", (27051, 27144), False, 'from langchain.chat_models import ChatOpenAI\n'), ((27419, 27451), 'os.path.join', 'os.path.join', (['path', '"""index.json"""'], {}), "(path, 'index.json')\n", (27431, 27451), False, 'import os\n'), ((27725, 27737), 'json.load', 'json.load', (['f'], {}), '(f)\n', (27734, 27737), False, 'import json\n'), ((14550, 14619), 'openai.Embedding.create', 'openai.Embedding.create', ([], {'input': '[text]', 'model': '"""text-embedding-ada-002"""'}), "(input=[text], model='text-embedding-ada-002')\n", (14573, 14619), False, 'import openai\n'), ((25615, 25649), 'time.strftime', 'time.strftime', (['"""%Y-%m-%d_%H-%M-%S"""'], {}), "('%Y-%m-%d_%H-%M-%S')\n", (25628, 25649), False, 'import time\n'), ((26369, 26419), 'os.path.join', 'os.path.join', (['result_path', '"""executive_summary.txt"""'], {}), "(result_path, 'executive_summary.txt')\n", (26381, 26419), False, 'import os\n'), ((26533, 26574), 'os.path.join', 'os.path.join', (['result_path', '"""api_call.txt"""'], {}), "(result_path, 'api_call.txt')\n", (26545, 26574), False, 'import os\n'), ((26771, 26812), 'os.path.join', 'os.path.join', (['result_path_i', '"""output.txt"""'], {}), "(result_path_i, 'output.txt')\n", (26783, 26812), False, 'import os\n'), ((26872, 26913), 'os.path.join', 'os.path.join', (['result_path_i', '"""vector.txt"""'], {}), "(result_path_i, 'vector.txt')\n", (26884, 26913), False, 'import os\n'), ((28018, 28055), 'collections.defaultdict', 'defaultdict', (['list', "json_data['cache']"], {}), "(list, json_data['cache'])\n", (28029, 28055), False, 'from collections import defaultdict, deque\n'), ((13093, 13192), 'openai.Completion.create', 'openai.Completion.create', ([], {'engine': '"""text-davinci-003"""', 'prompt': 'validation_prompt', 'temperature': '(0.0)'}), "(engine='text-davinci-003', prompt=\n validation_prompt, temperature=0.0)\n", (13117, 13192), False, 'import openai\n')]

import streamlit as st import requests import base64 import os import llama_index from audio_recorder_streamlit import audio_recorder from openai import OpenAI from llama_index import VectorStoreIndex, SimpleDirectoryReader from scipy.io.wavfile import write os.environ['OPENAI_API_KEY'] = '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' API_KEY = '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' def RAG(text): documents = SimpleDirectoryReader("db3").load_data() index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() response = query_engine.query(text) # Extract the text from the response response_text = response.response if hasattr(response, 'response') else str(response) return response_text def linkRAGhindi(text): new_prompt="निम्नलिखित प्रश्न के लिए सबसे उपयुक्त वेबसाइट लिंक दें"+text documents = SimpleDirectoryReader("db1").load_data() index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() response = query_engine.query(new_prompt) # Extract the text from the response response_text = response.response if hasattr(response, 'response') else str(response) return response_text def rechindi(text): new_prompt="निम्नलिखित प्रश्न के लिए सबसे उपयुक्त वेबसाइट लिंक दें"+text documents = SimpleDirectoryReader("db2").load_data() index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() response = query_engine.query(new_prompt) # Extract the text from the response response_text = response.response if hasattr(response, 'response') else str(response) return response_text def linkRAGenglish(text): new_prompt="Give the most appropiate website link for the following question "+text documents = SimpleDirectoryReader("db1").load_data() index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() response = query_engine.query(new_prompt) # Extract the text from the response response_text = response.response if hasattr(response, 'response') else str(response) return response_text def recenglish(text): new_prompt="Give the most intresting other website link for the following question "+text documents = SimpleDirectoryReader("db2").load_data() index = VectorStoreIndex.from_documents(documents) query_engine = index.as_query_engine() response = query_engine.query(new_prompt) # Extract the text from the response response_text = response.response if hasattr(response, 'response') else str(response) return response_text def transcribe_text_to_voice_english(audio_location): client = OpenAI(api_key=API_KEY) audio_file = open(audio_location, "rb") transcript = client.audio.transcriptions.create(model="whisper-1", file=audio_file) return transcript.text def transcribe_text_to_voice_hindi(audio_location): url = "https://api.runpod.ai/v2/faster-whisper/runsync" with open(audio_location, "rb") as audio_file: audio_base64 = base64.b64encode(audio_file.read()).decode('utf-8') payload = { "input": { "audio_base64": audio_base64, "model": "small", "transcription": "plain_text", "translate": True, "language": "hi", "temperature": 0, "best_of": 5, "beam_size": 5, "patience": 1, "suppress_tokens": "-1", "condition_on_previous_text": False, "temperature_increment_on_fallback": 0.2, "compression_ratio_threshold": 2.4, "logprob_threshold": -1, "no_speech_threshold": 0.6, "word_timestamps": False }, "enable_vad": False } headers = { "accept": "application/json", "content-type": "application/json", "authorization": "X01PG949AHTOVRYHLQZKSRIWN82UHBUU5JYLNAHM" } response = requests.post(url, json=payload, headers=headers) response_json = response.json() transcription = response_json["output"]["transcription"] translation = response_json["output"]["translation"].strip().split('\n')[-1].strip() return transcription, translation def recommendation(text): client = OpenAI(api_key=API_KEY) messages = [{"role": "user", "content": text}] response = client.chat.completions.create(model="gpt-3.5-turbo-1106", messages=messages) return response.choices[0].message.content def text_to_speech_ai(speech_file_path, api_response): client = OpenAI(api_key=API_KEY) response = client.audio.speech.create(model="tts-1",voice="nova",input=api_response) response.stream_to_file(speech_file_path) st.title("🚀 SHRESHTH 💬 Bhuvan Assistant") # Radio wheel for language selection language = st.radio("Language/भाषा",["English", "हिंदी"]) # Displaying description based on selected language if language == "English": mode = st.radio("Select Mode Of Input", ["Voice","Text"]) st.write("Smart - Helpful - Robust - Effortless - System for Text-to-speech and Human-like Assistance") if mode == "Voice" or mode == "आवाज": st.write("Click on the voice recorder and let me know how I can help you today with your Queries Regarding Bhuvan!") audio_bytes = audio_recorder( text="", recording_color="#e8b62c", neutral_color="#6aa36f", icon_name="microphone", icon_size="2x", ) if audio_bytes: # Save the Recorded File audio_location = "audio_file.wav" with open(audio_location, "wb") as f: f.write(audio_bytes) if language == "English": text=transcribe_text_to_voice_english(audio_location) st.write(text) else: text,trans=transcribe_text_to_voice_hindi(audio_location) st.write(text) link_response = linkRAGenglish(text) st.write("SHRESHTH:", link_response) api_response = RAG(text) st.write("SHRESHTH:", api_response) speech_file_path = 'audio_response.mp3' text_to_speech_ai(speech_file_path, api_response) st.audio(speech_file_path) recctext="recommend top three other websites that could interest the user depending on this link and answer : " + link_response + api_response recc=linkRAGenglish(recctext) st.write("SHRESHTH:", recc) else: # Text input option text_input = st.text_area("Enter your text here and press Enter", "") if st.button("Submit"): # Process the entered text link_response = linkRAGenglish(text_input) st.write("SHRESHTH:", link_response) api_response = RAG(text_input) st.write("SHRESHTH:", api_response) # Read out the text response using tts speech_file_path = 'audio_response.mp3' text_to_speech_ai(speech_file_path, api_response) st.audio(speech_file_path) recctext="recommend top three other websites that could interest the user depending on this link and answer : " + link_response + api_response recc=linkRAGenglish(recctext) st.write("SHRESHTH:", recc) else: mode = st.radio("इनपुट मोड का चयन करें", ["आवाज", "टेक्स्ट"]) st.write("स्मार्ट - सहायक - मजबूत - प्रयासहीन - पाठ-से-बोल के लिए एक सिस्टम और मानव जैसी सहायता") if mode == "Voice" or mode == "आवाज" or mode == "ভয়েস": st.write("आवाज रेकॉर्डर पर क्लिक करें और मुझसे यह बताएं कि आज आपकी भुवन से संबंधित सवालों में मैं आपकी कैसे मदद कर सकता हूँ!") audio_bytes = audio_recorder( text="", recording_color="#e8b62c", neutral_color="#6aa36f", icon_name="microphone", icon_size="2x", ) if audio_bytes: # Save the Recorded File audio_location = "audio_file.wav" with open(audio_location, "wb") as f: f.write(audio_bytes) if language == "English": text=transcribe_text_to_voice_english(audio_location) st.write(text) else: text,trans=transcribe_text_to_voice_hindi(audio_location) st.write(text) link_response = linkRAGhindi(text) st.write("श्रेष्ठ:", link_response) api_response = RAG(text) st.write("श्रेष्ठ:", api_response) # Read out the text response using tts speech_file_path = 'audio_response.mp3' text_to_speech_ai(speech_file_path, api_response) st.audio(speech_file_path) recctext="recommend top three other websites that could interest the user depending on this link and answer : " + link_response + api_response recc=rechindi(recctext) st.write("श्रेष्ठ:", recc) else: # Text input option text_input = st.text_area("आप यहाँ अपना टेक्स्ट दर्ज करें और एंटर दबाएं", "") if st.button("एंटर"): # Process the entered text link_response = linkRAGhindi(text_input) st.write("श्रेष्ठ:", link_response) api_response = RAG(text_input) st.write("श्रेष्ठ:", api_response) # Read out the text response using tts speech_file_path = 'audio_response.mp3' text_to_speech_ai(speech_file_path, api_response) st.audio(speech_file_path) recctext="recommend top three other websites that could interest the user depending on this link and answer : " + link_response + api_response recc=rechindi(recctext) st.write("श्रेष्ठ:", recc)

[((4762, 4803), 'streamlit.title', 'st.title', (['"""🚀 SHRESHTH 💬 Bhuvan Assistant"""'], {}), "('🚀 SHRESHTH 💬 Bhuvan Assistant')\n", (4770, 4803), True, 'import streamlit as st\n'), ((4853, 4900), 'streamlit.radio', 'st.radio', (['"""Language/भाषा"""', "['English', 'हिंदी']"], {}), "('Language/भाषा', ['English', 'हिंदी'])\n", (4861, 4900), True, 'import streamlit as st\n'), ((492, 534), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (523, 534), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((950, 992), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (981, 992), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((1410, 1452), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (1441, 1452), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((1886, 1928), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (1917, 1928), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((2359, 2401), 'llama_index.VectorStoreIndex.from_documents', 'VectorStoreIndex.from_documents', (['documents'], {}), '(documents)\n', (2390, 2401), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((2714, 2737), 'openai.OpenAI', 'OpenAI', ([], {'api_key': 'API_KEY'}), '(api_key=API_KEY)\n', (2720, 2737), False, 'from openai import OpenAI\n'), ((4000, 4049), 'requests.post', 'requests.post', (['url'], {'json': 'payload', 'headers': 'headers'}), '(url, json=payload, headers=headers)\n', (4013, 4049), False, 'import requests\n'), ((4315, 4338), 'openai.OpenAI', 'OpenAI', ([], {'api_key': 'API_KEY'}), '(api_key=API_KEY)\n', (4321, 4338), False, 'from openai import OpenAI\n'), ((4598, 4621), 'openai.OpenAI', 'OpenAI', ([], {'api_key': 'API_KEY'}), '(api_key=API_KEY)\n', (4604, 4621), False, 'from openai import OpenAI\n'), ((4989, 5040), 'streamlit.radio', 'st.radio', (['"""Select Mode Of Input"""', "['Voice', 'Text']"], {}), "('Select Mode Of Input', ['Voice', 'Text'])\n", (4997, 5040), True, 'import streamlit as st\n'), ((5044, 5157), 'streamlit.write', 'st.write', (['"""Smart - Helpful - Robust - Effortless - System for Text-to-speech and Human-like Assistance"""'], {}), "(\n 'Smart - Helpful - Robust - Effortless - System for Text-to-speech and Human-like Assistance'\n )\n", (5052, 5157), True, 'import streamlit as st\n'), ((7402, 7456), 'streamlit.radio', 'st.radio', (['"""इनपुट मोड का चयन करें"""', "['आवाज', 'टेक्स्ट']"], {}), "('इनपुट मोड का चयन करें', ['आवाज', 'टेक्स्ट'])\n", (7410, 7456), True, 'import streamlit as st\n'), ((7461, 7568), 'streamlit.write', 'st.write', (['"""स्मार्ट - सहायक - मजबूत - प्रयासहीन - पाठ-से-बोल के लिए एक सिस्टम और मानव जैसी सहायता"""'], {}), "(\n 'स्मार्ट - सहायक - मजबूत - प्रयासहीन - पाठ-से-बोल के लिए एक सिस्टम और मानव जैसी सहायता'\n )\n", (7469, 7568), True, 'import streamlit as st\n'), ((5198, 5324), 'streamlit.write', 'st.write', (['"""Click on the voice recorder and let me know how I can help you today with your Queries Regarding Bhuvan!"""'], {}), "(\n 'Click on the voice recorder and let me know how I can help you today with your Queries Regarding Bhuvan!'\n )\n", (5206, 5324), True, 'import streamlit as st\n'), ((5337, 5456), 'audio_recorder_streamlit.audio_recorder', 'audio_recorder', ([], {'text': '""""""', 'recording_color': '"""#e8b62c"""', 'neutral_color': '"""#6aa36f"""', 'icon_name': '"""microphone"""', 'icon_size': '"""2x"""'}), "(text='', recording_color='#e8b62c', neutral_color='#6aa36f',\n icon_name='microphone', icon_size='2x')\n", (5351, 5456), False, 'from audio_recorder_streamlit import audio_recorder\n'), ((6619, 6675), 'streamlit.text_area', 'st.text_area', (['"""Enter your text here and press Enter"""', '""""""'], {}), "('Enter your text here and press Enter', '')\n", (6631, 6675), True, 'import streamlit as st\n'), ((6687, 6706), 'streamlit.button', 'st.button', (['"""Submit"""'], {}), "('Submit')\n", (6696, 6706), True, 'import streamlit as st\n'), ((7629, 7765), 'streamlit.write', 'st.write', (['"""आवाज रेकॉर्डर पर क्लिक करें और मुझसे यह बताएं कि आज आपकी भुवन से संबंधित सवालों में मैं आपकी कैसे मदद कर सकता हूँ!"""'], {}), "(\n 'आवाज रेकॉर्डर पर क्लिक करें और मुझसे यह बताएं कि आज आपकी भुवन से संबंधित सवालों में मैं आपकी कैसे मदद कर सकता हूँ!'\n )\n", (7637, 7765), True, 'import streamlit as st\n'), ((7778, 7897), 'audio_recorder_streamlit.audio_recorder', 'audio_recorder', ([], {'text': '""""""', 'recording_color': '"""#e8b62c"""', 'neutral_color': '"""#6aa36f"""', 'icon_name': '"""microphone"""', 'icon_size': '"""2x"""'}), "(text='', recording_color='#e8b62c', neutral_color='#6aa36f',\n icon_name='microphone', icon_size='2x')\n", (7792, 7897), False, 'from audio_recorder_streamlit import audio_recorder\n'), ((9118, 9182), 'streamlit.text_area', 'st.text_area', (['"""आप यहाँ अपना टेक्स्ट दर्ज करें और एंटर दबाएं"""', '""""""'], {}), "('आप यहाँ अपना टेक्स्ट दर्ज करें और एंटर दबाएं', '')\n", (9130, 9182), True, 'import streamlit as st\n'), ((9194, 9211), 'streamlit.button', 'st.button', (['"""एंटर"""'], {}), "('एंटर')\n", (9203, 9211), True, 'import streamlit as st\n'), ((439, 467), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""db3"""'], {}), "('db3')\n", (460, 467), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((897, 925), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""db1"""'], {}), "('db1')\n", (918, 925), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((1357, 1385), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""db2"""'], {}), "('db2')\n", (1378, 1385), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((1833, 1861), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""db1"""'], {}), "('db1')\n", (1854, 1861), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((2306, 2334), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""db2"""'], {}), "('db2')\n", (2327, 2334), False, 'from llama_index import VectorStoreIndex, SimpleDirectoryReader\n'), ((6045, 6081), 'streamlit.write', 'st.write', (['"""SHRESHTH:"""', 'link_response'], {}), "('SHRESHTH:', link_response)\n", (6053, 6081), True, 'import streamlit as st\n'), ((6131, 6166), 'streamlit.write', 'st.write', (['"""SHRESHTH:"""', 'api_response'], {}), "('SHRESHTH:', api_response)\n", (6139, 6166), True, 'import streamlit as st\n'), ((6293, 6319), 'streamlit.audio', 'st.audio', (['speech_file_path'], {}), '(speech_file_path)\n', (6301, 6319), True, 'import streamlit as st\n'), ((6531, 6558), 'streamlit.write', 'st.write', (['"""SHRESHTH:"""', 'recc'], {}), "('SHRESHTH:', recc)\n", (6539, 6558), True, 'import streamlit as st\n'), ((6814, 6850), 'streamlit.write', 'st.write', (['"""SHRESHTH:"""', 'link_response'], {}), "('SHRESHTH:', link_response)\n", (6822, 6850), True, 'import streamlit as st\n'), ((6906, 6941), 'streamlit.write', 'st.write', (['"""SHRESHTH:"""', 'api_response'], {}), "('SHRESHTH:', api_response)\n", (6914, 6941), True, 'import streamlit as st\n'), ((7119, 7145), 'streamlit.audio', 'st.audio', (['speech_file_path'], {}), '(speech_file_path)\n', (7127, 7145), True, 'import streamlit as st\n'), ((7357, 7384), 'streamlit.write', 'st.write', (['"""SHRESHTH:"""', 'recc'], {}), "('SHRESHTH:', recc)\n", (7365, 7384), True, 'import streamlit as st\n'), ((8483, 8518), 'streamlit.write', 'st.write', (['"""श्रेष्ठ:"""', 'link_response'], {}), "('श्रेष्ठ:', link_response)\n", (8491, 8518), True, 'import streamlit as st\n'), ((8568, 8602), 'streamlit.write', 'st.write', (['"""श्रेष्ठ:"""', 'api_response'], {}), "('श्रेष्ठ:', api_response)\n", (8576, 8602), True, 'import streamlit as st\n'), ((8786, 8812), 'streamlit.audio', 'st.audio', (['speech_file_path'], {}), '(speech_file_path)\n', (8794, 8812), True, 'import streamlit as st\n'), ((9018, 9044), 'streamlit.write', 'st.write', (['"""श्रेष्ठ:"""', 'recc'], {}), "('श्रेष्ठ:', recc)\n", (9026, 9044), True, 'import streamlit as st\n'), ((9317, 9352), 'streamlit.write', 'st.write', (['"""श्रेष्ठ:"""', 'link_response'], {}), "('श्रेष्ठ:', link_response)\n", (9325, 9352), True, 'import streamlit as st\n'), ((9408, 9442), 'streamlit.write', 'st.write', (['"""श्रेष्ठ:"""', 'api_response'], {}), "('श्रेष्ठ:', api_response)\n", (9416, 9442), True, 'import streamlit as st\n'), ((9625, 9651), 'streamlit.audio', 'st.audio', (['speech_file_path'], {}), '(speech_file_path)\n', (9633, 9651), True, 'import streamlit as st\n'), ((9857, 9883), 'streamlit.write', 'st.write', (['"""श्रेष्ठ:"""', 'recc'], {}), "('श्रेष्ठ:', recc)\n", (9865, 9883), True, 'import streamlit as st\n'), ((5846, 5860), 'streamlit.write', 'st.write', (['text'], {}), '(text)\n', (5854, 5860), True, 'import streamlit as st\n'), ((5967, 5981), 'streamlit.write', 'st.write', (['text'], {}), '(text)\n', (5975, 5981), True, 'import streamlit as st\n'), ((8283, 8297), 'streamlit.write', 'st.write', (['text'], {}), '(text)\n', (8291, 8297), True, 'import streamlit as st\n'), ((8404, 8418), 'streamlit.write', 'st.write', (['text'], {}), '(text)\n', (8412, 8418), True, 'import streamlit as st\n')]

import json import logging import os import re import time import xml.etree.ElementTree as ET from collections import defaultdict, deque from functools import partial import backoff import llama_index import markdown import openai import tiktoken from colorama import Fore from langchain import OpenAI from langchain.chat_models import ChatOpenAI from llama_index import Document, GPTVectorStoreIndex, LLMPredictor, ServiceContext, GPTListIndex from llama_index.indices.composability import ComposableGraph from llama_index.retrievers import VectorIndexRetriever from llama_index.query_engine import RetrieverQueryEngine from llama_index import StorageContext, load_index_from_storage, ServiceContext from llama_index import ( VectorStoreIndex, ResponseSynthesizer, ) from api.mygene_api import mygene_api from api.pubmed_api import pubmed_api from api.myvariant_api import myvariant_api from config import OPENAI_API_KEY logging.getLogger("llama_index").setLevel(logging.WARNING) #file_handler = logging.FileHandler('utils.log') # Configure the logging settings #logging.basicConfig(level=logging.INFO, handlers=[file_handler]) MAX_TOKENS = 4097 api_info_mapping = {"mygene": mygene_api, "PubMed": pubmed_api, "myvariant": myvariant_api} api_key = OPENAI_API_KEY or os.environ["OPENAI_API_KEY"] openai.api_key = api_key def get_input(prompt, type_=None, min_=None, max_=None, range_=None): if min_ is not None and max_ is not None and max_ < min_: raise ValueError("min_ must be less than or equal to max_.") while True: ui = input(prompt) if type_ is not None: try: ui = type_(ui) except ValueError: print(f"Input type must be {type_.__name__}!") continue if max_ is not None and ui > max_: print(f"Input must be less than or equal to {max_}.") elif min_ is not None and ui < min_: print(f"Input must be greater than or equal to {min_}.") elif range_ is not None and ui not in range_: if isinstance(range_, range): template = "Input must be between {} and {}." print(template.format(range_.start, range_.stop)) else: template = "Input must be {}." print(template.format(", ".join(map(str, range_)))) else: return ui def select_task(task_list): # Task list is actually a Queue task_list = list(task_list) print('\n\n') choice = get_input(Fore.LIGHTGREEN_EX + "\033[1mWhich task would you like to execute? Type 0 to create your own task! \033[0m", type_=int, min_=0, max_=len(task_list)) if choice == 0: task = input(Fore.LIGHTGREEN_EX + "\033[1mWrite your task! \033[0m") else: task = task_list.pop(choice - 1) return task, deque(task_list) def num_tokens_from_string(string: str, encoding_name: str = "gpt2") -> int: """Returns the number of tokens in a text string.""" encoding = tiktoken.get_encoding(encoding_name) num_tokens = len(encoding.encode(string)) return num_tokens def get_key_results(index, objective, top_k=20, additional_queries=[]): """Run final queries over retrieved documents and store in doc_store.""" if not index.docstore.docs: print(Fore.RED + "\033[1m\n! WARNING: NO TASKS RETURNED RESULTS. PLEASE TWEAK YOUR OBJECTIVE AND CHECK SPELLING. !\n\033[0m") return [] print(Fore.CYAN + "\033[1m\n*****COMPILING KEY RESULTS*****\n\033[0m") key_results = [] queries = [ "Give a brief high level summary of all the data.", "Briefly list all the main points that the data covers.", "Generate several creative hypotheses given the data.", "What are some high level research directions to explore further given the data?", f"Do your best to answer the objective: {objective} given the information.", ] for query in queries: print(Fore.CYAN + f"\nCOMPILING RESULT {query}\n") res = None try: res, citation_data = query_knowledge_base(index=index, query=query, list_index=False, top_k=top_k) except Exception as e: print(f"Exception getting key result {query}, error {e}") if res: query = f"## {query}\n\n" res_html = markdown.markdown(res) res_citation = markdown.markdown(citation_data) key_results.append((query, f"{res_html}\n\n### Citations\n\n{res_citation}\n\n")) print(Fore.CYAN + f"\nRESULTS COMPILED. SAVED TO DIRECTORY `out`\n") return key_results def get_max_completion_len(prompt): tokens = num_tokens_from_string(prompt) return MAX_TOKENS - tokens def execute_python(code: str): # ret is defined in the code string loc = {} try: exec(code, globals(), loc) except Exception as e: print(f"Exception executing code {code}, {e}") return return loc["ret"] def process_myvariant_result(results): processed_result = [] if not isinstance(results, list): results = [results] for result in results: variant_name = result.get("_id") gene_affected = result.get("cadd", {}).get("gene", {}).get("genename") consequence = result.get("cadd", {}).get("consequence") cadd_score = result.get("cadd", {}).get("phred") rsid = result.get("dbsnp", {}).get("rsid") variant_data = "" citation_data = "" if variant_name: variant_data += f"Variant Name: {variant_name}\n" if gene_affected: variant_data += f"Gene Affected: {gene_affected}\n" if consequence: variant_data += f"Consequence: {consequence}\n" if cadd_score is not None: variant_data += f"CADD Score: {cadd_score}\n" if rsid: variant_data += f"rsID: {rsid}\n" processed_result.append((variant_data,{"citation_data": citation_data})) return processed_result def process_mygene_result(results): processed_result = [] if not isinstance(results, list): results = [results] # Each result will be split into 2 documents: summary and pathway for json_data in results: name = json_data.get("name") refseq_genomic = json_data.get("refseq", {}).get("genomic", []) refseq_rna = json_data.get("refseq", {}).get("rna", []) symbol = json_data.get("symbol") taxid = json_data.get("taxid") type_of_gene = json_data.get("type_of_gene") pos = json_data.get("genomic_pos_hg19") summary = json_data.get("summary") generif = json_data.get("generif") output_summary = "" citation_data = "" # Summary if name: output_summary += f"Gene Name: {name}\n" if refseq_genomic: output_summary += f"RefSeq genomic: {', '.join(refseq_genomic)}\n" if refseq_rna: output_summary += f"RefSeq rna: {', '.join(refseq_rna)}\n" if symbol: output_summary += f"Symbol: {symbol}\n" if taxid: output_summary += f"Tax ID: {taxid}\n" if type_of_gene and type_of_gene != 'unknown': output_summary += f"Type of gene: {type_of_gene}\n" if pos: output_summary += f"Position: {pos}\n" if summary: output_summary += f"Summary of {name}: {summary}\n" else: # If not summary, use generifs. if generif: # Take 20 rifs max. Some genes have hundreds of rifs and the results size explodes. for rif in generif[:20]: pubmed = rif.get("pubmed") text = rif.get("text") if text: output_summary += text if pubmed: citation_data += f" Pubmed ID: {pubmed}" output_summary = output_summary.strip() #logging.info(f"Mygene Summary result {name}, length is {str(len(output_summary))}") if output_summary: processed_result.append((output_summary, {"citation_data": citation_data})) # Pathway pathway = json_data.get("pathway") if pathway: kegg = pathway.get("kegg", []) pid = pathway.get("pid", []) reactome = pathway.get("reactome", []) wikipathways = pathway.get("wikipathways", []) netpath = pathway.get("netpath", []) biocarta = pathway.get("biocarta", []) pathway_elements = {"kegg": kegg, "pid": pid, "reactome": reactome, "wikipathways": wikipathways, "netpath": netpath, "biocarta": biocarta} # mygene returns dicts instead of lists if singleton # Wrap with list if not list for k,v in pathway_elements.items(): if type(v) is not list: pathway_elements[k] = [v] output_pathway = "" citation_data = "" if name: output_pathway += f"Gene Name: {name}\n" if symbol: output_pathway += f"Symbol: {symbol}\n" if taxid: output_pathway += f"Tax ID: {taxid}\n" if type_of_gene and type_of_gene != 'unknown': output_pathway += f"Type of gene: {type_of_gene}\n" if refseq_genomic: output_pathway += f"RefSeq genomic: {', '.join(refseq_genomic)}\n" if refseq_rna: output_pathway += f"RefSeq rna: {', '.join(refseq_rna)}\n" if pos: output_pathway += f"Position: {pos}\n" output_pathway += f"PATHWAYS\n\n" for k,v in pathway_elements.items(): output_pathway += f"\n{k}:\n" for item in v: output_pathway += f" ID: {item.get('id', '')}" output_pathway += f" Name: {item.get('name', '')}" #logging.info(f"Mygene Pathway result {name}, length is {len(output_pathway)}") output_pathway = output_pathway.strip() if output_pathway: processed_result.append((output_pathway,{"citation_data": citation_data})) return processed_result def process_pubmed_result(result): try: root = ET.fromstring(result) except Exception as e: print(f"Cannot parse pubmed result, expected xml. {e}") print("Adding whole document. Note this will lead to suboptimal results.") return result if isinstance(result, list) else [result] processed_result = [] for article in root: res_ = "" citation_data = "" for title in article.iter("Title"): res_ += f"{title.text}\n" citation_data += f"{title.text}\n" for abstract in article.iter("AbstractText"): res_ += f"{abstract.text}\n" for author in article.iter("Author"): try: citation_data += f"{author.find('LastName').text}" citation_data += f", {author.find('ForeName').text}\n" except: pass for journal in article.iter("Journal"): res_ += f"{journal.find('Title').text}\n" citation_data += f"{journal.find('Title').text}\n" for volume in article.iter("Volume"): citation_data += f"{volume.text}\n" for issue in article.iter("Issue"): citation_data += f"{issue.text}\n" for pubdate in article.iter("PubDate"): try: year = pubdate.find("Year").text citation_data += f"{year}" month = pubdate.find("Month").text citation_data += f"-{month}" day = pubdate.find("Day").text citation_data += f"-{day}\n" except: pass for doi in article.iter("ELocationID"): if doi.get("EIdType") == "doi": res_ += f"{doi.text}\n" if res_: processed_result.append((res_,{"citation_data": citation_data})) return processed_result def get_code_params(code: str, preparam_text: str, postparam_text: str): l = len(preparam_text) preparam_index = code.find(preparam_text) postparam_index = code.find(postparam_text) if preparam_index == -1 or postparam_index == -1: return params = code[preparam_index + l : postparam_index].strip() if params == "": return return params def validate_llm_response(goal, response): validation_prompt = f"I gave an LLM this goal: '{goal}' and it gave this response: '{response}'. Is this reasonable, or did something go wrong? [yes|no]" validation_response = ( openai.Completion.create( engine="text-davinci-003", prompt=validation_prompt, temperature=0.0 ) .choices[0] .text.strip() ) if validation_response.lower() == "yes": return True else: return False def generate_tool_prompt(task): if "MYVARIANT" in task: api_name = "myvariant" elif "MYGENE" in task: api_name = "mygene" elif "PUBMED" in task: api_name = "PubMed" else: print(f"Error. Tool not found in task: {task}") return None api_info = api_info_mapping[api_name] prompt = f"""You have access to query the {api_name} API. If a task starts with '{api_name.upper()}:' then you should create the code to query the {api_name} API based off the documentation and return the code to complete your task. If you use the {api_name} API, do not answer with words, simply write the parameters used to call the function then cease output. Be sure it is valid python that will execute in a python interpreter. --- Here is the {api_name} documentation {api_info} --- You should change the parameters to fit your specific task. """.strip() return prompt def get_ada_embedding(text): ada_embedding_max_size = 8191 text = text.replace("\n", " ") if num_tokens_from_string(text) > ada_embedding_max_size: # There must be a better way to do this. text = text[:ada_embedding_max_size] return openai.Embedding.create(input=[text], model="text-embedding-ada-002")[ "data" ][0]["embedding"] def insert_doc_llama_index(index, doc_id, data, metadata={}, embedding=None): if not embedding: embedding = get_ada_embedding(data) doc = Document(text=data, embedding=embedding, doc_id=doc_id, metadata=metadata) doc.excluded_llm_metadata_keys = ['citation_data'] doc.excluded_embed_metadata_keys = ['citation_data'] index.insert(doc) def handle_python_result(result, cache, task, doc_store, doc_store_task_key): results_returned = True params = result doc_store["tasks"][doc_store_task_key]["result_code"] = result tool = task.split(":")[0] if tool == "MYGENE": result = "from api.mygene_wrapper import mygene_wrapper\n" + result + "\nret = mygene_wrapper(query_term, size, from_)" elif tool == "MYVARIANT": result = "from api.myvariant_wrapper import myvariant_wrapper\n" + result + "\nret = myvariant_wrapper(query_term)" elif tool == "PUBMED": result = "from api.pubmed_wrapper import pubmed_wrapper\n" + result + "\nret = pubmed_wrapper(query_term, retmax, retstart)" executed_result = execute_python(result) if type(executed_result) is list: executed_result = list(filter(lambda x : x, executed_result)) if (executed_result is not None) and (not executed_result): # Execution complete succesfully, but executed result was empty list results_returned = False result = "NOTE: Code returned no results\n\n" + result print(Fore.BLUE + f"\nTask '{task}' completed but returned no results") if "MYVARIANT" in task: if results_returned: cache["MYVARIANT"].append(f"---\n{params}---\n") else: cache["MYVARIANT"].append(f"---\nNote: This call returned no results\n{params}---\n") processed_result = process_myvariant_result(executed_result) if "MYGENE" in task: if results_returned: cache["MYGENE"].append(f"---\n{params}---\n") else: cache["MYGENE"].append(f"---\nNote: This call returned no results\n{params}---\n") processed_result = process_mygene_result(executed_result) if "PUBMED" in task: if results_returned: cache["PUBMED"].append(f"---\n{params}---\n") else: cache["PUBMED"].append(f"---\nNote: This call returned no results\n{params}---\n") processed_result = process_pubmed_result(executed_result) if executed_result is None: result = "NOTE: Code did not run succesfully\n\n" + result print(Fore.BLUE + f"Task '{task}' failed. Code {result} did not run succesfully.") if "MYGENE" in task: cache["MYGENE"].append(f"---\nNote: This call did not run succesfully\n{params}---\n") if "PUBMED" in task: cache["PUBMED"].append(f"---\nNote: This call did not run succesfully\n{params}---\n") if "MYVARIANT" in task: cache["MYVARIANT"].append(f"---\nNote: This call did not run succesfully\n{params}---\n") return return processed_result def handle_results(result, index, doc_store, doc_store_key, task_id_counter, RESULT_CUTOFF): for i, r in enumerate(result): res, metadata = r[0], r[1] res = str(res)[ :RESULT_CUTOFF ] # Occasionally an enormous result will slow the program to a halt. Not ideal to lose results but putting in place for now. vectorized_data = get_ada_embedding(res) task_id = f"doc_id_{task_id_counter}_{i}" insert_doc_llama_index(index=index, doc_id=task_id, data=res, metadata=metadata, embedding=vectorized_data) doc_store["tasks"][doc_store_key]["results"].append( { "task_id_counter": task_id_counter, "vectorized_data": vectorized_data, "output": res, "metadata": metadata, } ) def query_knowledge_base( index, query="Give a detailed but terse overview of all the information. Start with a high level summary and then go into details. Do not include any further instruction. Do not include filler words.", response_mode="tree_summarize", top_k=50, list_index=False ): if not index.docstore.docs: print(Fore.RED + "NO INFORMATION IN LLAMA INDEX") return # configure retriever retriever = VectorIndexRetriever( index=index, similarity_top_k=top_k, ) # configure response synthesizer response_synthesizer = ResponseSynthesizer.from_args( response_mode="tree_summarize", ) # assemble query engine query_engine = RetrieverQueryEngine( retriever=retriever, response_synthesizer=response_synthesizer, ) if list_index: query_response = index.query( query, response_mode="default" ) else: # From llama index docs: Empirically, setting response_mode="tree_summarize" also leads to better summarization results. query_response = query_engine.query(query) extra_info = "" if query_response.metadata: try: extra_info = [x.get("citation_data") for x in query_response.metadata.values()] if not any(extra_info): extra_info = [] except Exception as e: print("Issue getting extra info from llama index") return query_response.response, '\n\n'.join(extra_info) def create_index(api_key,summaries=[], temperature=0.0, model_name="gpt-3.5-turbo-16k", max_tokens=6000): llm_predictor = LLMPredictor( llm=ChatOpenAI( temperature=temperature, openai_api_key=api_key, model_name=model_name, max_tokens=max_tokens, ) ) documents = [] for i, summary in enumerate(summaries): doc = Document(text=summary, doc_id=str(i)) doc.excluded_llm_metadata_keys = ['citation_data'] doc.excluded_embed_metadata_keys = ['citation_data'] documents.append(doc) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, chunk_size=4000) return GPTVectorStoreIndex(documents, service_context=service_context) def create_graph_index(api_key, indicies=[], summaries=[], temperature=0.0, model_name="text-davinci-003", max_tokens=2000): llm_predictor = LLMPredictor( llm=OpenAI( temperature=temperature, openai_api_key=api_key, model_name=model_name, max_tokens=max_tokens, ) ) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor) graph = ComposableGraph.from_indices( GPTListIndex, indicies, index_summaries=summaries, service_context=service_context ) return graph def create_list_index(api_key, summaries=[], temperature=0.0, model_name="text-davinci-003", max_tokens=2000): llm_predictor = LLMPredictor( llm=OpenAI( temperature=temperature, openai_api_key=api_key, model_name=model_name, max_tokens=max_tokens, ) ) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor) documents = [] for i, summary in enumerate(summaries): documents.append(Document(text=summary, doc_id=str(i))) index = GPTListIndex.from_documents(documents, service_context=service_context) return index @backoff.on_exception( partial(backoff.expo, max_value=50), (openai.error.RateLimitError, openai.error.APIError, openai.error.APIConnectionError, openai.error.ServiceUnavailableError, openai.error.Timeout), ) def get_gpt_completion( prompt, temp=0.0, engine="text-davinci-003", top_p=1, frequency_penalty=0, presence_penalty=0, ): response = openai.Completion.create( engine=engine, prompt=prompt, temperature=temp, max_tokens=get_max_completion_len(prompt), top_p=top_p, frequency_penalty=frequency_penalty, presence_penalty=presence_penalty, ) return response.choices[0].text.strip() @backoff.on_exception( partial(backoff.expo, max_value=50), (openai.error.RateLimitError, openai.error.APIError, openai.error.APIConnectionError, openai.error.ServiceUnavailableError, openai.error.Timeout), ) def get_gpt_chat_completion( system_prompt, user_prompt, model="gpt-3.5-turbo-16k", temp=0.0 ): response = openai.ChatCompletion.create( model=model, messages=[ {"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}, ], temperature=temp, ) return response.choices[0]["message"]["content"].strip() ### FILE UTILS ### def make_dir(path): if not os.path.exists(path): os.makedirs(path) def write_file(path, contents, mode="w"): with open(path, mode) as f: f.write(contents) def read_file(path, mode="r"): with open(path, mode) as f: contents = f.read() if not contents: print(f"WARNING: file {path} empty") return contents def sanitize_dir_name(dir_name): # Remove invalid characters dir_name = re.sub(r'[<>:"/\|?*]', '_', dir_name) dir_name = dir_name.replace(' ', '_') # Remove leading period if dir_name.startswith('.'): dir_name = dir_name[1:] return dir_name def save( index, doc_store, OBJECTIVE, current_datetime, task_id_counter, task_list, completed_tasks, cache, reload_count, summaries, ): # Make basepath. path = os.path.join("./out", sanitize_dir_name(OBJECTIVE) + "_" + current_datetime) make_dir(path) # Save llama index. index.storage_context.persist(persist_dir=os.path.join(path, "index.json")) # Save program state. state = { "summaries": summaries, "reload_count": reload_count, "task_id_counter": task_id_counter, "task_list": list(task_list), "completed_tasks": completed_tasks, "cache": dict(cache), "current_datetime": current_datetime, "objective": OBJECTIVE, } with open(os.path.join(path, "state.json"), "w") as outfile: json.dump(state, outfile) # Save results. if "key_results" in doc_store: if reload_count: new_time = str(time.strftime("%Y-%m-%d_%H-%M-%S")) header = f"# {OBJECTIVE}\nDate: {new_time}\n\n" else: header = f"# {OBJECTIVE}\nDate: {current_datetime}\n\n" key_findings_path = os.path.join(path, f"key_findings_{reload_count}.md") write_file(key_findings_path, header, mode="a+") for res in doc_store["key_results"]: content = f"{res[0]}{res[1]}" write_file(key_findings_path, content, mode="a+") for task, doc in doc_store["tasks"].items(): doc_path = os.path.join(path, task) make_dir(doc_path) result_path = os.path.join(doc_path, "results") make_dir(result_path) if "executive_summary" in doc: write_file(os.path.join(result_path, "executive_summary.txt"), doc["executive_summary"]) if "result_code" in doc: write_file(os.path.join(result_path, "api_call.txt"), doc["result_code"]) for i, result in enumerate(doc["results"]): result_path_i = os.path.join(result_path, str(i)) make_dir(result_path_i) write_file(os.path.join(result_path_i, "output.txt"), result["output"]) write_file( os.path.join(result_path_i, "vector.txt"), str(result["vectorized_data"]), ) def load(path): llm_predictor = LLMPredictor( llm=ChatOpenAI( temperature=0, openai_api_key=api_key, model_name="gpt-3.5-turbo-16k", max_tokens=6000, ) ) service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, chunk_size=4000) # rebuild storage context storage_context = StorageContext.from_defaults(persist_dir=os.path.join(path, "index.json")) index = load_index_from_storage(storage_context=storage_context, service_context=service_context) state_path = os.path.join(path, "state.json") if os.path.exists(state_path): with open(state_path, "r") as f: json_data = json.load(f) try: reload_count = json_data["reload_count"] + 1 task_id_counter = json_data["task_id_counter"] task_list = json_data["task_list"] completed_tasks = json_data["completed_tasks"] cache = defaultdict(list, json_data["cache"]) current_datetime = json_data["current_datetime"] objective = json_data["objective"] summaries = json_data["summaries"] except KeyError as e: raise Exception( f"Missing key '{e.args[0]}' in JSON file at path '{state_path}'" ) return ( index, task_id_counter, deque(task_list), completed_tasks, cache, current_datetime, objective, reload_count, summaries, )

[((3024, 3060), 'tiktoken.get_encoding', 'tiktoken.get_encoding', (['encoding_name'], {}), '(encoding_name)\n', (3045, 3060), False, 'import tiktoken\n'), ((14555, 14629), 'llama_index.Document', 'Document', ([], {'text': 'data', 'embedding': 'embedding', 'doc_id': 'doc_id', 'metadata': 'metadata'}), '(text=data, embedding=embedding, doc_id=doc_id, metadata=metadata)\n', (14563, 14629), False, 'from llama_index import Document, GPTVectorStoreIndex, LLMPredictor, ServiceContext, GPTListIndex\n'), ((18745, 18802), 'llama_index.retrievers.VectorIndexRetriever', 'VectorIndexRetriever', ([], {'index': 'index', 'similarity_top_k': 'top_k'}), '(index=index, similarity_top_k=top_k)\n', (18765, 18802), False, 'from llama_index.retrievers import VectorIndexRetriever\n'), ((18892, 18953), 'llama_index.ResponseSynthesizer.from_args', 'ResponseSynthesizer.from_args', ([], {'response_mode': '"""tree_summarize"""'}), "(response_mode='tree_summarize')\n", (18921, 18953), False, 'from llama_index import VectorStoreIndex, ResponseSynthesizer\n'), ((19017, 19106), 'llama_index.query_engine.RetrieverQueryEngine', 'RetrieverQueryEngine', ([], {'retriever': 'retriever', 'response_synthesizer': 'response_synthesizer'}), '(retriever=retriever, response_synthesizer=\n response_synthesizer)\n', (19037, 19106), False, 'from llama_index.query_engine import RetrieverQueryEngine\n'), ((20428, 20502), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'chunk_size': '(4000)'}), '(llm_predictor=llm_predictor, chunk_size=4000)\n', (20456, 20502), False, 'from llama_index import StorageContext, load_index_from_storage, ServiceContext\n'), ((20514, 20577), 'llama_index.GPTVectorStoreIndex', 'GPTVectorStoreIndex', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (20533, 20577), False, 'from llama_index import Document, GPTVectorStoreIndex, LLMPredictor, ServiceContext, GPTListIndex\n'), ((20944, 21001), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor'}), '(llm_predictor=llm_predictor)\n', (20972, 21001), False, 'from llama_index import StorageContext, load_index_from_storage, ServiceContext\n'), ((21016, 21133), 'llama_index.indices.composability.ComposableGraph.from_indices', 'ComposableGraph.from_indices', (['GPTListIndex', 'indicies'], {'index_summaries': 'summaries', 'service_context': 'service_context'}), '(GPTListIndex, indicies, index_summaries=\n summaries, service_context=service_context)\n', (21044, 21133), False, 'from llama_index.indices.composability import ComposableGraph\n'), ((21537, 21594), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor'}), '(llm_predictor=llm_predictor)\n', (21565, 21594), False, 'from llama_index import StorageContext, load_index_from_storage, ServiceContext\n'), ((21743, 21814), 'llama_index.GPTListIndex.from_documents', 'GPTListIndex.from_documents', (['documents'], {'service_context': 'service_context'}), '(documents, service_context=service_context)\n', (21770, 21814), False, 'from llama_index import Document, GPTVectorStoreIndex, LLMPredictor, ServiceContext, GPTListIndex\n'), ((21861, 21896), 'functools.partial', 'partial', (['backoff.expo'], {'max_value': '(50)'}), '(backoff.expo, max_value=50)\n', (21868, 21896), False, 'from functools import partial\n'), ((22854, 23020), 'openai.ChatCompletion.create', 'openai.ChatCompletion.create', ([], {'model': 'model', 'messages': "[{'role': 'system', 'content': system_prompt}, {'role': 'user', 'content':\n user_prompt}]", 'temperature': 'temp'}), "(model=model, messages=[{'role': 'system',\n 'content': system_prompt}, {'role': 'user', 'content': user_prompt}],\n temperature=temp)\n", (22882, 23020), False, 'import openai\n'), ((22549, 22584), 'functools.partial', 'partial', (['backoff.expo'], {'max_value': '(50)'}), '(backoff.expo, max_value=50)\n', (22556, 22584), False, 'from functools import partial\n'), ((23607, 23644), 're.sub', 're.sub', (['"""[<>:"/\\\\|?*]"""', '"""_"""', 'dir_name'], {}), '(\'[<>:"/\\\\|?*]\', \'_\', dir_name)\n', (23613, 23644), False, 'import re\n'), ((26372, 26446), 'llama_index.ServiceContext.from_defaults', 'ServiceContext.from_defaults', ([], {'llm_predictor': 'llm_predictor', 'chunk_size': '(4000)'}), '(llm_predictor=llm_predictor, chunk_size=4000)\n', (26400, 26446), False, 'from llama_index import StorageContext, load_index_from_storage, ServiceContext\n'), ((26588, 26682), 'llama_index.load_index_from_storage', 'load_index_from_storage', ([], {'storage_context': 'storage_context', 'service_context': 'service_context'}), '(storage_context=storage_context, service_context=\n service_context)\n', (26611, 26682), False, 'from llama_index import StorageContext, load_index_from_storage, ServiceContext\n'), ((26695, 26727), 'os.path.join', 'os.path.join', (['path', '"""state.json"""'], {}), "(path, 'state.json')\n", (26707, 26727), False, 'import os\n'), ((26735, 26761), 'os.path.exists', 'os.path.exists', (['state_path'], {}), '(state_path)\n', (26749, 26761), False, 'import os\n'), ((935, 967), 'logging.getLogger', 'logging.getLogger', (['"""llama_index"""'], {}), "('llama_index')\n", (952, 967), False, 'import logging\n'), ((2855, 2871), 'collections.deque', 'deque', (['task_list'], {}), '(task_list)\n', (2860, 2871), False, 'from collections import defaultdict, deque\n'), ((10387, 10408), 'xml.etree.ElementTree.fromstring', 'ET.fromstring', (['result'], {}), '(result)\n', (10400, 10408), True, 'import xml.etree.ElementTree as ET\n'), ((23194, 23214), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (23208, 23214), False, 'import os\n'), ((23224, 23241), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (23235, 23241), False, 'import os\n'), ((24651, 24676), 'json.dump', 'json.dump', (['state', 'outfile'], {}), '(state, outfile)\n', (24660, 24676), False, 'import json\n'), ((24991, 25044), 'os.path.join', 'os.path.join', (['path', 'f"""key_findings_{reload_count}.md"""'], {}), "(path, f'key_findings_{reload_count}.md')\n", (25003, 25044), False, 'import os\n'), ((25334, 25358), 'os.path.join', 'os.path.join', (['path', 'task'], {}), '(path, task)\n', (25346, 25358), False, 'import os\n'), ((25408, 25441), 'os.path.join', 'os.path.join', (['doc_path', '"""results"""'], {}), "(doc_path, 'results')\n", (25420, 25441), False, 'import os\n'), ((27558, 27574), 'collections.deque', 'deque', (['task_list'], {}), '(task_list)\n', (27563, 27574), False, 'from collections import defaultdict, deque\n'), ((4361, 4383), 'markdown.markdown', 'markdown.markdown', (['res'], {}), '(res)\n', (4378, 4383), False, 'import markdown\n'), ((4411, 4443), 'markdown.markdown', 'markdown.markdown', (['citation_data'], {}), '(citation_data)\n', (4428, 4443), False, 'import markdown\n'), ((19965, 20075), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': 'temperature', 'openai_api_key': 'api_key', 'model_name': 'model_name', 'max_tokens': 'max_tokens'}), '(temperature=temperature, openai_api_key=api_key, model_name=\n model_name, max_tokens=max_tokens)\n', (19975, 20075), False, 'from langchain.chat_models import ChatOpenAI\n'), ((20751, 20857), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': 'temperature', 'openai_api_key': 'api_key', 'model_name': 'model_name', 'max_tokens': 'max_tokens'}), '(temperature=temperature, openai_api_key=api_key, model_name=\n model_name, max_tokens=max_tokens)\n', (20757, 20857), False, 'from langchain import OpenAI\n'), ((21344, 21450), 'langchain.OpenAI', 'OpenAI', ([], {'temperature': 'temperature', 'openai_api_key': 'api_key', 'model_name': 'model_name', 'max_tokens': 'max_tokens'}), '(temperature=temperature, openai_api_key=api_key, model_name=\n model_name, max_tokens=max_tokens)\n', (21350, 21450), False, 'from langchain import OpenAI\n'), ((24193, 24225), 'os.path.join', 'os.path.join', (['path', '"""index.json"""'], {}), "(path, 'index.json')\n", (24205, 24225), False, 'import os\n'), ((24592, 24624), 'os.path.join', 'os.path.join', (['path', '"""state.json"""'], {}), "(path, 'state.json')\n", (24604, 24624), False, 'import os\n'), ((26186, 26289), 'langchain.chat_models.ChatOpenAI', 'ChatOpenAI', ([], {'temperature': '(0)', 'openai_api_key': 'api_key', 'model_name': '"""gpt-3.5-turbo-16k"""', 'max_tokens': '(6000)'}), "(temperature=0, openai_api_key=api_key, model_name=\n 'gpt-3.5-turbo-16k', max_tokens=6000)\n", (26196, 26289), False, 'from langchain.chat_models import ChatOpenAI\n'), ((26541, 26573), 'os.path.join', 'os.path.join', (['path', '"""index.json"""'], {}), "(path, 'index.json')\n", (26553, 26573), False, 'import os\n'), ((26828, 26840), 'json.load', 'json.load', (['f'], {}), '(f)\n', (26837, 26840), False, 'import json\n'), ((14291, 14360), 'openai.Embedding.create', 'openai.Embedding.create', ([], {'input': '[text]', 'model': '"""text-embedding-ada-002"""'}), "(input=[text], model='text-embedding-ada-002')\n", (14314, 14360), False, 'import openai\n'), ((24785, 24819), 'time.strftime', 'time.strftime', (['"""%Y-%m-%d_%H-%M-%S"""'], {}), "('%Y-%m-%d_%H-%M-%S')\n", (24798, 24819), False, 'import time\n'), ((25535, 25585), 'os.path.join', 'os.path.join', (['result_path', '"""executive_summary.txt"""'], {}), "(result_path, 'executive_summary.txt')\n", (25547, 25585), False, 'import os\n'), ((25669, 25710), 'os.path.join', 'os.path.join', (['result_path', '"""api_call.txt"""'], {}), "(result_path, 'api_call.txt')\n", (25681, 25710), False, 'import os\n'), ((25916, 25957), 'os.path.join', 'os.path.join', (['result_path_i', '"""output.txt"""'], {}), "(result_path_i, 'output.txt')\n", (25928, 25957), False, 'import os\n'), ((26017, 26058), 'os.path.join', 'os.path.join', (['result_path_i', '"""vector.txt"""'], {}), "(result_path_i, 'vector.txt')\n", (26029, 26058), False, 'import os\n'), ((27121, 27158), 'collections.defaultdict', 'defaultdict', (['list', "json_data['cache']"], {}), "(list, json_data['cache'])\n", (27132, 27158), False, 'from collections import defaultdict, deque\n'), ((12834, 12933), 'openai.Completion.create', 'openai.Completion.create', ([], {'engine': '"""text-davinci-003"""', 'prompt': 'validation_prompt', 'temperature': '(0.0)'}), "(engine='text-davinci-003', prompt=\n validation_prompt, temperature=0.0)\n", (12858, 12933), False, 'import openai\n')]

"""Global eval handlers.""" from typing import Any from llama_index.legacy.callbacks.argilla_callback import argilla_callback_handler from llama_index.legacy.callbacks.arize_phoenix_callback import ( arize_phoenix_callback_handler, ) from llama_index.legacy.callbacks.base_handler import BaseCallbackHandler from llama_index.legacy.callbacks.deepeval_callback import deepeval_callback_handler from llama_index.legacy.callbacks.honeyhive_callback import honeyhive_callback_handler from llama_index.legacy.callbacks.open_inference_callback import ( OpenInferenceCallbackHandler, ) from llama_index.legacy.callbacks.promptlayer_handler import PromptLayerHandler from llama_index.legacy.callbacks.simple_llm_handler import SimpleLLMHandler from llama_index.legacy.callbacks.wandb_callback import WandbCallbackHandler def set_global_handler(eval_mode: str, **eval_params: Any) -> None: """Set global eval handlers.""" import llama_index.legacy llama_index.legacy.global_handler = create_global_handler(eval_mode, **eval_params) def create_global_handler(eval_mode: str, **eval_params: Any) -> BaseCallbackHandler: """Get global eval handler.""" if eval_mode == "wandb": handler: BaseCallbackHandler = WandbCallbackHandler(**eval_params) elif eval_mode == "openinference": handler = OpenInferenceCallbackHandler(**eval_params) elif eval_mode == "arize_phoenix": handler = arize_phoenix_callback_handler(**eval_params) elif eval_mode == "honeyhive": handler = honeyhive_callback_handler(**eval_params) elif eval_mode == "promptlayer": handler = PromptLayerHandler(**eval_params) elif eval_mode == "deepeval": handler = deepeval_callback_handler(**eval_params) elif eval_mode == "simple": handler = SimpleLLMHandler(**eval_params) elif eval_mode == "argilla": handler = argilla_callback_handler(**eval_params) else: raise ValueError(f"Eval mode {eval_mode} not supported.") return handler

[((1239, 1274), 'llama_index.legacy.callbacks.wandb_callback.WandbCallbackHandler', 'WandbCallbackHandler', ([], {}), '(**eval_params)\n', (1259, 1274), False, 'from llama_index.legacy.callbacks.wandb_callback import WandbCallbackHandler\n'), ((1332, 1375), 'llama_index.legacy.callbacks.open_inference_callback.OpenInferenceCallbackHandler', 'OpenInferenceCallbackHandler', ([], {}), '(**eval_params)\n', (1360, 1375), False, 'from llama_index.legacy.callbacks.open_inference_callback import OpenInferenceCallbackHandler\n'), ((1433, 1478), 'llama_index.legacy.callbacks.arize_phoenix_callback.arize_phoenix_callback_handler', 'arize_phoenix_callback_handler', ([], {}), '(**eval_params)\n', (1463, 1478), False, 'from llama_index.legacy.callbacks.arize_phoenix_callback import arize_phoenix_callback_handler\n'), ((1532, 1573), 'llama_index.legacy.callbacks.honeyhive_callback.honeyhive_callback_handler', 'honeyhive_callback_handler', ([], {}), '(**eval_params)\n', (1558, 1573), False, 'from llama_index.legacy.callbacks.honeyhive_callback import honeyhive_callback_handler\n'), ((1629, 1662), 'llama_index.legacy.callbacks.promptlayer_handler.PromptLayerHandler', 'PromptLayerHandler', ([], {}), '(**eval_params)\n', (1647, 1662), False, 'from llama_index.legacy.callbacks.promptlayer_handler import PromptLayerHandler\n'), ((1715, 1755), 'llama_index.legacy.callbacks.deepeval_callback.deepeval_callback_handler', 'deepeval_callback_handler', ([], {}), '(**eval_params)\n', (1740, 1755), False, 'from llama_index.legacy.callbacks.deepeval_callback import deepeval_callback_handler\n'), ((1806, 1837), 'llama_index.legacy.callbacks.simple_llm_handler.SimpleLLMHandler', 'SimpleLLMHandler', ([], {}), '(**eval_params)\n', (1822, 1837), False, 'from llama_index.legacy.callbacks.simple_llm_handler import SimpleLLMHandler\n'), ((1889, 1928), 'llama_index.legacy.callbacks.argilla_callback.argilla_callback_handler', 'argilla_callback_handler', ([], {}), '(**eval_params)\n', (1913, 1928), False, 'from llama_index.legacy.callbacks.argilla_callback import argilla_callback_handler\n')]

"""Global eval handlers.""" from typing import Any from llama_index.legacy.callbacks.argilla_callback import argilla_callback_handler from llama_index.legacy.callbacks.arize_phoenix_callback import ( arize_phoenix_callback_handler, ) from llama_index.legacy.callbacks.base_handler import BaseCallbackHandler from llama_index.legacy.callbacks.deepeval_callback import deepeval_callback_handler from llama_index.legacy.callbacks.honeyhive_callback import honeyhive_callback_handler from llama_index.legacy.callbacks.open_inference_callback import ( OpenInferenceCallbackHandler, ) from llama_index.legacy.callbacks.promptlayer_handler import PromptLayerHandler from llama_index.legacy.callbacks.simple_llm_handler import SimpleLLMHandler from llama_index.legacy.callbacks.wandb_callback import WandbCallbackHandler def set_global_handler(eval_mode: str, **eval_params: Any) -> None: """Set global eval handlers.""" import llama_index.legacy llama_index.legacy.global_handler = create_global_handler(eval_mode, **eval_params) def create_global_handler(eval_mode: str, **eval_params: Any) -> BaseCallbackHandler: """Get global eval handler.""" if eval_mode == "wandb": handler: BaseCallbackHandler = WandbCallbackHandler(**eval_params) elif eval_mode == "openinference": handler = OpenInferenceCallbackHandler(**eval_params) elif eval_mode == "arize_phoenix": handler = arize_phoenix_callback_handler(**eval_params) elif eval_mode == "honeyhive": handler = honeyhive_callback_handler(**eval_params) elif eval_mode == "promptlayer": handler = PromptLayerHandler(**eval_params) elif eval_mode == "deepeval": handler = deepeval_callback_handler(**eval_params) elif eval_mode == "simple": handler = SimpleLLMHandler(**eval_params) elif eval_mode == "argilla": handler = argilla_callback_handler(**eval_params) else: raise ValueError(f"Eval mode {eval_mode} not supported.") return handler

[((1239, 1274), 'llama_index.legacy.callbacks.wandb_callback.WandbCallbackHandler', 'WandbCallbackHandler', ([], {}), '(**eval_params)\n', (1259, 1274), False, 'from llama_index.legacy.callbacks.wandb_callback import WandbCallbackHandler\n'), ((1332, 1375), 'llama_index.legacy.callbacks.open_inference_callback.OpenInferenceCallbackHandler', 'OpenInferenceCallbackHandler', ([], {}), '(**eval_params)\n', (1360, 1375), False, 'from llama_index.legacy.callbacks.open_inference_callback import OpenInferenceCallbackHandler\n'), ((1433, 1478), 'llama_index.legacy.callbacks.arize_phoenix_callback.arize_phoenix_callback_handler', 'arize_phoenix_callback_handler', ([], {}), '(**eval_params)\n', (1463, 1478), False, 'from llama_index.legacy.callbacks.arize_phoenix_callback import arize_phoenix_callback_handler\n'), ((1532, 1573), 'llama_index.legacy.callbacks.honeyhive_callback.honeyhive_callback_handler', 'honeyhive_callback_handler', ([], {}), '(**eval_params)\n', (1558, 1573), False, 'from llama_index.legacy.callbacks.honeyhive_callback import honeyhive_callback_handler\n'), ((1629, 1662), 'llama_index.legacy.callbacks.promptlayer_handler.PromptLayerHandler', 'PromptLayerHandler', ([], {}), '(**eval_params)\n', (1647, 1662), False, 'from llama_index.legacy.callbacks.promptlayer_handler import PromptLayerHandler\n'), ((1715, 1755), 'llama_index.legacy.callbacks.deepeval_callback.deepeval_callback_handler', 'deepeval_callback_handler', ([], {}), '(**eval_params)\n', (1740, 1755), False, 'from llama_index.legacy.callbacks.deepeval_callback import deepeval_callback_handler\n'), ((1806, 1837), 'llama_index.legacy.callbacks.simple_llm_handler.SimpleLLMHandler', 'SimpleLLMHandler', ([], {}), '(**eval_params)\n', (1822, 1837), False, 'from llama_index.legacy.callbacks.simple_llm_handler import SimpleLLMHandler\n'), ((1889, 1928), 'llama_index.legacy.callbacks.argilla_callback.argilla_callback_handler', 'argilla_callback_handler', ([], {}), '(**eval_params)\n', (1913, 1928), False, 'from llama_index.legacy.callbacks.argilla_callback import argilla_callback_handler\n')]

import sys from langchain import OpenAI from pathlib import Path import llama_index as li #from llamahub.connectors import TextFileConnector from llama_index import SimpleDirectoryReader,GPTListIndex,LLMPredictor file_name = sys.argv[1] llm_predictor = LLMPredictor(llm=OpenAI(model_name="gpt-3.5-turbo")) #temperature=0, docs = SimpleDirectoryReader('.', [file_name]).load_data() index = GPTListIndex(docs) ex = """Today we finish off our study of collaborative filtering by looking closely at embeddings—a critical building block of many deep learning algorithms. Then we’ll dive into convolutional neural networks (CNNs) and see how they really work. We’ve used plenty of CNNs through this course, but we haven’t peeked inside them to see what’s really going on in there. As well as learning about their most fundamental building block, the convolution, we’ll also look at pooling, dropout, and more.""" q = f"""Here's an example of a lesson summary from a previous fast.ai lesson: "{ex}" Write a four paragraph summary of the fast.ai lesson contained in the following transcript, using a similar informal writing style to the above summary from the previous lesson.""" summary = index.query(q, response_mode="tree_summarize", llm_predictor=llm_predictor) Path(f'{Path(file_name).stem}-summ.txt').write_text(str(summary))

[((391, 409), 'llama_index.GPTListIndex', 'GPTListIndex', (['docs'], {}), '(docs)\n', (403, 409), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, LLMPredictor\n'), ((271, 305), 'langchain.OpenAI', 'OpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""'}), "(model_name='gpt-3.5-turbo')\n", (277, 305), False, 'from langchain import OpenAI\n'), ((331, 370), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""."""', '[file_name]'], {}), "('.', [file_name])\n", (352, 370), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, LLMPredictor\n'), ((1270, 1285), 'pathlib.Path', 'Path', (['file_name'], {}), '(file_name)\n', (1274, 1285), False, 'from pathlib import Path\n')]

import sys from langchain import OpenAI from pathlib import Path import llama_index as li #from llamahub.connectors import TextFileConnector from llama_index import SimpleDirectoryReader,GPTListIndex,LLMPredictor file_name = sys.argv[1] llm_predictor = LLMPredictor(llm=OpenAI(model_name="gpt-3.5-turbo")) #temperature=0, docs = SimpleDirectoryReader('.', [file_name]).load_data() index = GPTListIndex(docs) ex = """Today we finish off our study of collaborative filtering by looking closely at embeddings—a critical building block of many deep learning algorithms. Then we’ll dive into convolutional neural networks (CNNs) and see how they really work. We’ve used plenty of CNNs through this course, but we haven’t peeked inside them to see what’s really going on in there. As well as learning about their most fundamental building block, the convolution, we’ll also look at pooling, dropout, and more.""" q = f"""Here's an example of a lesson summary from a previous fast.ai lesson: "{ex}" Write a four paragraph summary of the fast.ai lesson contained in the following transcript, using a similar informal writing style to the above summary from the previous lesson.""" summary = index.query(q, response_mode="tree_summarize", llm_predictor=llm_predictor) Path(f'{Path(file_name).stem}-summ.txt').write_text(str(summary))

[((391, 409), 'llama_index.GPTListIndex', 'GPTListIndex', (['docs'], {}), '(docs)\n', (403, 409), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, LLMPredictor\n'), ((271, 305), 'langchain.OpenAI', 'OpenAI', ([], {'model_name': '"""gpt-3.5-turbo"""'}), "(model_name='gpt-3.5-turbo')\n", (277, 305), False, 'from langchain import OpenAI\n'), ((331, 370), 'llama_index.SimpleDirectoryReader', 'SimpleDirectoryReader', (['"""."""', '[file_name]'], {}), "('.', [file_name])\n", (352, 370), False, 'from llama_index import SimpleDirectoryReader, GPTListIndex, LLMPredictor\n'), ((1270, 1285), 'pathlib.Path', 'Path', (['file_name'], {}), '(file_name)\n', (1274, 1285), False, 'from pathlib import Path\n')]