mlk8s v 0.0.1

.gitignore

@@ -0,0 +1,2 @@
+.env
+__pycache__

app.py

@@ -1,4 +1,299 @@
 import streamlit as st
 
-x = st.slider('Select a value')
-st.write(x, 'squared is', x*x)
+import os
+import re
+import sys
+import logging
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+from dotenv import load_dotenv
+load_dotenv()
+
+for key in st.session_state.keys():
+    #del st.session_state[key]
+    print(f'session state entry: {key} {st.session_state[key]}')
+
+__spaces__ = os.environ.get('__SPACES__')
+
+if __spaces__:
+    from kron.persistence.dynamodb_request_log import get_request_log;
+    st.session_state.request_log = get_request_log()
+
+#third party service access
+#hf inference api
+hf_api_key = os.environ['HF_TOKEN']
+ch_api_key = os.environ['COHERE_TOKEN']
+bs_api_key = os.environ['BASETEN_TOKEN']
+
+index_model = "Writer/camel-5b-hf"
+INDEX_NAME = f"{index_model.replace('/', '-')}-default-no-coref"
+persist_path = f"storage/{INDEX_NAME}"
+MAX_LENGTH = 1024
+
+import baseten
+@st.cache_resource
+def set_baseten_key(bs_api_key):
+    baseten.login(bs_api_key)
+
+set_baseten_key(bs_api_key)
+
+from llama_index import StorageContext
+from llama_index import ServiceContext
+from llama_index import load_index_from_storage 
+from llama_index.langchain_helpers.text_splitter import SentenceSplitter
+from llama_index.node_parser import SimpleNodeParser
+from llama_index import LLMPredictor
+
+from langchain import HuggingFaceHub
+from langchain.llms.cohere import Cohere
+from langchain.llms import Baseten
+
+import tiktoken
+
+import openai
+#extensions to llama_index to support openai compatible endpoints, e.g. llama-api
+from kron.llm_predictor.KronOpenAILLM import KronOpenAI
+#baseten deployment expects a specific request format
+from kron.llm_predictor.KronBasetenCamelLLM import KronBasetenCamelLLM
+from kron.llm_predictor.KronLLMPredictor import KronLLMPredictor
+
+#writer/camel uses endoftext 
+from llama_index.utils import globals_helper
+enc = tiktoken.get_encoding("gpt2")
+tokenizer = lambda text: enc.encode(text, allowed_special={"<|endoftext|>"})
+globals_helper._tokenizer = tokenizer
+
+
+def set_openai_local():
+    openai.api_key = os.environ['LOCAL_OPENAI_API_KEY']
+    openai.api_base = os.environ['LOCAL_OPENAI_API_BASE']
+    os.environ['OPENAI_API_KEY'] = os.environ['LOCAL_OPENAI_API_KEY']
+    os.environ['OPENAI_API_BASE'] = os.environ['LOCAL_OPENAI_API_BASE']
+
+def set_openai():
+    openai.api_key = os.environ['DAVINCI_OPENAI_API_KEY']
+    openai.api_base = os.environ['DAVINCI_OPENAI_API_BASE']
+    os.environ['OPENAI_API_KEY'] = os.environ['DAVINCI_OPENAI_API_KEY']
+    os.environ['OPENAI_API_BASE'] = os.environ['DAVINCI_OPENAI_API_BASE']
+
+def get_hf_predictor(query_model):
+    # no embeddings for now
+    set_openai_local()
+    llm=HuggingFaceHub(repo_id=query_model, task="text-generation", 
+                       model_kwargs={"temperature": 0.01, "max_length": MAX_LENGTH}, 
+                       huggingfacehub_api_token=hf_api_key)
+    llm_predictor = LLMPredictor(llm)
+    return llm_predictor
+
+def get_cohere_predictor(query_model):
+    # no embeddings for now
+    set_openai_local()
+    llm=Cohere(model='command', temperature = 0.01,
+#                       model_kwargs={"temperature": 0.01, "max_length": MAX_LENGTH}, 
+                       cohere_api_key=ch_api_key)
+    llm_predictor = LLMPredictor(llm)
+    return llm_predictor
+
+def get_baseten_predictor(query_model):
+    # no embeddings for now
+    set_openai_local()
+    llm=KronBasetenCamelLLM(model='3yd1ke3', temperature = 0.01,
+#                       model_kwargs={"temperature": 0.01, "max_length": MAX_LENGTH, 'repetition_penalty':1.07}, 
+                       model_kwargs={"temperature": 0.01, "max_length": MAX_LENGTH, 'frequency_penalty':1}, 
+                       cohere_api_key=ch_api_key)
+    llm_predictor = LLMPredictor(llm)
+    return llm_predictor
+
+def get_kron_openai_predictor(query_model): 
+    # define LLM
+    llm=KronOpenAI(temperature=0.01, model=query_model)
+    llm.max_tokens = MAX_LENGTH 
+    llm_predictor = KronLLMPredictor(llm)
+    return llm_predictor
+
+def get_servce_context(llm_predictor):
+    # define TextSplitter
+    text_splitter = SentenceSplitter(chunk_size=192, chunk_overlap=48, paragraph_separator='\n')
+    #define NodeParser
+    node_parser = SimpleNodeParser(text_splitter=text_splitter)
+    #define ServiceContext
+    service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, node_parser=node_parser)
+    return service_context
+
+def get_index(service_context, persist_path):
+    print(f'Loading index from {persist_path}')
+    # rebuild storage context
+    storage_context = StorageContext.from_defaults(persist_dir=persist_path)
+    # load index
+    index = load_index_from_storage(storage_context=storage_context, 
+                                    service_context=service_context, 
+                                    max_triplets_per_chunk=2,
+                                    show_progress = False)
+    return index
+
+def get_query_engine(index):
+    #writer/camel does not understand the refine prompt
+    RESPONSE_MODE = 'accumulate'
+    query_engine = index.as_query_engine(response_mode = RESPONSE_MODE)
+    return query_engine
+
+def load_query_engine(llm_predictor, persist_path):
+    service_context = get_servce_context(llm_predictor)
+    index = get_index(service_context, persist_path)
+    print(f'No query engine for {persist_path}; creating')
+    query_engine = get_query_engine(index)
+    return query_engine
+
+@st.cache_resource
+def build_kron_query_engine(query_model, persist_path):
+    llm_predictor = get_kron_openai_predictor(query_model)    
+    query_engine = load_query_engine(llm_predictor, persist_path)
+    return query_engine
+
+@st.cache_resource
+def build_hf_query_engine(query_model, persist_path):
+    llm_predictor = get_hf_predictor(query_model)    
+    query_engine = load_query_engine(llm_predictor, persist_path)
+    return query_engine
+
+@st.cache_resource
+def build_cohere_query_engine(query_model, persist_path):
+    llm_predictor = get_cohere_predictor(query_model)    
+    query_engine = load_query_engine(llm_predictor, persist_path)
+    return query_engine
+
+@st.cache_resource
+def build_baseten_query_engine(query_model, persist_path):
+    llm_predictor = get_baseten_predictor(query_model)    
+    query_engine = load_query_engine(llm_predictor, persist_path)
+    return query_engine
+
+def format_response(answer):
+    # Replace any eventual --
+    dashes = r'(\-{2,50})'
+    answer.response = re.sub(dashes, '', answer.response)
+    return answer.response or "None"
+
+def clear_question(query_model):
+    if not ('prev_model' in st.session_state) or (('prev_model' in st.session_state) and (st.session_state.prev_model != query_model)) :
+        if 'prev_model' in st.session_state:
+            print(f'clearing question {st.session_state.prev_model} {query_model}')
+        else:
+            print(f'clearing question None {query_model}')
+        if('question_input' in st.session_state):
+            st.session_state.question = st.session_state.question_input
+        st.session_state.question_input = ''
+        st.session_state.question_answered = False
+        st.session_state.answer = ''
+        st.session_state.prev_model = query_model
+
+
+initial_query = ''
+#st.session_state.prev_model = None
+
+if 'question' not in st.session_state:
+    st.session_state.question = ''
+
+if __spaces__ :
+    answer_model = st.radio(
+        "Choose the model used for inference:",
+        ('baseten/Camel-5b', 'cohere/command','hf/tiiuae/falcon-7b-instruct', 'openai/text-davinci-003') #TODO start hf inference container on demand
+#        ('cohere/command','hf/tiiuae/falcon-7b-instruct', 'openai/text-davinci-003')
+    )
+else :    
+    answer_model = st.radio(
+        "Choose the model used for inference:",
+        ('Local-Camel', 'HF-TKI', 'hf/tiiuae/falcon-7b-instruct', 'openai/text-davinci-003')
+    )
+
+if answer_model == 'openai/text-davinci-003':
+    print(answer_model)
+    query_model = 'text-davinci-003'
+    clear_question(query_model)
+    set_openai()
+    query_engine = build_kron_query_engine(query_model, persist_path)
+elif answer_model == 'hf/tiiuae/falcon-7b-instruct':
+    print(answer_model)
+    query_model = 'tiiuae/falcon-7b-instruct'
+    clear_question(query_model)
+    query_engine = build_hf_query_engine(query_model, persist_path) 
+elif answer_model == 'cohere/command':
+    print(answer_model)
+    query_model = 'cohere/command'
+    clear_question(query_model)
+    query_engine = build_cohere_query_engine(query_model, persist_path)         
+elif answer_model == 'baseten/Camel-5b':   
+    print(answer_model)    
+    query_model = 'baseten/Camel-5b'
+    clear_question(query_model)
+    query_engine = build_baseten_query_engine(query_model, persist_path)
+elif answer_model == 'Local-Camel':
+    query_model = 'Writer/camel-5b-hf'
+    print(answer_model)
+    clear_question(query_model)
+    set_openai_local()
+    query_engine = build_kron_query_engine(query_model, persist_path)
+elif answer_model == 'HF-TKI':    
+    query_model = 'allenai/tk-instruct-3b-def-pos-neg-expl'
+    clear_question(query_model)
+    query_engine = build_hf_query_engine(query_model, persist_path)
+else:
+    print('This is a bug.')
+
+# to clear input box
+def submit():
+    st.session_state.question = st.session_state.question_input
+    st.session_state.question_input = ''
+    st.session_state.question_answered = False
+
+#def submit_rating(query_model, req, resp):
+#    print(f'query model {query_model}')
+#    if 'answer_rating' in st.session_state:
+#        print(f'rating {st.session_state.answer_rating}')
+
+st.write(f'Model, question, answer and rating are logged to help with the improvement of this application.')
+question = st.text_input("Enter a question, e.g. What benchmarks can we use for QA?", key='question_input',  on_change=submit )
+ 
+# answer_str = None
+if(st.session_state.question):
+    col1, col2 = st.columns([2, 2])
+    with col1:
+        st.write(f'Answering: {st.session_state.question} with {query_model}.')
+    
+    try :
+        if not st.session_state.question_answered:
+            answer = query_engine.query(st.session_state.question)
+            st.session_state.answer = answer
+            st.session_state.question_answered = True
+        else:
+            answer = st.session_state.answer
+        answer_str = format_response(answer)
+        st.write(answer_str)
+        with col1:
+            if answer_str:
+                st.write(f' Please rate this answer.')
+        with col2:
+            from streamlit_star_rating import st_star_rating
+            stars = st_star_rating("", maxValue=5, defaultValue=3, key="answer_rating", 
+                               # customCSS = "div {background-color: red;}"
+                               # on_change = submit_rating(query_model, st.session_state.question, answer_str)
+                               )
+        print(f"------stars {stars}")
+    except Exception as e:
+        print(e)
+        answer_str = str(e)
+        st.session_state.answer_rating = -1
+    finally:
+        if 'question' in st.session_state:
+            req = st.session_state.question
+            #st.session_state.question = ''
+            if(__spaces__):
+                #request_log = get_request_log()
+                st.session_state.request_log.add_request_log_entry(query_model, req, answer_str, st.session_state.answer_rating)
+ 
+   # if "answer_rating" in st.session_state:
+   #     if(__spaces__):
+   #         print('time to log the rating')
+   #         #request_log = get_request_log()
+   #         st.session_state.request_log.add_request_log_entry(query_model, req, answer_str, st.session_state.answer_rating)

kron/indices/knowledge_graph/KronKnowledgeGraphIndex.py

@@ -0,0 +1,61 @@
+import logging
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from llama_index import KnowledgeGraphIndex 
+from llama_index.data_structs.data_structs import KG
+from llama_index.indices.service_context import ServiceContext
+from llama_index.prompts.prompts import KnowledgeGraphPrompt
+from llama_index.storage.storage_context import StorageContext
+from llama_index.schema import BaseNode
+
+class KronKnowledgeGraphIndex(KnowledgeGraphIndex):
+    def __init__(
+        self,
+        nodes: Optional[Sequence[BaseNode]] = None,
+        index_struct: Optional[KG] = None,
+        service_context: Optional[ServiceContext] = None,
+        storage_context: Optional[StorageContext] = None,
+        kg_triple_extract_template: Optional[KnowledgeGraphPrompt] = None,
+        max_triplets_per_chunk: int = 10,
+        include_embeddings: bool = False,
+        **kwargs: Any,
+    ) -> None:
+          super().__init__(
+                           nodes, 
+                           index_struct, 
+                           service_context, 
+                           storage_context, 
+                           kg_triple_extract_template, 
+                           max_triplets_per_chunk, 
+                           include_embeddings, 
+                           kwargs
+                        )
+          
+    def _extract_triplets(self, text: str) -> List[Tuple[str, str, str]]:
+        """Extract keywords from text."""
+        #response, _ = self._service_context.llm_predictor.predict(
+        response = self._service_context.llm_predictor.predict(
+            self.kg_triple_extract_template,
+            text=text,
+        )
+        return self._kron_parse_triplet_response(response)
+
+    @staticmethod
+    def _kron_parse_triplet_response(response: str) -> List[Tuple[str, str, str]]:
+        print("_kron_parse_triplet_response")
+        knowledge_strs = response.strip().split("\n")
+        results = []
+        for text in knowledge_strs:
+            text = text.strip()   #triples might not start at the begining of the line
+            #text = text.replace('<|endoftext|>', '')
+            #useful triplets are before <|endoftext|>
+            text = text.split("<|endoftext|>")[0]
+            if text == "" or text[0] != "(":
+                # skip empty lines and non-triplets
+                continue
+            tokens = text[1:-1].split(",")
+            if len(tokens) != 3:
+                continue
+            subj, pred, obj = tokens
+            results.append((subj.strip(), pred.strip(), obj.strip()))
+        return results

kron/llm_predictor/KronBasetenCamelLLM.py

@@ -0,0 +1,32 @@
+from typing import Any, Optional, List
+from langchain.callbacks.manager import CallbackManagerForLLMRun
+from langchain.llms import Baseten
+
+class KronBasetenCamelLLM(Baseten):
+    def _call(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        """Call to Baseten deployed model endpoint."""
+        try:
+            import baseten
+        except ImportError as exc:
+            raise ImportError(
+                "Could not import Baseten Python package. "
+                "Please install it with `pip install baseten`."
+            ) from exc
+
+        # get the model and version
+        try:
+            model = baseten.deployed_model_version_id(self.model)
+            response = model.predict({"instruction": prompt, **kwargs})
+        except baseten.common.core.ApiError:
+            model = baseten.deployed_model_id(self.model)
+            response = model.predict({"instruction": prompt, **kwargs})
+
+        response_txt = response['completion']
+        #print(f'\n********{response_txt}')
+        return response_txt

kron/llm_predictor/KronLLMPredictor.py

@@ -0,0 +1,39 @@
+
+from typing import Any, Generator, Optional, Protocol, Tuple, runtime_checkable
+
+from llama_index import  LLMPredictor
+from llama_index.llms.utils import LLMType
+from llama_index.callbacks.base import CallbackManager
+
+from kron.llm_predictor.utils import kron_resolve_llm
+
+class KronLLMPredictor(LLMPredictor):
+    """LLM predictor class.
+
+    Wrapper around an LLMChain from Langchain.
+
+    Args:
+        llm (Optional[langchain.llms.base.LLM]): LLM from Langchain to use
+            for predictions. Defaults to OpenAI's text-davinci-003 model.
+            Please see `Langchain's LLM Page
+            <https://langchain.readthedocs.io/en/latest/modules/llms.html>`_
+            for more details.
+
+        retry_on_throttling (bool): Whether to retry on rate limit errors.
+            Defaults to true.
+
+        cache (Optional[langchain.cache.BaseCache]) : use cached result for LLM
+    """
+
+    def __init__(
+        self,
+        llm: Optional[LLMType] = None,
+        callback_manager: Optional[CallbackManager] = None,
+     ) -> None:
+        """Initialize params."""
+        self._llm = kron_resolve_llm(llm)
+        self.callback_manager = callback_manager or CallbackManager([])
+
+
+
+

kron/llm_predictor/KronLangChainLLM.py

@@ -0,0 +1,35 @@
+from llama_index.bridge.langchain import BaseLanguageModel, BaseChatModel
+from llama_index.llms.langchain import LangChainLLM
+from llama_index.bridge.langchain import OpenAI, ChatOpenAI
+
+from llama_index.llms.base import LLMMetadata
+
+from kron.llm_predictor.openai_utils import kron_openai_modelname_to_contextsize
+
+def is_chat_model(llm: BaseLanguageModel) -> bool:
+    return isinstance(llm, BaseChatModel)
+
+class KronLangChainLLM(LangChainLLM):
+    """Adapter for a LangChain LLM."""
+
+    def __init__(self, llm: BaseLanguageModel) -> None:
+        super().__init__(llm)
+
+
+    @property
+    def metadata(self) -> LLMMetadata:
+        is_chat_model_ = is_chat_model(self.llm)
+        if isinstance(self.llm, OpenAI):
+            return LLMMetadata(
+                context_window=kron_openai_modelname_to_contextsize(self.llm.model_name),
+                num_output=self.llm.max_tokens,
+                is_chat_model=is_chat_model_ ,
+            )
+        elif isinstance(self.llm, ChatOpenAI):
+            return LLMMetadata(
+                context_window=kron_openai_modelname_to_contextsize(self.llm.model_name),
+                num_output=self.llm.max_tokens or -1,
+                is_chat_model=is_chat_model_ ,
+            )
+        else:
+            return super().metadata()

kron/llm_predictor/KronOpenAILLM.py

@@ -0,0 +1,39 @@
+from typing import Any, Awaitable, Callable, Dict, Optional, Sequence
+
+from llama_index.bridge.langchain import BaseLanguageModel, BaseChatModel
+from llama_index.llms.langchain import LangChainLLM
+from llama_index.llms.openai import OpenAI
+
+from llama_index.llms.base import (
+    LLM,
+    ChatMessage,
+    ChatResponse,
+    ChatResponseAsyncGen,
+    ChatResponseGen,
+    CompletionResponse,
+    CompletionResponseAsyncGen,
+    CompletionResponseGen,
+    LLMMetadata,
+)
+
+from kron.llm_predictor.openai_utils import kron_openai_modelname_to_contextsize
+
+class KronOpenAI(OpenAI):
+
+    @property
+    def metadata(self) -> LLMMetadata:
+        return LLMMetadata(
+            context_window=kron_openai_modelname_to_contextsize(self.model),
+            num_output=self.max_tokens or -1,
+            is_chat_model=self._is_chat_model,
+        )
+    
+    def complete(self, prompt: str, **kwargs: Any) -> CompletionResponse:
+        #print("KronOpenAI complete called")
+        response = super().complete(prompt, **kwargs)
+        text = response.text
+        text = text.strip()   #triples might not start at the begining of the line
+        #useful triplets are before <|endoftext|>
+        text = text.split("<|endoftext|>")[0]
+        response.text = text
+        return response

kron/llm_predictor/openai_utils.py

@@ -0,0 +1,115 @@
+LOCAL_MODELS = {
+    "Writer/camel-5b-hf": 2048,
+    "mosaicml/mpt-7b-instruct": 2048,
+    "mosaicml/mpt-30b-instruct": 8192,
+}
+
+GPT4_MODELS = {
+    # stable model names:
+    #   resolves to gpt-4-0314 before 2023-06-27,
+    #   resolves to gpt-4-0613 after
+    "gpt-4": 8192,
+    "gpt-4-32k": 32768,
+    # 0613 models (function calling):
+    #   https://openai.com/blog/function-calling-and-other-api-updates
+    "gpt-4-0613": 8192,
+    "gpt-4-32k-0613": 32768,
+    # 0314 models
+    "gpt-4-0314": 8192,
+    "gpt-4-32k-0314": 32768,
+}
+
+AZURE_TURBO_MODELS = {
+    "gpt-35-turbo-16k": 16384,
+    "gpt-35-turbo": 4096,
+}
+
+TURBO_MODELS = {
+    # stable model names:
+    #   resolves to gpt-3.5-turbo-0301 before 2023-06-27,
+    #   resolves to gpt-3.5-turbo-0613 after
+    "gpt-3.5-turbo": 4096,
+    # resolves to gpt-3.5-turbo-16k-0613
+    "gpt-3.5-turbo-16k": 16384,
+    # 0613 models (function calling):
+    #   https://openai.com/blog/function-calling-and-other-api-updates
+    "gpt-3.5-turbo-0613": 4096,
+    "gpt-3.5-turbo-16k-0613": 16384,
+    # 0301 models
+    "gpt-3.5-turbo-0301": 4096,
+}
+
+GPT3_5_MODELS = {
+    "text-davinci-003": 4097,
+    "text-davinci-002": 4097,
+}
+
+GPT3_MODELS = {
+    "text-ada-001": 2049,
+    "text-babbage-001": 2040,
+    "text-curie-001": 2049,
+    "ada": 2049,
+    "babbage": 2049,
+    "curie": 2049,
+    "davinci": 2049,
+}
+
+ALL_AVAILABLE_MODELS = {
+    **GPT4_MODELS,
+    **TURBO_MODELS,
+    **GPT3_5_MODELS,
+    **GPT3_MODELS,
+    **LOCAL_MODELS,
+}
+
+CHAT_MODELS = {
+    **GPT4_MODELS,
+    **TURBO_MODELS,
+    **AZURE_TURBO_MODELS,
+}
+
+
+DISCONTINUED_MODELS = {
+    "code-davinci-002": 8001,
+    "code-davinci-001": 8001,
+    "code-cushman-002": 2048,
+    "code-cushman-001": 2048,
+}
+
+
+def kron_openai_modelname_to_contextsize(modelname: str) -> int:
+    """Calculate the maximum number of tokens possible to generate for a model.
+
+    Args:
+        modelname: The modelname we want to know the context size for.
+
+    Returns:
+        The maximum context size
+
+    Example:
+        .. code-block:: python
+
+            max_tokens = openai.modelname_to_contextsize("text-davinci-003")
+
+    Modified from:
+        https://github.com/hwchase17/langchain/blob/master/langchain/llms/openai.py
+    """
+    # handling finetuned models
+    if "ft-" in modelname:
+        modelname = modelname.split(":")[0]
+
+    if modelname in DISCONTINUED_MODELS:
+        raise ValueError(
+            f"OpenAI model {modelname} has been discontinued. "
+            "Please choose another model."
+        )
+
+    context_size = ALL_AVAILABLE_MODELS.get(modelname, None)
+
+    if context_size is None:
+        raise ValueError(
+            f"Unknown model: {modelname}. Please provide a valid OpenAI model name."
+            "Known models are: " + ", ".join(ALL_AVAILABLE_MODELS.keys())
+        )
+
+    return context_size

kron/llm_predictor/utils.py

@@ -0,0 +1,16 @@
+from typing import Optional, Union
+from llama_index.llms.base import LLM
+from langchain.base_language import BaseLanguageModel
+
+from kron.llm_predictor.KronLangChainLLM import KronLangChainLLM
+from llama_index.llms.openai import OpenAI
+
+from llama_index.llms.utils import LLMType
+
+
+def kron_resolve_llm(llm: Optional[LLMType] = None) -> LLM:
+    if isinstance(llm, BaseLanguageModel):
+        # NOTE: if it's a langchain model, wrap it in a LangChainLLM
+        return KronLangChainLLM(llm=llm)
+
+    return llm or OpenAI()

kron/persistence/dynamodb_request_log.py

@@ -0,0 +1,132 @@
+#dynamodb access# 
+from datetime import datetime
+import boto3
+from botocore.exceptions import ClientError
+
+import logging
+logger = logging.getLogger(__name__)
+
+session = boto3.Session(
+#    aws_access_key_id=AWS_ACCESS_KEY_ID,
+#    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+)
+dynamodb = session.resource('dynamodb')
+
+class RequestLog:
+    """Encapsulates an Amazon DynamoDB table of request data."""
+    def __init__(self, dyn_resource):
+        """
+        :param dyn_resource: A Boto3 DynamoDB resource.
+        """
+        self.dyn_resource = dyn_resource
+        self.table = None
+
+    def exists(self, table_name):
+        """
+        Determines whether a table exists. As a side effect, stores the table in
+        a member variable.
+
+        :param table_name: The name of the table to check.
+        :return: True when the table exists; otherwise, False.
+        """
+        try:
+            table = self.dyn_resource.Table(table_name)
+            table.load()
+            exists = True
+        except ClientError as err:
+            if err.response['Error']['Code'] == 'ResourceNotFoundException':
+                exists = False
+            else:
+                logger.error(
+                    "Couldn't check for existence of %s. Here's why: %s: %s",
+                    table_name,
+                    err.response['Error']['Code'], err.response['Error']['Message'])
+                raise
+        else:
+            self.table = table
+        return exists
+    
+    def create_table(self, table_name):
+        """
+        Creates an Amazon DynamoDB table that can be used to store request data.
+        The table uses the release year of the movie as the partition key and the
+        title as the sort key.
+
+        :param table_name: The name of the table to create.
+        :return: The newly created table.
+        """
+        try:
+            self.table = self.dyn_resource.create_table(
+                TableName=table_name,
+                KeySchema=[
+                    {'AttributeName': 'model', 'KeyType': 'HASH'},  # Partition key
+                    {'AttributeName': 'timestamp', 'KeyType': 'RANGE'}  # Sort key
+                ],
+                AttributeDefinitions=[
+                    {'AttributeName': 'model', 'AttributeType': 'S'},
+                    {'AttributeName': 'timestamp', 'AttributeType': 'S'},
+ #                   {'AttributeName': 'request', 'AttributeType': 'S'},
+ #                   {'AttributeName': 'response', 'AttributeType': 'S'}
+                ],
+                ProvisionedThroughput={'ReadCapacityUnits': 10, 'WriteCapacityUnits': 10})
+            self.table.wait_until_exists()
+        except ClientError as err:
+            logger.error(
+                "Couldn't create table %s. Here's why: %s: %s", table_name,
+                err.response['Error']['Code'], err.response['Error']['Message'])
+            raise
+        else:
+            return self.table
+        
+    def log_request(self, req_timestamp_str, model, request_str, response_str, rating = 0):
+        """
+        Log a request to the table.
+
+        # TODO
+        :param title: The title of the movie.
+        :param year: The release year of the movie.
+        :param plot: The plot summary of the movie.
+        :param rating: The quality rating of the movie.
+        """
+        try:
+            self.table.put_item(
+                Item={
+                    'timestamp': req_timestamp_str,
+                    'model': model,
+                    'request': request_str,
+                    'response': response_str,
+                    'rating': rating,
+                }
+            )
+        except ClientError as err:
+            logger.error(
+                "Couldn't add request log %s to table %s. Here's why: %s: %s",
+                model, self.table.name,
+                err.response['Error']['Code'], err.response['Error']['Message'])
+            raise    
+    
+    def add_request_log_entry(self, query_model, req, resp, rating=0):
+        """
+            Logs the cuurent model, req and response
+        """
+        today = datetime.now()
+        # Get current ISO 8601 datetime in string format
+        iso_date = today.isoformat()        
+        self.log_request(iso_date, query_model, req, resp, rating)
+
+table_name = 'hf-spaces-request-log'
+
+def get_request_log():
+    request_log = RequestLog(dynamodb)
+    request_log_exists = request_log.exists(table_name)
+    if not request_log_exists:
+        print(f"\nCreating table {table_name}...")
+        request_log.create_table(table_name)
+        print(f"\nCreated table {request_log.table.name}.")
+    return request_log
+
+#def add_request_log_entry(request_log, query_model, req, resp, rating=0):
+#    today = datetime.now()
+#    # Get current ISO 8601 datetime in string format
+#    iso_date = today.isoformat()        
+#    request_log.log_request(iso_date, query_model, req, resp, rating)

kron/prompts/kg_prompts.py

@@ -0,0 +1,351 @@
+"""Set of default prompts."""
+
+from llama_index.prompts.base import Prompt
+from llama_index.prompts.prompt_type import PromptType
+
+############################################
+# Tree
+############################################
+
+DEFAULT_SUMMARY_PROMPT_TMPL = (
+    "Write a summary of the following. Try to use only the "
+    "information provided. "
+    "Try to include as many key details as possible.\n"
+    "\n"
+    "\n"
+    "{context_str}\n"
+    "\n"
+    "\n"
+    'SUMMARY:"""\n'
+)
+
+DEFAULT_SUMMARY_PROMPT = Prompt(
+    DEFAULT_SUMMARY_PROMPT_TMPL, prompt_type=PromptType.SUMMARY
+)
+
+# insert prompts
+DEFAULT_INSERT_PROMPT_TMPL = (
+    "Context information is below. It is provided in a numbered list "
+    "(1 to {num_chunks}),"
+    "where each item in the list corresponds to a summary.\n"
+    "---------------------\n"
+    "{context_list}"
+    "---------------------\n"
+    "Given the context information, here is a new piece of "
+    "information: {new_chunk_text}\n"
+    "Answer with the number corresponding to the summary that should be updated. "
+    "The answer should be the number corresponding to the "
+    "summary that is most relevant to the question.\n"
+)
+DEFAULT_INSERT_PROMPT = Prompt(
+    DEFAULT_INSERT_PROMPT_TMPL, prompt_type=PromptType.TREE_INSERT
+)
+
+
+# # single choice
+DEFAULT_QUERY_PROMPT_TMPL = (
+    "Some choices are given below. It is provided in a numbered list "
+    "(1 to {num_chunks}),"
+    "where each item in the list corresponds to a summary.\n"
+    "---------------------\n"
+    "{context_list}"
+    "\n---------------------\n"
+    "Using only the choices above and not prior knowledge, return "
+    "the choice that is most relevant to the question: '{query_str}'\n"
+    "Provide choice in the following format: 'ANSWER: <number>' and explain why "
+    "this summary was selected in relation to the question.\n"
+)
+DEFAULT_QUERY_PROMPT = Prompt(
+    DEFAULT_QUERY_PROMPT_TMPL, prompt_type=PromptType.TREE_SELECT
+)
+
+# multiple choice
+DEFAULT_QUERY_PROMPT_MULTIPLE_TMPL = (
+    "Some choices are given below. It is provided in a numbered "
+    "list (1 to {num_chunks}), "
+    "where each item in the list corresponds to a summary.\n"
+    "---------------------\n"
+    "{context_list}"
+    "\n---------------------\n"
+    "Using only the choices above and not prior knowledge, return the top choices "
+    "(no more than {branching_factor}, ranked by most relevant to least) that "
+    "are most relevant to the question: '{query_str}'\n"
+    "Provide choices in the following format: 'ANSWER: <numbers>' and explain why "
+    "these summaries were selected in relation to the question.\n"
+)
+DEFAULT_QUERY_PROMPT_MULTIPLE = Prompt(
+    DEFAULT_QUERY_PROMPT_MULTIPLE_TMPL, prompt_type=PromptType.TREE_SELECT_MULTIPLE
+)
+
+
+DEFAULT_REFINE_PROMPT_TMPL = (
+    "The original question is as follows: {query_str}\n"
+    "We have provided an existing answer: {existing_answer}\n"
+    "We have the opportunity to refine the existing 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. "
+    "If the context isn't useful, return the original answer."
+)
+DEFAULT_REFINE_PROMPT = Prompt(
+    DEFAULT_REFINE_PROMPT_TMPL, prompt_type=PromptType.REFINE
+)
+
+
+DEFAULT_TEXT_QA_PROMPT_TMPL = (
+    "Context information is below.\n"
+    "---------------------\n"
+    "{context_str}\n"
+    "---------------------\n"
+    "Given the context information and not prior knowledge, "
+    "answer the question: {query_str}\n"
+)
+DEFAULT_TEXT_QA_PROMPT = Prompt(
+    DEFAULT_TEXT_QA_PROMPT_TMPL, prompt_type=PromptType.QUESTION_ANSWER
+)
+
+
+############################################
+# Keyword Table
+############################################
+
+DEFAULT_KEYWORD_EXTRACT_TEMPLATE_TMPL = (
+    "Some text is provided below. Given the text, extract up to {max_keywords} "
+    "keywords from the text. Avoid stopwords."
+    "---------------------\n"
+    "{text}\n"
+    "---------------------\n"
+    "Provide keywords in the following comma-separated format: 'KEYWORDS: <keywords>'\n"
+)
+DEFAULT_KEYWORD_EXTRACT_TEMPLATE = Prompt(
+    DEFAULT_KEYWORD_EXTRACT_TEMPLATE_TMPL, prompt_type=PromptType.KEYWORD_EXTRACT
+)
+
+
+# NOTE: the keyword extraction for queries can be the same as
+# the one used to build the index, but here we tune it to see if performance is better.
+DEFAULT_QUERY_KEYWORD_EXTRACT_TEMPLATE_TMPL = (
+    "A question is provided below. Given the question, extract up to {max_keywords} "
+    "keywords from the text. Focus on extracting the keywords that we can use "
+    "to best lookup answers to the question. Avoid stopwords.\n"
+    "---------------------\n"
+    "{question}\n"
+    "---------------------\n"
+    "Provide keywords in the following comma-separated format: 'KEYWORDS: <keywords>'\n"
+)
+DEFAULT_QUERY_KEYWORD_EXTRACT_TEMPLATE = Prompt(
+    DEFAULT_QUERY_KEYWORD_EXTRACT_TEMPLATE_TMPL,
+    prompt_type=PromptType.QUERY_KEYWORD_EXTRACT,
+)
+
+
+############################################
+# Structured Store
+############################################
+
+DEFAULT_SCHEMA_EXTRACT_TMPL = (
+    "We wish to extract relevant fields from an unstructured text chunk into "
+    "a structured schema. We first provide the unstructured text, and then "
+    "we provide the schema that we wish to extract. "
+    "-----------text-----------\n"
+    "{text}\n"
+    "-----------schema-----------\n"
+    "{schema}\n"
+    "---------------------\n"
+    "Given the text and schema, extract the relevant fields from the text in "
+    "the following format: "
+    "field1: <value>\nfield2: <value>\n...\n\n"
+    "If a field is not present in the text, don't include it in the output."
+    "If no fields are present in the text, return a blank string.\n"
+    "Fields: "
+)
+DEFAULT_SCHEMA_EXTRACT_PROMPT = Prompt(
+    DEFAULT_SCHEMA_EXTRACT_TMPL, prompt_type=PromptType.SCHEMA_EXTRACT
+)
+
+# NOTE: taken from langchain and adapted
+# https://tinyurl.com/b772sd77
+DEFAULT_TEXT_TO_SQL_TMPL = (
+    "Given an input question, first create a syntactically correct {dialect} "
+    "query to run, then look at the results of the query and return the answer. "
+    "You can order the results by a relevant column to return the most "
+    "interesting examples in the database.\n"
+    "Never query for all the columns from a specific table, only ask for a "
+    "few relevant columns given the question.\n"
+    "Pay attention to use only the column names that you can see in the schema "
+    "description. "
+    "Be careful to not query for columns that do not exist. "
+    "Pay attention to which column is in which table. "
+    "Also, qualify column names with the table name when needed.\n"
+    "Use the following format:\n"
+    "Question: Question here\n"
+    "SQLQuery: SQL Query to run\n"
+    "SQLResult: Result of the SQLQuery\n"
+    "Answer: Final answer here\n"
+    "Only use the tables listed below.\n"
+    "{schema}\n"
+    "Question: {query_str}\n"
+    "SQLQuery: "
+)
+
+DEFAULT_TEXT_TO_SQL_PROMPT = Prompt(
+    DEFAULT_TEXT_TO_SQL_TMPL,
+    stop_token="\nSQLResult:",
+    prompt_type=PromptType.TEXT_TO_SQL,
+)
+
+
+# NOTE: by partially filling schema, we can reduce to a QuestionAnswer prompt
+# that we can feed to ur table
+DEFAULT_TABLE_CONTEXT_TMPL = (
+    "We have provided a table schema below. "
+    "---------------------\n"
+    "{schema}\n"
+    "---------------------\n"
+    "We have also provided context information below. "
+    "{context_str}\n"
+    "---------------------\n"
+    "Given the context information and the table schema, "
+    "give a response to the following task: {query_str}"
+)
+
+DEFAULT_TABLE_CONTEXT_QUERY = (
+    "Provide a high-level description of the table, "
+    "as well as a description of each column in the table. "
+    "Provide answers in the following format:\n"
+    "TableDescription: <description>\n"
+    "Column1Description: <description>\n"
+    "Column2Description: <description>\n"
+    "...\n\n"
+)
+
+DEFAULT_TABLE_CONTEXT_PROMPT = Prompt(
+    DEFAULT_TABLE_CONTEXT_TMPL, prompt_type=PromptType.TABLE_CONTEXT
+)
+
+# NOTE: by partially filling schema, we can reduce to a RefinePrompt
+# that we can feed to ur table
+DEFAULT_REFINE_TABLE_CONTEXT_TMPL = (
+    "We have provided a table schema below. "
+    "---------------------\n"
+    "{schema}\n"
+    "---------------------\n"
+    "We have also provided some context information below. "
+    "{context_msg}\n"
+    "---------------------\n"
+    "Given the context information and the table schema, "
+    "give a response to the following task: {query_str}\n"
+    "We have provided an existing answer: {existing_answer}\n"
+    "Given the new context, refine the original answer to better "
+    "answer the question. "
+    "If the context isn't useful, return the original answer."
+)
+DEFAULT_REFINE_TABLE_CONTEXT_PROMPT = Prompt(
+    DEFAULT_REFINE_TABLE_CONTEXT_TMPL, prompt_type=PromptType.TABLE_CONTEXT
+)
+
+
+############################################
+# Knowledge-Graph Table
+############################################
+
+KRON_KG_TRIPLET_EXTRACT_TMPL = (
+            "Below is an instruction that describes a task, paired with an input that provides further context. "
+            "Write a response that appropriately completes the request.\n\n" 
+            "### Instruction:\n"  
+            "Some text is provided below. Given the text, extract up to {max_knowledge_triplets} knowledge triplets in the form of " 
+            "(subject, predicate, object).\n\n"  
+            "### Input: \n"
+            "Text: Alice is Bob's mother. \n" 
+            "Triplets: \n"
+            "    (Alice, is mother of, Bob) \n"
+            "Text: Philz is a coffee shop founded in Berkeley in 1982. \n"
+            "Triplets: \n"
+            "    (Philz, is, coffee shop) \n"
+            "    (Philz, founded in, Berkeley) \n"
+            "    (Philz, founded in, 1982) \n"
+            "Text: This small and colorful book is for children. \n"
+            "Triplets: \n"
+            "    (book, is for, children)\n" 
+            "    (book, is, small and colorful) \n"
+            "    (small book, is for, children) \n"
+            "    (this small book, is for, children) \n"
+            "Text: We saw these dwellings, brightly painted cottages, shining in the sun. \n"
+            "Triplets: \n"
+            "    (dwellings, are, brightly painted cottages) \n"
+            "    (cottages, shine in, the sun) \n"
+            "--------------------- \n"
+            "### Text: {text} \n\n"
+            "### Triplets: "    
+)
+
+KRON_KG_TRIPLET_EXTRACT_PROMPT = Prompt(
+    KRON_KG_TRIPLET_EXTRACT_TMPL, prompt_type=PromptType.KNOWLEDGE_TRIPLET_EXTRACT
+)
+
+############################################
+# HYDE
+##############################################
+
+HYDE_TMPL = (
+    "Please write a passage to answer the question\n"
+    "Try to include as many key details as possible.\n"
+    "\n"
+    "\n"
+    "{context_str}\n"
+    "\n"
+    "\n"
+    'Passage:"""\n'
+)
+
+DEFAULT_HYDE_PROMPT = Prompt(HYDE_TMPL, prompt_type=PromptType.SUMMARY)
+
+
+############################################
+# Simple Input
+############################################
+
+DEFAULT_SIMPLE_INPUT_TMPL = "{query_str}"
+DEFAULT_SIMPLE_INPUT_PROMPT = Prompt(
+    DEFAULT_SIMPLE_INPUT_TMPL, prompt_type=PromptType.SIMPLE_INPUT
+)
+
+
+############################################
+# Pandas
+############################################
+
+DEFAULT_PANDAS_TMPL = (
+    "You are working with a pandas dataframe in Python.\n"
+    "The name of the dataframe is `df`.\n"
+    "This is the result of `print(df.head())`:\n"
+    "{df_str}\n\n"
+    "Here is the input query: {query_str}.\n"
+    "Given the df information and the input query, please follow "
+    "these instructions:\n"
+    "{instruction_str}"
+    "Output:\n"
+)
+
+DEFAULT_PANDAS_PROMPT = Prompt(DEFAULT_PANDAS_TMPL, prompt_type=PromptType.PANDAS)
+
+
+############################################
+# JSON Path
+############################################
+
+DEFAULT_JSON_PATH_TMPL = (
+    "We have provided a JSON schema below:\n"
+    "{schema}\n"
+    "Given a task, respond with a JSON Path query that "
+    "can retrieve data from a JSON value that matches the schema.\n"
+    "Task: {query_str}\n"
+    "JSONPath: "
+)
+
+DEFAULT_JSON_PATH_PROMPT = Prompt(
+    DEFAULT_JSON_PATH_TMPL, prompt_type=PromptType.JSON_PATH
+)

requirements.txt

@@ -0,0 +1,21 @@
+#local
+#conda create -n mlk8s python=3.9.15 -y 
+#conda activate mlk8s
+#pip install --upgrade streamlit
+#pip install --upgrade huggingface_hub
+#pip install -r requirements.txt
+#streamlit run appname.py
+
+torch
+transformers
+llama_index
+pyvis
+nltk
+python-dotenv
+cohere
+baseten
+st-star-rating
+amazon-dax-client>=1.1.7
+boto3>=1.26.79
+pytest>=7.2.1
+requests>=2.28.2

storage/Writer-camel-5b-hf-default-no-coref/vector_store.json

@@ -0,0 +1 @@
+{"embedding_dict": {}, "text_id_to_ref_doc_id": {}}