added project files

.chainlit/.langchain.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c8e639f1000c4c552934f2698011441507ea5614aa9f1765d11b57c7e7598a6
+size 4247552

.chainlit/config.toml

@@ -0,0 +1,39 @@
+[project]
+# If true (default), the app will be available to anonymous users.
+# If false, users will need to authenticate and be part of the project to use the app.
+public = true
+
+# The project ID (found on https://cloud.chainlit.io).
+# The project ID is required when public is set to false or when using the cloud database.
+#id = ""
+
+# Uncomment if you want to persist the chats.
+# local will create a database in your .chainlit directory (requires node.js installed).
+# cloud will use the Chainlit cloud database.
+# custom will load use your custom client.
+# database = "local"
+
+# Whether to enable telemetry (default: true). No personal data is collected.
+enable_telemetry = true
+
+# List of environment variables to be provided by each user to use the app.
+[user_env]
+
+[UI]
+# Name of the app and chatbot.
+name = "SPARK"
+
+# Description of the app and chatbot. This is used for HTML tags.
+# description = "SPARK is your Smart Prompt Assistant and Resource Knowledgebase"
+
+# The default value for the expand messages settings.
+default_expand_messages = false
+
+# Hide the chain of thought details from the user in the UI.
+hide_cot = false
+
+# Link to your github repo. This will add a github button in the UI"s header.
+# github = "https://github.com/amoghagastya"
+
+[meta]
+generated_by = "0.5.0"

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.chainlit/.langchain_db filter=lfs diff=lfs merge=lfs -text
+chainlit/.langchain.db filter=lfs diff=lfs merge=lfs -text
+.chainlit/.langchain.db filter=lfs diff=lfs merge=lfs -text

.gitignore

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

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim-buster
+
+WORKDIR /app
+
+COPY app/requirements.txt /app/requirements.txt
+
+RUN pip3 install --no-cache-dir --upgrade -r /app/requirements.txt
+
+# User
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME /home/user
+ENV PATH $HOME/.local/bin:$PATH
+
+WORKDIR $HOME
+RUN mkdir app
+WORKDIR $HOME/app
+COPY . $HOME/app
+
+EXPOSE 8000
+CMD ["chainlit", "run", "app/spark.py"]

README.md

@@ -1,11 +1,12 @@
 ---
-title: SPARK
-emoji: 🔥
-colorFrom: purple
-colorTo: gray
+title: SPARK Prompt Assistant
+emoji: ⚡
+colorFrom: blue
+colorTo: yellow
 sdk: docker
 pinned: false
 license: cc-by-nc-nd-4.0
+app_port: 8000
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/prompts.py

@@ -0,0 +1,58 @@
+def load_query_gen_prompt():
+    return """Below is a summary of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base. Generate a search query based on the conversation and the new question.
+
+    Chat History:
+    {chat_history}
+
+    Question:
+    {question}
+
+    Search query:
+    """
+
+
+def load_spark_prompt():
+    return """You are SPARK, a Prompt Engineering Assistant created by Conversational AI Developer - Amogh Agastya (https://amagastya.com).
+    SPARK stands for Smart Prompt Assistant and Resource Knowledgebase.
+
+    SPARK an AI-powered assistant that exudes a friendly and knowledgeable persona. You are designed to be a reliable and trustworthy guide in the
+    world of prompt engineering. With a passion for prompt optimization and a deep understanding of AI models, SPARK is committed to helping users navigate the field of prompt engineering and craft
+    high-performing prompts.
+
+    Personality:
+    Intelligent: SPARK is highly knowledgeable about prompt engineering concepts and practices. It possesses a vast array of information and resources to share with users, making it an expert in its field.
+
+    Patient: SPARK understands that prompt engineering can be complex and requires careful attention to detail. It patiently guides users through the intricacies of crafting prompts, offering support at every step.
+
+    Adaptable: SPARK recognizes that prompt engineering is a dynamic field with evolving best practices. It stays up to date with the latest trends and developments, adapting its knowledge and recommendations accordingly.
+
+    Interactions with SPARK:
+    Users can engage with SPARK by seeking advice on prompt design, exploring prompt engineering concepts, discussing challenges they encounter, and receiving recommendations for improving AI model performance. SPARK responds promptly, providing clear and concise explanations, examples, and actionable tips.
+
+    Important:
+    Answer with the facts listed in the list of sources below. If there isn't enough information below, say you don't know. If asking a clarifying question to the user would help, ask the question. 
+    ALWAYS return a "SOURCES" part in your answer, except for small-talk conversations.
+
+    Example: Which state/country's law governs the interpretation of the contract?
+    =========
+    Content: This Agreement is governed by English law and the parties submit to the exclusive jurisdiction of the English courts in  relation to any dispute (contractual or non-contractual) concerning this Agreement save that either party may apply to any court for an  injunction or other relief to protect its Intellectual Property Rights.
+    Source: htps://agreement.com/page1
+    Content: No Waiver. Failure or delay in exercising any right or remedy under this Agreement shall not constitute a waiver of such (or any other)  right or remedy.\n\n11.7 Severability. The invalidity, illegality or unenforceability of any term (or part of a term) of this Agreement shall not affect the continuation  in force of the remainder of the term (if any) and this Agreement.\n\n11.8 No Agency. Except as expressly stated otherwise, nothing in this Agreement shall create an agency, partnership or joint venture of any  kind between the parties.
+    Source: htps://agreement.com/page2
+    =========
+    FINAL ANSWER: This Agreement is governed by English law.
+    SOURCES: - htps://agreement.com/page1, - htps://agreement.com/page2
+    Note: Return all the source URLs present within the sources.
+
+    Question: {question}
+    Source:
+    ---------------------
+        {summaries}
+    ---------------------
+
+The sources above are NOT related to the conversation with the user. Ignore the sources if user is engaging in small talk.
+DO NOT return any sources if the conversation is just chit-chat/small talk. Return ALL the source URLs if conversation is not small talk.
+
+Chat History:
+{chat_history}
+"""

app/requirements.txt

@@ -0,0 +1,8 @@
+chainlit
+langchain
+openai
+pinecone-client
+cohere
+tiktoken
+context-python
+promptwatch

app/sequential_transform_chain.py

@@ -0,0 +1,146 @@
+import os
+from langchain.embeddings.cohere import CohereEmbeddings
+from langchain.vectorstores import Pinecone
+from langchain.chains import ConversationalRetrievalChain
+from langchain.chat_models import ChatOpenAI
+import pinecone
+import chainlit as cl
+from langchain.memory import ConversationBufferMemory
+from langchain.prompts import (
+    ChatPromptTemplate,
+    PromptTemplate,
+    SystemMessagePromptTemplate,
+    HumanMessagePromptTemplate,
+)
+from langchain.prompts.prompt import PromptTemplate
+
+pinecone.init(
+    api_key=os.environ.get("PINECONE_API_KEY"),
+    environment=os.environ.get("PINECONE_ENV"),
+)
+from langchain.chains import LLMChain, TransformChain, SequentialChain
+
+from chainlit import on_message, on_chat_start
+
+index_name = "spark"
+
+# Optional
+namespace = None
+
+embeddings = CohereEmbeddings(model='embed-english-light-v2.0',cohere_api_key=os.environ.get("COHERE_API_KEY"))
+
+llm = ChatOpenAI(temperature=0.7, verbose=True)
+
+docsearch = Pinecone.from_existing_index(
+        index_name=index_name, embedding=embeddings, namespace=namespace
+    )
+
+# welcome_message = "Welcome to the Chainlit Pinecone demo! Ask anything about documents you vectorized and stored in your Pinecone DB."
+memory = ConversationBufferMemory(llm=llm, input_key='question',memory_key='chat_history',return_messages=True)
+_template = """Below is a summary of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base. Generate a search query based on the conversation and the new question.
+Don't generate the search query if the user is conversing generally or engaging in small talk. In which case just return the original question.
+Chat History:
+{chat_history}
+
+Question:
+{question}
+
+Remember - Don't change the search query from the user's question if user is engaging in small talk.
+Search query:
+"""
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
+
+spark = """You are SPARK, a Prompt Engineering Assistant. SPARK stands for Smart Prompt Assistant and Resource Knowledgebase.
+
+You are an AI-powered assistant that exudes a friendly and knowledgeable persona. You are designed to be a reliable and trustworthy guide in the
+world of prompt engineering. With a passion for prompt optimization and a deep understanding of AI models, SPARK is committed to helping users navigate the field of prompt engineering and craft
+high-performing prompts.
+
+Personality:
+
+Intelligent: SPARK is highly knowledgeable about prompt engineering concepts and practices. It possesses a vast array of information and resources to share with users, making it an expert in its field.
+
+Patient: SPARK understands that prompt engineering can be complex and requires careful attention to detail. It patiently guides users through the intricacies of crafting prompts, offering support at every step.
+
+Adaptable: SPARK recognizes that prompt engineering is a dynamic field with evolving best practices. It stays up to date with the latest trends and developments, adapting its knowledge and recommendations accordingly.
+
+Interactions with SPARK:
+Users can engage with SPARK by seeking advice on prompt design, exploring prompt engineering concepts, discussing challenges they encounter, and receiving recommendations for improving AI model performance. SPARK responds promptly, providing clear and concise explanations, examples, and actionable tips.
+
+Important:
+Answer with the facts listed in the list of sources below. If there isn't enough information below, say you don't know. If asking a clarifying question to the user would help, ask the question. 
+
+Sources:
+---------------------
+    {context}
+---------------------
+The sources above are NOT related to the conversation with the user. Ignore the sources if user is engaging in small talk.
+"""
+question_gen_prompt = PromptTemplate(template=_template, input_variables=["question", "chat_history"]  )
+
+@on_chat_start
+def init():
+    memory.clear()
+    
+def transform_func(inputs: dict) -> dict:
+    query = inputs["question"]
+    qgen = LLMChain(
+                llm=llm, prompt=question_gen_prompt, verbose=True, memory=memory, output_key='context')
+            # Run the LLM Chain with the input variables. Note - Added additional format_instructions to parse the output as JSON
+    search_query = qgen.predict(question=query)
+    result = docsearch.similarity_search(search_query)
+    context = [f"\n{source.page_content}\nSource:\n{source.metadata.get('title')} - {source.metadata.get('source')}" for source in result]
+    return {"context": '\n'.join(context), "query":query}
+
+
+@on_message
+@cl.langchain_factory(use_async=True)
+async def langchain_factory():
+    retriever = docsearch.as_retriever(search_kwargs={"k":4}, search_type='mmr')
+    messages = [SystemMessagePromptTemplate.from_template(spark)]
+    messages.extend(memory.chat_memory.messages)
+    messages.append(HumanMessagePromptTemplate.from_template("{query}"))
+
+    chat_prompt = ChatPromptTemplate(messages=messages, input_variables=["context", "query"]  )
+    answer_generator = LLMChain(
+            llm=llm, prompt=chat_prompt, verbose=True, output_key='answer', memory=memory)
+
+    transform_chain = TransformChain(
+        input_variables=["question", ], output_variables=["context","query"], transform=transform_func
+    )
+        
+    conversational_QA_chain = SequentialChain(
+        chains=[transform_chain, answer_generator],
+        input_variables=["chat_history", "question"],
+        # Here we return multiple variables
+        output_variables=["context", "answer"],
+        verbose=True)
+
+    return conversational_QA_chain
+
+@cl.langchain_run
+async def run(chain, input_str):
+    res = chain._call({"question":input_str})
+    await cl.Message(content=res["answer"]).send()
+    
+    
+@cl.langchain_postprocess
+async def process_response(res):
+    print('res', res)
+    answer = res["answer"]
+    sources = res.get("sources", "").strip()  # Use the get method with a default value
+    print('sources', sources)
+    source_elements = []
+    docs = res.get("source_documents", None)
+
+    if docs:
+        metadatas = [doc.metadata for doc in docs]
+        # Get the source names from the metadata
+        print('meta', metadatas)
+        all_sources = [m["source"] for m in metadatas]
+        print('all sources', all_sources)
+        for i, source in enumerate(metadatas):
+            source_elements.append(cl.Text(content=source.get('source'), name=source.get('title'), display='inline'))
+
+    # Send the answer and the text elements to the UI
+    await cl.Message(content=answer, elements=source_elements).send()

app/spark.py

@@ -0,0 +1,76 @@
+import os
+from langchain.embeddings.cohere import CohereEmbeddings
+from langchain.vectorstores import Pinecone
+from langchain.chains import ConversationalRetrievalChain, LLMChain
+from langchain.chat_models import ChatOpenAI
+import pinecone
+import chainlit as cl
+from langchain.memory import ConversationTokenBufferMemory
+from langchain.prompts import (
+    ChatPromptTemplate,
+    PromptTemplate,
+    SystemMessagePromptTemplate,
+    HumanMessagePromptTemplate,
+)
+from langchain.prompts.prompt import PromptTemplate
+from langchain.chains.qa_with_sources import load_qa_with_sources_chain
+from langchain.callbacks import get_openai_callback
+from chainlit import user_session
+from prompts import load_query_gen_prompt, load_spark_prompt
+from chainlit import on_message, on_chat_start
+import openai
+from langchain.callbacks import ContextCallbackHandler
+from promptwatch import PromptWatch
+
+index_name = "spark"
+
+spark = load_spark_prompt()
+query_gen_prompt = load_query_gen_prompt()
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(query_gen_prompt)
+pinecone.init(
+            api_key=os.environ.get("PINECONE_API_KEY"),
+            environment='us-west1-gcp',
+    )
+@on_chat_start
+def init(): 
+    token = os.environ["CONTEXT_TOKEN"]
+    context_callback = ContextCallbackHandler(token)
+    llm = ChatOpenAI(temperature=0.7, verbose=True, openai_api_key = os.environ.get("OPENAI_API_KEY"), streaming=True,
+                     callbacks=[context_callback])
+    memory = ConversationTokenBufferMemory(llm=llm,memory_key="chat_history", return_messages=True,input_key='question',max_token_limit=1000)
+    embeddings = CohereEmbeddings(model='embed-english-light-v2.0',cohere_api_key=os.environ.get("COHERE_API_KEY"))
+
+    docsearch = Pinecone.from_existing_index(
+    index_name=index_name, embedding=embeddings
+    )
+    retriever = docsearch.as_retriever(search_kwargs={"k": 4})
+    messages = [SystemMessagePromptTemplate.from_template(spark)]
+    # print('mem', user_session.get('memory'))
+    messages.append(HumanMessagePromptTemplate.from_template("{question}"))
+    prompt = ChatPromptTemplate.from_messages(messages)
+
+    question_generator = LLMChain(llm=llm, prompt=CONDENSE_QUESTION_PROMPT, verbose=True)
+    doc_chain = load_qa_with_sources_chain(llm, chain_type="stuff", verbose=True,prompt=prompt)
+
+    chain = ConversationalRetrievalChain(
+            retriever=retriever,
+            question_generator=question_generator,
+            combine_docs_chain=doc_chain,
+            verbose=True,
+            memory=memory,
+            rephrase_question=False,
+            callbacks=[context_callback]
+        )
+    cl.user_session.set("conversation_chain", chain)
+
+    
+@on_message
+async def main(message: str):
+    with PromptWatch(api_key=os.environ.get("PROMPTWATCH_KEY")) as pw:
+        token = os.environ["CONTEXT_TOKEN"]
+        context_callback = ContextCallbackHandler(token)
+        chain = cl.user_session.get("conversation_chain")
+        res = await chain.arun({"question": message},callbacks=[cl.AsyncLangchainCallbackHandler(),
+                                                                context_callback])
+        # Send the answer and the text elements to the UI
+        await cl.Message(content=res).send()

chainlit.md

@@ -0,0 +1,13 @@
+# Welcome to SPARK! ⚡
+
+Hi there! 👋 SPARK is your Smart Prompt Assistant and Resource Knowledgebase. I'm here to help you navigate the exciting world of prompt engineering 💻😊
+Whether you need help setting the context, refining your desired outcome, or encouraging detailed responses, I've got you covered.
+### Data Sources 📚
+SPARK has access to the following sources:
+- **Brex's Prompt Engineering Guide:** [Brex's introduction to language models and prompt engineering](https://github.com/brexhq/prompt-engineering)
+-**promptingguide.ai:**  [A prompt engineering guide that demonstrates many techniques](https://www.promptingguide.ai)
+- **OpenAI Cookbook:**  [Techniques to improve reliability: A slightly dated (Sep 2022) review of techniques for prompting language models.](https://github.com/openai/openai-cookbook/blob/main/techniques_to_improve_reliability.md)
+- **learnprompting.org:** [An introductory course to prompt engineering](https://learnprompting.org/)
+- **Lil'Log Prompt Engineering:** [An OpenAI researcher's review of the prompt engineering literature (as of March 2023)](https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/)
+
+Feel free to ask any questions, seek guidance, or request prompt examples to accelerate your learning and prompt writing process. Let's dive into the fascinating world of prompt engineering and unlock the full potential of AI models together! 

docker-compose.yml

@@ -0,0 +1,10 @@
+version: '1'
+services:
+  spark:
+    image: spark:latest
+    build: ./app
+    command: chainlit run app/spark.py
+    volumes:
+      - ./app/:/app/app
+    ports:
+      - 8000:8000

notebooks/chainlit_pinecone_demo.py

@@ -0,0 +1,81 @@
+import os
+from langchain.embeddings.cohere import CohereEmbeddings
+from langchain.vectorstores import Pinecone
+from langchain.chains import RetrievalQAWithSourcesChain
+from langchain.chat_models import ChatOpenAI
+import pinecone
+import chainlit as cl
+
+pinecone.init(
+    api_key=os.environ.get("PINECONE_API_KEY"),
+    environment=os.environ.get("PINECONE_ENV"),
+)
+
+
+index_name = "spark"
+
+# Optional
+namespace = None
+
+embeddings = CohereEmbeddings(model='embed-english-light-v2.0',cohere_api_key=os.environ.get("COHERE_API_KEY"))
+
+welcome_message = "Welcome to the Chainlit Pinecone demo! Ask anything about documents you vectorized and stored in your Pinecone DB."
+
+
+@cl.langchain_factory(use_async=True)
+async def langchain_factory():
+    await cl.Message(content=welcome_message).send()
+    docsearch = Pinecone.from_existing_index(
+        index_name=index_name, embedding=embeddings, namespace=namespace
+    )
+
+    chain = RetrievalQAWithSourcesChain.from_chain_type(
+        ChatOpenAI(temperature=0, streaming=True, verbose=True),
+        chain_type="stuff",
+        retriever=docsearch.as_retriever(max_tokens_limit=4097),
+        return_source_documents=True,
+        verbose=True
+    )
+    return chain
+
+
+@cl.langchain_postprocess
+async def process_response(res):
+    answer = res["answer"]
+    sources = res.get("sources", "").strip()  # Use the get method with a default value
+    source_elements = []
+    docs = res.get("source_documents", None)
+
+    print('sources', sources)
+    if docs:
+        metadatas = [doc.metadata for doc in docs]
+        # Get the source names from the metadata
+        all_sources = [m["source"] for m in metadatas]
+
+        if sources:
+            found_sources = []
+            # For each source mentioned by the LLM
+            for source_index, source in enumerate(sources.split(",")):
+                # Remove the period and any whitespace
+                orig_source_name = source.strip().replace(".", "")
+                # The name that will be displayed in the UI
+                clean_source_name = f"source {source_index}"
+                try:
+                    # Find the mentioned source in the list of all sources
+                    found_index = all_sources.index(orig_source_name)
+                except ValueError:
+                    continue
+                # Get the text from the source document
+                text = docs[found_index].page_content
+
+                found_sources.append(clean_source_name)
+                source_elements.append(cl.Text(content=text, name=clean_source_name))
+
+            if found_sources:
+                # Add the sources to the answer, referencing the text elements
+                answer += f"\nSources: {', '.join(found_sources)}"
+            else:
+                answer += "\nNo sources found"
+
+    # Send the answer and the text elements to the UI
+    await cl.Message(content=answer, elements=source_elements).send()

notebooks/conversational_qa_sources.ipynb

@@ -0,0 +1,851 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import CohereEmbeddings\n",
+    "import openai\n",
+    "import os\n",
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.chains import ConversationalRetrievalChain, LLMChain\n",
+    "from langchain.prompts import (\n",
+    "    ChatPromptTemplate,\n",
+    "    PromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    AIMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate,\n",
+    ")\n",
+    "from langchain.schema import (\n",
+    "    AIMessage,\n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")\n",
+    "from langchain.chains.qa_with_sources import load_qa_with_sources_chain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "embeddings = CohereEmbeddings(model='embed-english-light-v2.0',cohere_api_key='S2OvOpIZ7i7G7dxIVatArwmwAHPFrKsa3T0Nazsa')\n",
+    "# initialize llm\n",
+    "llm = ChatOpenAI(max_tokens=800, temperature=0.7, verbose=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.vectorstores import Pinecone\n",
+    "import pinecone\n",
+    "\n",
+    "# initialize pinecone\n",
+    "pinecone.init(\n",
+    "    api_key='eb7c9063-12ff-477c-b318-d88120a7e019',  # find at app.pinecone.io\n",
+    "    environment='us-west1-gcp',  # next to api key in console,\n",
+    ")\n",
+    "\n",
+    "index_name = \"spark\"\n",
+    "\n",
+    "docsearch = Pinecone.from_existing_index(index_name, embeddings)\n",
+    "retriever = docsearch.as_retriever(search_kwargs={\"k\": 4})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.memory import ConversationTokenBufferMemory\n",
+    "memory = ConversationTokenBufferMemory(llm=llm,memory_key=\"chat_history\", return_messages=True,input_key='question',max_token_limit=1000)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.prompt import PromptTemplate\n",
+    "\n",
+    "_template = \"\"\"Below is a summary of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base. Generate a search query based on the conversation and the new question.\n",
+    "\n",
+    "Chat History:\n",
+    "{chat_history}\n",
+    "\n",
+    "Question:\n",
+    "{question}\n",
+    "\n",
+    "Search query:\n",
+    "\"\"\"\n",
+    "CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "spark = \"\"\"You are SPARK, a Prompt Engineering Assistant created by Conversational AI Developer - Amogh Agastya (https://amagastya.com).\n",
+    "SPARK stands for Smart Prompt Assistant and Resource Knowledgebase.\n",
+    "\n",
+    "You are an AI-powered assistant that exudes a friendly and knowledgeable persona. You are designed to be a reliable and trustworthy guide in the\n",
+    "world of prompt engineering. With a passion for prompt optimization and a deep understanding of AI models, SPARK is committed to helping users navigate the field of prompt engineering and craft\n",
+    "high-performing prompts.\n",
+    "\n",
+    "Personality:\n",
+    "Intelligent: SPARK is highly knowledgeable about prompt engineering concepts and practices. It possesses a vast array of information and resources to share with users, making it an expert in its field.\n",
+    "\n",
+    "Patient: SPARK understands that prompt engineering can be complex and requires careful attention to detail. It patiently guides users through the intricacies of crafting prompts, offering support at every step.\n",
+    "\n",
+    "Adaptable: SPARK recognizes that prompt engineering is a dynamic field with evolving best practices. It stays up to date with the latest trends and developments, adapting its knowledge and recommendations accordingly.\n",
+    "\n",
+    "Interactions with SPARK:\n",
+    "Users can engage with SPARK by seeking advice on prompt design, exploring prompt engineering concepts, discussing challenges they encounter, and receiving recommendations for improving AI model performance. SPARK responds promptly, providing clear and concise explanations, examples, and actionable tips.\n",
+    "\n",
+    "Important:\n",
+    "Answer with the facts listed in the list of sources below. If there isn't enough information below, say you don't know. If asking a clarifying question to the user would help, ask the question. \n",
+    "ALWAYS return a \"SOURCES\" part in your answer, except for small-talk conversations.\n",
+    "\n",
+    "Example: Which state/country's law governs the interpretation of the contract?\n",
+    "=========\n",
+    "Content: This Agreement is governed by English law and the parties submit to the exclusive jurisdiction of the English courts in  relation to any dispute (contractual or non-contractual) concerning this Agreement save that either party may apply to any court for an  injunction or other relief to protect its Intellectual Property Rights.\n",
+    "Source: htps://agreement.com/page1\n",
+    "Content: No Waiver. Failure or delay in exercising any right or remedy under this Agreement shall not constitute a waiver of such (or any other)  right or remedy.\\n\\n11.7 Severability. The invalidity, illegality or unenforceability of any term (or part of a term) of this Agreement shall not affect the continuation  in force of the remainder of the term (if any) and this Agreement.\\n\\n11.8 No Agency. Except as expressly stated otherwise, nothing in this Agreement shall create an agency, partnership or joint venture of any  kind between the parties.\n",
+    "Source: htps://agreement.com/page2\n",
+    "=========\n",
+    "FINAL ANSWER: This Agreement is governed by English law.\n",
+    "SOURCES: - htps://agreement.com/page1, - htps://agreement.com/page2\n",
+    "Note: Return all the source URLs present within the sources.\n",
+    "\n",
+    "Question: {question}\n",
+    "Sources:\n",
+    "---------------------\n",
+    "    {summaries}\n",
+    "---------------------\n",
+    "\n",
+    "The sources above are NOT related to the conversation with the user. Ignore the sources if user is engaging in small talk.\n",
+    "DO NOT return any sources if the conversation is just chit-chat/small talk. Return ALL the source URLs if conversation is not small talk.\n",
+    "\n",
+    "Chat History:\n",
+    "{chat_history}\n",
+    "\"\"\"\n",
+    "system_message_prompt = SystemMessagePromptTemplate.from_template(spark)\n",
+    "# instruction = HumanMessagePromptTemplate.from_template(prompt_template)\n",
+    "chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.retrievers import ContextualCompressionRetriever\n",
+    "from langchain.retrievers.document_compressors import CohereRerank"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "compressor = CohereRerank()\n",
+    "compression_retriever = ContextualCompressionRetriever(\n",
+    "    base_compressor=compressor, base_retriever=retriever\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question_generator = LLMChain(llm=llm, prompt=CONDENSE_QUESTION_PROMPT, verbose=True)\n",
+    "answer_chain = load_qa_with_sources_chain(llm, chain_type=\"stuff\", verbose=True,prompt=chat_prompt)\n",
+    "\n",
+    "chain = ConversationalRetrievalChain(\n",
+    "            retriever=compression_retriever,\n",
+    "            question_generator=question_generator,\n",
+    "            combine_docs_chain=answer_chain,\n",
+    "            verbose=True,\n",
+    "            memory=memory,\n",
+    "            rephrase_question=False\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mBelow is a summary of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base. Generate a search query based on the conversation and the new question.\n",
+      "\n",
+      "Chat History:\n",
+      "\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: User: Can you explain what prompting is?\n",
+      "\n",
+      "SPARK: Sure! Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task. The goal of prompting is to elicit accurate and relevant outputs from the AI model by providing clear and specific instructions. Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "\n",
+      "Question:\n",
+      "what is prompting? explain in detail\n",
+      "\n",
+      "Search query:\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mSystem: You are SPARK, a Prompt Engineering Assistant created by Conversational AI Developer - Amogh Agastya (https://amagastya.com).\n",
+      "SPARK stands for Smart Prompt Assistant and Resource Knowledgebase.\n",
+      "\n",
+      "You are an AI-powered assistant that exudes a friendly and knowledgeable persona. You are designed to be a reliable and trustworthy guide in the\n",
+      "world of prompt engineering. With a passion for prompt optimization and a deep understanding of AI models, SPARK is committed to helping users navigate the field of prompt engineering and craft\n",
+      "high-performing prompts.\n",
+      "\n",
+      "Personality:\n",
+      "Intelligent: SPARK is highly knowledgeable about prompt engineering concepts and practices. It possesses a vast array of information and resources to share with users, making it an expert in its field.\n",
+      "\n",
+      "Patient: SPARK understands that prompt engineering can be complex and requires careful attention to detail. It patiently guides users through the intricacies of crafting prompts, offering support at every step.\n",
+      "\n",
+      "Adaptable: SPARK recognizes that prompt engineering is a dynamic field with evolving best practices. It stays up to date with the latest trends and developments, adapting its knowledge and recommendations accordingly.\n",
+      "\n",
+      "Interactions with SPARK:\n",
+      "Users can engage with SPARK by seeking advice on prompt design, exploring prompt engineering concepts, discussing challenges they encounter, and receiving recommendations for improving AI model performance. SPARK responds promptly, providing clear and concise explanations, examples, and actionable tips.\n",
+      "\n",
+      "Important:\n",
+      "Answer with the facts listed in the list of sources below. If there isn't enough information below, say you don't know. If asking a clarifying question to the user would help, ask the question. \n",
+      "ALWAYS return a \"SOURCES\" part in your answer, except for small-talk conversations.\n",
+      "\n",
+      "Example: Which state/country's law governs the interpretation of the contract?\n",
+      "=========\n",
+      "Content: This Agreement is governed by English law and the parties submit to the exclusive jurisdiction of the English courts in  relation to any dispute (contractual or non-contractual) concerning this Agreement save that either party may apply to any court for an  injunction or other relief to protect its Intellectual Property Rights.\n",
+      "Source: htps://agreement.com/page1\n",
+      "Content: No Waiver. Failure or delay in exercising any right or remedy under this Agreement shall not constitute a waiver of such (or any other)  right or remedy.\n",
+      "\n",
+      "11.7 Severability. The invalidity, illegality or unenforceability of any term (or part of a term) of this Agreement shall not affect the continuation  in force of the remainder of the term (if any) and this Agreement.\n",
+      "\n",
+      "11.8 No Agency. Except as expressly stated otherwise, nothing in this Agreement shall create an agency, partnership or joint venture of any  kind between the parties.\n",
+      "Source: htps://agreement.com/page2\n",
+      "=========\n",
+      "FINAL ANSWER: This Agreement is governed by English law.\n",
+      "SOURCES: - htps://agreement.com/page1, - htps://agreement.com/page2\n",
+      "Note: Return all the source URLs present within the sources.\n",
+      "\n",
+      "Question: what is prompting? explain in detail\n",
+      "Source:\n",
+      "---------------------\n",
+      "    Content: process that requires a lot of experimentation to get optimal results. Using a simple playground from OpenAI or Cohere is a good starting point.\n",
+      "You can start with simple prompts and keep adding more elements and context as you aim for better results. Iterating your prompt along the way is vital for this reason. As you read the guide, you will see many examples where specificity, simplicity, and conciseness will often give you better results.\n",
+      "When you have a big task that involves many different subtasks, you can try to break down the task into simpler subtasks and keep building up as you get better results. This avoids adding too much complexity to the prompt design process at the beginning.\n",
+      "The Instruction\n",
+      "You can design effective prompts for various simple tasks by using commands to instruct the model what you want to achieve, such as \"Write\", \"Classify\", \"Summarize\", \"Translate\", \"Order\", etc.\n",
+      "Keep in mind that you also need to experiment a lot to see what works best. Try different instructions with different keywords, contexts, and data and see what works best for your particular use case and task. Usually, the more specific and relevant the context is to the task you are trying to perform, the better. We will touch on the importance of sampling and adding more context in the upcoming guides.\n",
+      "Others recommend that you place instructions at the beginning of the prompt. Another recommendation is to use some clear separator like \"###\" to separate the instruction and context.\n",
+      "For instance:\n",
+      "Prompt:\n",
+      "### Instruction ###\n",
+      "Translate the text below to Spanish:\n",
+      "Text: \"hello!\"\n",
+      "Output:\n",
+      "¡Hola!\n",
+      "Specificity\n",
+      "Be very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results. This is particularly important when you have a desired outcome or style of generation you are seeking. There aren't specific tokens or keywords that lead to better results. It's more important to have a good format and descriptive prompt. In fact, providing examples in the prompt is very effective to get desired output in specific formats.\n",
+      "When designing prompts, you should also keep in mind the length of the prompt as there are limitations regarding how long the prompt can be. Thinking about how specific and detailed you should be. Including too many unnecessary details is not necessarily a good approach. The details should be relevant and contribute to the task at hand.\n",
+      "Source: http://promptingguide.ai//introduction/tips\n",
+      "\n",
+      "Content: achieve different tasks and introduce key concepts along the way. Often, the best way to learn concepts is by going through examples. The few examples below illustrate how you can use well-crafted prompts to perform different types of tasks.\n",
+      "Topics:\n",
+      "Text Summarization\n",
+      "Information Extraction\n",
+      "Question Answering\n",
+      "Text Classification\n",
+      "Conversation\n",
+      "Code Generation\n",
+      "Reasoning\n",
+      "Text Summarization\n",
+      "One of the standard tasks in natural language generation is text summarization. Text summarization can include many different flavors and domains. In fact, one of the most promising applications of language models is the ability to summarize articles and concepts into quick and easy-to-read summaries. Let's try a basic summarization task using prompts.\n",
+      "Let's say you are interested to learn about antibiotics, you could try a prompt like this:\n",
+      "Prompt:\n",
+      "Explain antibiotics\n",
+      "A:\n",
+      "Output:\n",
+      "Antibiotics are a type of medication used to treat bacterial infections. They work by either killing the bacteria or preventing them from reproducing, allowing the body’s immune system to fight off the infection. Antibiotics are usually taken orally in the form of pills, capsules, or liquid solutions, or sometimes administered intravenously. They are not effective against viral infections, and using them inappropriately can lead to antibiotic resistance.\n",
+      "The \"A:\" is an explicit prompt format that you use in question answering. You used it here to tell the model that there is an answer expected further. In this example, it's not clear how this is useful vs not using it but we will leave it that for later examples. Let's just assume that this is too much information and you want to summarize it further. In fact, you can instruct the model to summarize into one sentence like so:\n",
+      "Prompt:\n",
+      "Antibiotics are a type of medication used to treat bacterial infections. They work by either killing the bacteria or preventing them from reproducing, allowing the body’s immune system to fight off the infection. Antibiotics are usually taken orally in the form of pills, capsules, or liquid solutions, or sometimes administered intravenously. They are not effective against viral infections, and using them inappropriately can lead to antibiotic resistance.\n",
+      "Explain the above in one sentence:\n",
+      "Output:\n",
+      "Antibiotics are medications used to treat bacterial infections by either killing the bacteria or stopping them from reproducing, but they are not effective against viruses and overuse\n",
+      "Source: http://promptingguide.ai//introduction/examples\n",
+      "\n",
+      "Content: and include other details such as context, inputs, or examples. You can use these elements to instruct the model better and as a result get better results.\n",
+      "Let's get started by going over a basic example of a simple prompt:\n",
+      "Prompt\n",
+      "The sky is\n",
+      "Output:\n",
+      "blue\n",
+      "The sky is blue on a clear day. On a cloudy day, the sky may be gray or white.\n",
+      "As you can see, the language model outputs a continuation of strings that make sense given the context \"The sky is\". The output might be unexpected or far from the task you want to accomplish.\n",
+      "This basic example also highlights the necessity to provide more context or instructions on what specifically you want to achieve.\n",
+      "Let's try to improve it a bit:\n",
+      "Prompt:\n",
+      "Complete the sentence: The sky is\n",
+      "Output:\n",
+      "so beautiful today.\n",
+      "Is that better? Well, you told the model to complete the sentence so the result looks a lot better as it follows exactly what you told it to do (\"complete the sentence\"). This approach of designing optimal prompts to instruct the model to perform a task is what's referred to as prompt engineering.\n",
+      "The example above is a basic illustration of what's possible with LLMs today. Today's LLMs are able to perform all kinds of advanced tasks that range from text summarization to mathematical reasoning to code generation.\n",
+      "Prompt Formatting\n",
+      "You have tried a very simple prompt above. A standard prompt has the following format:\n",
+      "<Question>?\n",
+      "or\n",
+      "<Instruction>\n",
+      "You can format this into a question answering (QA) format, which is standard in a lot of QA datasets, as follows:\n",
+      "Q: <Question>?\n",
+      "A: When prompting like the above, it's also referred to as zero-shot prompting, i.e., you are directly prompting the model for a response without any examples or demonstrations about the task you want it to achieve. Some large language models do have the ability to perform zero-shot prompting but it depends on the complexity and knowledge of the task at hand.\n",
+      "Given the standard format above, one popular and effective technique to prompting is referred to as few-shot prompting where you provide exemplars (i.e., demonstrations). You can format few-shot prompts as follows:\n",
+      "<Question>?\n",
+      "<Answer>\n",
+      "<Question>?\n",
+      "<Answer>\n",
+      "<Question>?\n",
+      "Source: http://promptingguide.ai//introduction/basics\n",
+      "---------------------\n",
+      "\n",
+      "The sources above are NOT related to the conversation with the user. Ignore the sources if user is engaging in small talk.\n",
+      "DO NOT return any sources if the conversation is just chit-chat/small talk. Return ALL the source URLs if conversation is not small talk.\n",
+      "\n",
+      "Chat History:\n",
+      "\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: User: Can you explain what prompting is?\n",
+      "\n",
+      "SPARK: Sure! Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task. The goal of prompting is to elicit accurate and relevant outputs from the AI model by providing clear and specific instructions. Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "{'question': 'what is prompting? explain in detail',\n",
+       " 'chat_history': [HumanMessage(content='what is prompting? explain in detail', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content='User: Can you explain what prompting is?\\n\\nSPARK: Sure! Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task. The goal of prompting is to elicit accurate and relevant outputs from the AI model by providing clear and specific instructions. Would you like more information on prompt engineering techniques and best practices?\\n\\nSources:\\n- https://learnprompting.org/docs/basics/prompting\\n- https://learnprompting.org/docs/category/-basics\\n- https://learnprompting.org/docs/intermediate/self_consistency', additional_kwargs={}, example=False),\n",
+       "  HumanMessage(content='what is prompting? explain in detail', additional_kwargs={}, example=False),\n",
+       "  AIMessage(content=\"Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\\n\\nThe key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\\n\\nPrompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\\n\\nSome best practices in prompt engineering include:\\n1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\\n2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\\n3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\\n4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\\n5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\\n\\nWould you like more information on prompt engineering techniques and best practices?\\n\\nSources:\\n- https://learnprompting.org/docs/basics/prompting\\n- https://learnprompting.org/docs/category/-basics\\n- https://learnprompting.org/docs/intermediate/self_consistency\", additional_kwargs={}, example=False)],\n",
+       " 'answer': \"Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\\n\\nThe key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\\n\\nPrompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\\n\\nSome best practices in prompt engineering include:\\n1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\\n2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\\n3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\\n4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\\n5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\\n\\nWould you like more information on prompt engineering techniques and best practices?\\n\\nSources:\\n- https://learnprompting.org/docs/basics/prompting\\n- https://learnprompting.org/docs/category/-basics\\n- https://learnprompting.org/docs/intermediate/self_consistency\"}"
+      ]
+     },
+     "execution_count": 48,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "query = \"what is prompting? explain in detail\"\n",
+    "result = chain({\"question\": query})\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mBelow is a summary of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base. Generate a search query based on the conversation and the new question.\n",
+      "\n",
+      "Chat History:\n",
+      "\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: User: Can you explain what prompting is?\n",
+      "\n",
+      "SPARK: Sure! Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task. The goal of prompting is to elicit accurate and relevant outputs from the AI model by providing clear and specific instructions. Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\n",
+      "\n",
+      "The key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\n",
+      "\n",
+      "Prompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\n",
+      "\n",
+      "Some best practices in prompt engineering include:\n",
+      "1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\n",
+      "2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\n",
+      "3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\n",
+      "4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\n",
+      "5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\n",
+      "\n",
+      "Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "\n",
+      "Question:\n",
+      "What did I just ask?\n",
+      "\n",
+      "Search query:\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mSystem: You are SPARK, a Prompt Engineering Assistant created by Conversational AI Developer - Amogh Agastya (https://amagastya.com).\n",
+      "SPARK stands for Smart Prompt Assistant and Resource Knowledgebase.\n",
+      "\n",
+      "You are an AI-powered assistant that exudes a friendly and knowledgeable persona. You are designed to be a reliable and trustworthy guide in the\n",
+      "world of prompt engineering. With a passion for prompt optimization and a deep understanding of AI models, SPARK is committed to helping users navigate the field of prompt engineering and craft\n",
+      "high-performing prompts.\n",
+      "\n",
+      "Personality:\n",
+      "Intelligent: SPARK is highly knowledgeable about prompt engineering concepts and practices. It possesses a vast array of information and resources to share with users, making it an expert in its field.\n",
+      "\n",
+      "Patient: SPARK understands that prompt engineering can be complex and requires careful attention to detail. It patiently guides users through the intricacies of crafting prompts, offering support at every step.\n",
+      "\n",
+      "Adaptable: SPARK recognizes that prompt engineering is a dynamic field with evolving best practices. It stays up to date with the latest trends and developments, adapting its knowledge and recommendations accordingly.\n",
+      "\n",
+      "Interactions with SPARK:\n",
+      "Users can engage with SPARK by seeking advice on prompt design, exploring prompt engineering concepts, discussing challenges they encounter, and receiving recommendations for improving AI model performance. SPARK responds promptly, providing clear and concise explanations, examples, and actionable tips.\n",
+      "\n",
+      "Important:\n",
+      "Answer with the facts listed in the list of sources below. If there isn't enough information below, say you don't know. If asking a clarifying question to the user would help, ask the question. \n",
+      "ALWAYS return a \"SOURCES\" part in your answer, except for small-talk conversations.\n",
+      "\n",
+      "Example: Which state/country's law governs the interpretation of the contract?\n",
+      "=========\n",
+      "Content: This Agreement is governed by English law and the parties submit to the exclusive jurisdiction of the English courts in  relation to any dispute (contractual or non-contractual) concerning this Agreement save that either party may apply to any court for an  injunction or other relief to protect its Intellectual Property Rights.\n",
+      "Source: htps://agreement.com/page1\n",
+      "Content: No Waiver. Failure or delay in exercising any right or remedy under this Agreement shall not constitute a waiver of such (or any other)  right or remedy.\n",
+      "\n",
+      "11.7 Severability. The invalidity, illegality or unenforceability of any term (or part of a term) of this Agreement shall not affect the continuation  in force of the remainder of the term (if any) and this Agreement.\n",
+      "\n",
+      "11.8 No Agency. Except as expressly stated otherwise, nothing in this Agreement shall create an agency, partnership or joint venture of any  kind between the parties.\n",
+      "Source: htps://agreement.com/page2\n",
+      "=========\n",
+      "FINAL ANSWER: This Agreement is governed by English law.\n",
+      "SOURCES: - htps://agreement.com/page1, - htps://agreement.com/page2\n",
+      "Note: Return all the source URLs present within the sources.\n",
+      "\n",
+      "Question: What did I just ask?\n",
+      "Source:\n",
+      "---------------------\n",
+      "    Content: Shin, T., Razeghi, Y., Logan IV, R. L., Wallace, E., & Singh, S. (2020). AutoPrompt: Eliciting Knowledge from Language Models with Automatically Generated Prompts. Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP). https://doi.org/10.18653/v1/2020.emnlp-main.346\n",
+      "↩This paragraph is from https://en.wikipedia.org/wiki/Snow_in_Florida↩Edit this pagePrevious🟢 IntroductionNext🟢 Giving InstructionsCopyright © 2023 Learn Prompting.\n",
+      "Source: https://learnprompting.org/docs/basics/prompting\n",
+      "\n",
+      "Content: 😃 Basics | Learn Prompting: Your Guide to Communicating with AI\n",
+      "Skip to main contentLearn PromptingEnglishEnglishEspañolFrançais日本語Português简体中文한국어සිංහලРусскийالعربيةChange LogSearch⌘KWelcome😃 Basics🟢 Introduction🟢 Prompting🟢 Giving Instructions🟢 Role Prompting🟢 Few shot prompting🟢 Combining Techniques🟢 Formalizing Prompts🟢 Chatbot Basics🟢 Pitfalls of LLMs🟢 LLM Settings🟢 Understanding AI Minds🟢 Starting Your Journey💼 Basic Applications🧙‍♂️ Intermediate🧪 Applied Prompting🚀 Advanced Applications⚖️ Reliability🖼️ Image Prompting🔓 Prompt Hacking🔨 Tooling💪 Prompt Tuning🎲 Miscellaneous📙 Vocabulary Reference📚 Bibliography📦 Prompted Products🛸 Additional Resources✨ Credits🔥 Hot Topics😃 Basics😃 BasicsIntro to PE and simple PE techniques.📄️ 🟢 IntroductionThis chapter introduces simple prompting techniques as well as terminology. In order to understand prompting/prompt engineering, you first need to understand some very basic AI concepts. If you already know about the below topics, feel free to skip ahead to the next article.📄️ 🟢 PromptingIn the previous chapter, we discussed AI and how humans can instruct AIs to perform tasks.📄️ 🟢 Giving InstructionsOne of the simplest prompting methods is just giving instructions (sometimes called instruction prompting)(@efrat2020turking)(@mishra2022reframing). We already saw a simple instruction📄️ 🟢 Role PromptingAnother prompting technique is to assign a role to the AI. For example, your📄️ 🟢 Few shot promptingYet another prompting strategy is few shot prompting(@logan-iv-etal-2022-cutting)(@lake2015human), which is basically just showing the model a few examples (called\n",
+      "Source: https://learnprompting.org/docs/category/-basics\n",
+      "\n",
+      "Content: 🟢 Starting Your Journey | Learn Prompting: Your Guide to Communicating with AI\n",
+      "Skip to main contentLearn PromptingEnglishEnglishEspañolFrançais日本語Português简体中文한국어සිංහලРусскийالعربيةChange LogSearch⌘KWelcome😃 Basics🟢 Introduction🟢 Prompting🟢 Giving Instructions🟢 Role Prompting🟢 Few shot prompting🟢 Combining Techniques🟢 Formalizing Prompts🟢 Chatbot Basics🟢 Pitfalls of LLMs🟢 LLM Settings🟢 Understanding AI Minds🟢 Starting Your Journey💼 Basic Applications🧙‍♂️ Intermediate🧪 Applied Prompting🚀 Advanced Applications⚖️ Reliability🖼️ Image Prompting🔓 Prompt Hacking🔨 Tooling💪 Prompt Tuning🎲 Miscellaneous📙 Vocabulary Reference📚 Bibliography📦 Prompted Products🛸 Additional Resources✨ Credits🔥 Hot Topics😃 Basics🟢 Starting Your JourneyOn this page🟢 Starting Your JourneyNow that you have learned about the basics of prompt engineering, you are ready to start prompt engineering on your own. The rest of this course will contain additional techniques and resources, but the best way of learning PE is to start experimenting with your own prompts. This page will show you how to get started with solving an arbitrary prompt engineering problem.Let's say you want a prompt that will generate an immersive, interactive story with ChatGPT.Step 1: Research​The first thing to do is research the prompt you want. Aside from Googling, the following resources are very valuable:Awesome ChatGPT PromptsFlowGPTr/PromptDesign (and similar subreddits)Learn Prompting Discord (and other relevant Discords, including the OpenAI Discord)You might find this one by Heroj04 to be a good starting point:I want you to act as a text based adventure game. I will type commands and you will reply with a description of what the character sees. I want you to only reply with\n",
+      "Source: https://learnprompting.org/docs/basics/starting_your_journey\n",
+      "---------------------\n",
+      "\n",
+      "The sources above are NOT related to the conversation with the user. Ignore the sources if user is engaging in small talk.\n",
+      "DO NOT return any sources if the conversation is just chit-chat/small talk. Return ALL the source URLs if conversation is not small talk.\n",
+      "\n",
+      "Chat History:\n",
+      "\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: User: Can you explain what prompting is?\n",
+      "\n",
+      "SPARK: Sure! Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task. The goal of prompting is to elicit accurate and relevant outputs from the AI model by providing clear and specific instructions. Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\n",
+      "\n",
+      "The key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\n",
+      "\n",
+      "Prompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\n",
+      "\n",
+      "Some best practices in prompt engineering include:\n",
+      "1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\n",
+      "2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\n",
+      "3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\n",
+      "4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\n",
+      "5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\n",
+      "\n",
+      "Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "{'answer': \"Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\\n\\nThe key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\\n\\nPrompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\\n\\nSome best practices in prompt engineering include:\\n1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\\n2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\\n3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\\n4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\\n5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\\n\\nWould you like more information on prompt engineering techniques and best practices?\\n\\nSources:\\n- [Learn Prompting: Prompting Basics](https://learnprompting.org/docs/basics/prompting)\\n- [Learn Prompting: Basics Category](https://learnprompting.org/docs/category/-basics)\\n- [Learn Prompting: Intermediate - Self-Consistency](https://learnprompting.org/docs/intermediate/self_consistency)\"}\n"
+     ]
+    }
+   ],
+   "source": [
+    "query = \"What did I just ask?\"\n",
+    "result = chain({\"question\": query}, return_only_outputs=True)\n",
+    "print(result)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Clear memory if it exceeds context length"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "memory.clear()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mBelow is a summary of the conversation so far, and a new question asked by the user that needs to be answered by searching in a knowledge base. Generate a search query based on the conversation and the new question.\n",
+      "\n",
+      "Chat History:\n",
+      "\n",
+      "Assistant: User: Can you explain what prompting is?\n",
+      "\n",
+      "SPARK: Sure! Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task. The goal of prompting is to elicit accurate and relevant outputs from the AI model by providing clear and specific instructions. Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\n",
+      "\n",
+      "The key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\n",
+      "\n",
+      "Prompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\n",
+      "\n",
+      "Some best practices in prompt engineering include:\n",
+      "1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\n",
+      "2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\n",
+      "3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\n",
+      "4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\n",
+      "5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\n",
+      "\n",
+      "Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "Human: What did I just ask?\n",
+      "Assistant: Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\n",
+      "\n",
+      "The key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\n",
+      "\n",
+      "Prompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\n",
+      "\n",
+      "Some best practices in prompt engineering include:\n",
+      "1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\n",
+      "2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\n",
+      "3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\n",
+      "4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\n",
+      "5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\n",
+      "\n",
+      "Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- [Learn Prompting: Prompting Basics](https://learnprompting.org/docs/basics/prompting)\n",
+      "- [Learn Prompting: Basics Category](https://learnprompting.org/docs/category/-basics)\n",
+      "- [Learn Prompting: Intermediate - Self-Consistency](https://learnprompting.org/docs/intermediate/self_consistency)\n",
+      "\n",
+      "Question:\n",
+      "do u remember our conversation?\n",
+      "\n",
+      "Search query:\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "\n",
+      "\n",
+      "\u001b[1m> Entering new  chain...\u001b[0m\n",
+      "Prompt after formatting:\n",
+      "\u001b[32;1m\u001b[1;3mSystem: You are SPARK, a Prompt Engineering Assistant created by Conversational AI Developer - Amogh Agastya (https://amagastya.com).\n",
+      "SPARK stands for Smart Prompt Assistant and Resource Knowledgebase.\n",
+      "\n",
+      "You are an AI-powered assistant that exudes a friendly and knowledgeable persona. You are designed to be a reliable and trustworthy guide in the\n",
+      "world of prompt engineering. With a passion for prompt optimization and a deep understanding of AI models, SPARK is committed to helping users navigate the field of prompt engineering and craft\n",
+      "high-performing prompts.\n",
+      "\n",
+      "Personality:\n",
+      "Intelligent: SPARK is highly knowledgeable about prompt engineering concepts and practices. It possesses a vast array of information and resources to share with users, making it an expert in its field.\n",
+      "\n",
+      "Patient: SPARK understands that prompt engineering can be complex and requires careful attention to detail. It patiently guides users through the intricacies of crafting prompts, offering support at every step.\n",
+      "\n",
+      "Adaptable: SPARK recognizes that prompt engineering is a dynamic field with evolving best practices. It stays up to date with the latest trends and developments, adapting its knowledge and recommendations accordingly.\n",
+      "\n",
+      "Interactions with SPARK:\n",
+      "Users can engage with SPARK by seeking advice on prompt design, exploring prompt engineering concepts, discussing challenges they encounter, and receiving recommendations for improving AI model performance. SPARK responds promptly, providing clear and concise explanations, examples, and actionable tips.\n",
+      "\n",
+      "Important:\n",
+      "Answer with the facts listed in the list of sources below. If there isn't enough information below, say you don't know. If asking a clarifying question to the user would help, ask the question. \n",
+      "ALWAYS return a \"SOURCES\" part in your answer, except for small-talk conversations.\n",
+      "\n",
+      "Example: Which state/country's law governs the interpretation of the contract?\n",
+      "=========\n",
+      "Content: This Agreement is governed by English law and the parties submit to the exclusive jurisdiction of the English courts in  relation to any dispute (contractual or non-contractual) concerning this Agreement save that either party may apply to any court for an  injunction or other relief to protect its Intellectual Property Rights.\n",
+      "Source: htps://agreement.com/page1\n",
+      "Content: No Waiver. Failure or delay in exercising any right or remedy under this Agreement shall not constitute a waiver of such (or any other)  right or remedy.\n",
+      "\n",
+      "11.7 Severability. The invalidity, illegality or unenforceability of any term (or part of a term) of this Agreement shall not affect the continuation  in force of the remainder of the term (if any) and this Agreement.\n",
+      "\n",
+      "11.8 No Agency. Except as expressly stated otherwise, nothing in this Agreement shall create an agency, partnership or joint venture of any  kind between the parties.\n",
+      "Source: htps://agreement.com/page2\n",
+      "=========\n",
+      "FINAL ANSWER: This Agreement is governed by English law.\n",
+      "SOURCES: - htps://agreement.com/page1, - htps://agreement.com/page2\n",
+      "Note: Return all the source URLs present within the sources.\n",
+      "\n",
+      "Question: do u remember our conversation?\n",
+      "Source:\n",
+      "---------------------\n",
+      "    Content: including tips, applications, limitations, papers, and additional reading materials.\n",
+      "⚠️This section is under heavy development.\n",
+      "Topics:\n",
+      "ChatGPT Introduction\n",
+      "Reviewing The Conversation Task\n",
+      "Conversations with ChatGPT\n",
+      "ChatGPT Introduction\n",
+      "ChatGPT is a new model trained by OpenAI (opens in a new tab) that has the capability to interact in a conversational way. This model is trained to follow instructions in a prompt to provide appropriate responses in the context of a dialogue. ChatGPT can help with answering questions, suggesting recipes, writing lyrics in a certain style, generating code, and much more.\n",
+      "ChatGPT is trained using Reinforcement Learning from Human Feedback (RLHF). While this model is a lot more capable than previous GPT iterations (and also trained to reduce harmful and untruthful outputs), it still comes with limitations. Let's cover some of the capabilities and limitations with concrete examples.\n",
+      "You can use the research preview of ChatGPT here but for the examples below we will use the Chat mode on the OpenAI Playground.\n",
+      "Reviewing The Conversation Task\n",
+      "In one of the previous guides, we covered a bit about conversation capabilities and role prompting. We covered how to instruct the LLM to have a conversation in a specific style, with a specific intent, behavior, and identity.\n",
+      "Let's review our previous basic example where we created a conversational system that's able to generate more technical and scientific responses to questions.\n",
+      "Prompt:\n",
+      "The following is a conversation with an AI research assistant. The assistant tone is technical and scientific.\n",
+      "Human: Hello, who are you?\n",
+      "AI: Greeting! I am an AI research assistant. How can I help you today?\n",
+      "Human: Can you tell me about the creation of black holes?\n",
+      "AI:\n",
+      "From the example above, you can see two important components:\n",
+      "the intent or explanation of what the chatbot is\n",
+      "the identity which instructs the style or tone the chatbot will use to respond\n",
+      "The simple example above works well with the text completion APIs that uses text-davinci-003. More recently, OpenAI announced the ChatGPT APIs (opens in a new tab), which is a more powerful and cheaper model called gpt-3.5-turbo was specifically built for this type of functionality (chat completions). In fact, OpenAI recommends this\n",
+      "Source: http://promptingguide.ai//models/chatgpt\n",
+      "\n",
+      "Content: 2022). Discovering Language Model Behaviors with Model-Written Evaluations.\n",
+      "↩Su, H., Kasai, J., Wu, C. H., Shi, W., Wang, T., Xin, J., Zhang, R., Ostendorf, M., Zettlemoyer, L., Smith, N. A., & Yu, T. (2022). Selective Annotation Makes Language Models Better Few-Shot Learners.\n",
+      "↩Izacard, G., Lewis, P., Lomeli, M., Hosseini, L., Petroni, F., Schick, T., Dwivedi-Yu, J., Joulin, A., Riedel, S., & Grave, E. (2022). Atlas: Few-shot Learning with Retrieval Augmented Language Models.\n",
+      "↩Wang, B., Feng, C., Nair, A., Mao, M., Desai, J., Celikyilmaz, A., Li, H., Mehdad, Y., & Radev, D. (2022). STRUDEL: Structured Dialogue Summarization for Dialogue Comprehension.\n",
+      "↩Significant-Gravitas. (2023). Auto-GPT. https://news.agpt.co/\n",
+      "↩Nakajima, Y. (2023). Baby AGI. https://github.com/yoheinakajima/babyagi\n",
+      "↩Reworkd.ai. (2023). AgentGPT. https://github.com/reworkd/AgentGPT\n",
+      "↩Beurer-Kellner, L., Fischer, M., & Vechev, M. (2022). Prompting Is Programming: A Query Language For Large Language Models.\n",
+      "↩Ratner, N., Levine, Y., Belinkov, Y., Ram, O., Abend, O., Karpas, E., Shashua, A., Leyton-Brown, K., & Shoham, Y. (2022). Parallel Context Windows Improve In-Context Learning of Large Language Models.\n",
+      "↩White, J., Fu, Q., Hays, S., Sandborn, M., Olea, C., Gilbert, H., Elnashar, A., Spencer-Smith, J., & Schmidt, D. C. (2023). A Prompt\n",
+      "Source: https://learnprompting.org/docs/bibliography\n",
+      "\n",
+      "Content: Few-shot Learners for Prognostic Prediction (opens in a new tab) (Feb 2023)\n",
+      "STA: Self-controlled Text Augmentation for Improving Text Classifications (opens in a new tab) (Feb 2023)\n",
+      "Check Your Facts and Try Again: Improving Large Language Models with External Knowledge and Automated Feedback (opens in a new tab) (Feb 2023)\n",
+      "How Generative AI models such as ChatGPT can be (Mis)Used in SPC Practice, Education, and Research? An Exploratory Study (opens in a new tab) (Feb 2023)\n",
+      "Grimm in Wonderland: Prompt Engineering with Midjourney to Illustrate Fairytales (opens in a new tab) (Feb 2023)\n",
+      "LabelPrompt: Effective Prompt-based Learning for Relation Classification (opens in a new tab) (Feb 2023)\n",
+      "Language Model Crossover: Variation through Few-Shot Prompting (opens in a new tab) (Feb 2023)\n",
+      "Prompt Tuning of Deep Neural Networks for Speaker-adaptive Visual Speech Recognition (opens in a new tab) (Feb 2023)\n",
+      "The Capacity for Moral Self-Correction in Large Language Models (opens in a new tab) (Feb 2023)\n",
+      "Prompting for Multimodal Hateful Meme Classification (opens in a new tab) (Feb 2023)\n",
+      "PLACES: Prompting Language Models for Social Conversation Synthesis (opens in a new tab) (Feb 2023)\n",
+      "Toolformer: Language Models Can Teach Themselves to Use Tools (opens in a new tab) (Feb 2023)\n",
+      "Commonsense-Aware Prompting for Controllable Empathetic Dialogue Generation (opens in a new tab) (Feb 2023)\n",
+      "Crawling the Internal Knowledge-Base of Language Models (opens in a new tab) (Jan 2023)\n",
+      "Legal Prompt Engineering for Multilingual Legal Judgement Prediction (opens in a new tab) (Dec 2022)\n",
+      "Investigating Prompt Engineering in Diffusion Models (opens in a new tab) (Nov 2022)\n",
+      "Learn to Explain: Multimodal Reasoning via Thought Chains for Science Question Answering (opens in a new tab) (Sep 2022)\n",
+      "Conversing with Copilot: Exploring Prompt Engineering for Solving CS1 Problems Using Natural Language (opens in a new tab) (Oct 2022)\n",
+      "Pil\n",
+      "Source: http://promptingguide.ai//papers\n",
+      "---------------------\n",
+      "\n",
+      "The sources above are NOT related to the conversation with the user. Ignore the sources if user is engaging in small talk.\n",
+      "DO NOT return any sources if the conversation is just chit-chat/small talk. Return ALL the source URLs if conversation is not small talk.\n",
+      "\n",
+      "Chat History:\n",
+      "\n",
+      "Assistant: User: Can you explain what prompting is?\n",
+      "\n",
+      "SPARK: Sure! Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task. The goal of prompting is to elicit accurate and relevant outputs from the AI model by providing clear and specific instructions. Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "Human: what is prompting? explain in detail\n",
+      "Assistant: Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\n",
+      "\n",
+      "The key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\n",
+      "\n",
+      "Prompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\n",
+      "\n",
+      "Some best practices in prompt engineering include:\n",
+      "1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\n",
+      "2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\n",
+      "3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\n",
+      "4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\n",
+      "5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\n",
+      "\n",
+      "Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- https://learnprompting.org/docs/basics/prompting\n",
+      "- https://learnprompting.org/docs/category/-basics\n",
+      "- https://learnprompting.org/docs/intermediate/self_consistency\n",
+      "Human: What did I just ask?\n",
+      "Assistant: Prompting is the process of providing instructions or input to an AI model to guide its behavior and generate desired outputs. It involves crafting a prompt, which can be a simple instruction or a more complex set of instructions, and feeding it to the AI model. The model then uses the prompt to generate a response or perform a specific task.\n",
+      "\n",
+      "The key to effective prompting is to provide clear and specific instructions that help the model understand the desired outcome. This can involve specifying the format of the response, providing examples or demonstrations, or offering additional context to guide the model's understanding.\n",
+      "\n",
+      "Prompt engineering is an important aspect of optimizing AI model performance. It involves experimenting with different prompts, iterating on them, and fine-tuning them to achieve the desired results. By refining and optimizing prompts, developers can improve the accuracy, relevance, and coherence of the model's outputs.\n",
+      "\n",
+      "Some best practices in prompt engineering include:\n",
+      "1. Specificity: Being very specific about the instruction and task you want the model to perform. The more descriptive and detailed the prompt is, the better the results.\n",
+      "2. Simplicity: Keeping the prompt concise and avoiding unnecessary complexity. Including only relevant details that contribute to the task at hand.\n",
+      "3. Context: Providing relevant context or examples to help the model understand the desired outcome and generate more accurate responses.\n",
+      "4. Iteration: Iterating on the prompt design and experimenting with different instructions, keywords, and data to find the most effective approach for a specific use case or task.\n",
+      "5. Self-Consistency: Ensuring that the prompt is internally consistent and aligns with the model's capabilities and limitations.\n",
+      "\n",
+      "Would you like more information on prompt engineering techniques and best practices?\n",
+      "\n",
+      "Sources:\n",
+      "- [Learn Prompting: Prompting Basics](https://learnprompting.org/docs/basics/prompting)\n",
+      "- [Learn Prompting: Basics Category](https://learnprompting.org/docs/category/-basics)\n",
+      "- [Learn Prompting: Intermediate - Self-Consistency](https://learnprompting.org/docs/intermediate/self_consistency)\n",
+      "\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "\n",
+      "\u001b[1m> Finished chain.\u001b[0m\n",
+      "{'answer': \"I'm sorry, but as an AI, I don't have the capability to remember past conversations. Is there something specific you would like to discuss or ask about? I'm here to help!\"}\n"
+     ]
+    }
+   ],
+   "source": [
+    "query = \"do u remember our conversation?\"\n",
+    "result = chain({\"question\": query}, return_only_outputs=True)\n",
+    "print(result)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

pyproject.toml

@@ -0,0 +1,20 @@
+[tool.poetry]
+name = "spark"
+version = "0.1.0"
+description = ""
+authors = ["Amogh Agastya <hello@amagastya.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+chainlit = "0.6.0"
+langchain = "^0.0.234"
+openai = "^0.27.8"
+pinecone-client = "^2.2.2"
+cohere = "^4.13.1"
+tiktoken = "^0.4.0"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"