Integrations/Langchain/Agents/Doc-retrieve_using_Langchain-ReAct_Agent.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<td>\n",
    "   <a target=\"_blank\" href=\"https://www.clarifai.com/\" ><img src=\"https://upload.wikimedia.org/wikipedia/commons/b/bc/Clarifai_Logo_FC_Web.png\" width=256/></a>\n",
    "</td>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<td>\n",
    "<a href=\"https://colab.research.google.com/github/Clarifai/examples/blob/main/Integrations/Langchain/Agents/Doc-retrieve_using_Langchain-ReAct_Agent.ipynb\" target=\"_blank\"><img\n",
    "src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Colab\"></a>\n",
    "</td>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "roc5ea-clgIi"
   },
   "source": [
    "# Clarifai Doc-Retrieval using React Docstore\n",
    "\n",
    "The notebook gives a walkthrough to build a Doc Q/A using clarifai vectorstore and langchain's React Docstore with Webscraped docs of Clarifai. This enables the user to retrive info regarding the Docs of Clarifai.\n",
    "\n",
    "\n",
    "The steps are as follows:\n",
    "\n",
    "- Websracping from Clarifai Docs Website.\n",
    "- Processing and Storing the Docs in Clarifai Vectorstore.\n",
    "- Building a React Agent to search in the Clarifai vectorstore.\n",
    "- Using the Agent to answer for User queries related to Clarifai."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agents\n",
    "\n",
    "The core idea of agents is to use a language model to choose a sequence of actions to take. In agents, a language model is used as a reasoning engine to determine which actions to take and in which order.\n",
    "\n",
    "To know more on Agents: https://python.langchain.com/docs/modules/agents/\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KqjkG_y794nk"
   },
   "source": [
    "### Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "I7ERa_Fn7s32"
   },
   "outputs": [],
   "source": [
    "!pip install -U langchain\n",
    "!pip install clarifai"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize your PAT key as environment variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5SatdHPtC4-t"
   },
   "outputs": [],
   "source": [
    "#Note we also have an option to pass the PAT key directly while calling the classes, so user can either intialize it as env variable or arguments.\n",
    "import os\n",
    "os.environ[\"CLARIFAI_PAT\"]=\"YOUR_CLARIFAI_PAT\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Note: Guide to get your [PAT](https://docs.clarifai.com/clarifai-basics/authentication/personal-access-tokens)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uZvF_tkNj9ZK"
   },
   "source": [
    "### Web Scraping\n",
    "\n",
    "Extracting Docs form https://docs.clarifai.com/ using BeautifulSoup\n",
    "\n",
    "**Note: Storing only some pages(Portal Guide) of the website for demo purpose**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "t9ORHHzBwbEl"
   },
   "outputs": [],
   "source": [
    "#Getting the URLs associated with Portal Guide in https://docs.clarifai.com\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "import re\n",
    "\n",
    "url = 'https://docs.clarifai.com/'\n",
    "reqs = requests.get(url)\n",
    "soup = BeautifulSoup(reqs.text, 'html.parser')\n",
    "\n",
    "urls = []\n",
    "for link in soup.find_all('a', attrs={'href': re.compile(\"^/portal\")}):\n",
    "    portal_url = 'https://docs.clarifai.com'+link.get('href')\n",
    "    sub_reqs = requests.get(portal_url)\n",
    "    soup_1 = BeautifulSoup(sub_reqs.text, 'html.parser')\n",
    "    re_match = portal_url.split('/')[-2]\n",
    "    for sublink in soup_1.find_all('a', attrs={'href': re.compile(\"^/portal-guide/\"+re_match)}):\n",
    "        portal_sub_url = sublink.get('href')\n",
    "        if portal_sub_url.startswith('/'):\n",
    "            urls.append('https://docs.clarifai.com'+portal_sub_url)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Langchain's HTMLHeaderTextSplitter to split the docs based on the headers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "KAwoy2O8j9ZK"
   },
   "outputs": [],
   "source": [
    "#Splitting the docs based on headers. Every doc corresponds to a content under a header\n",
    "from langchain.document_loaders import AsyncHtmlLoader\n",
    "from langchain.text_splitter import HTMLHeaderTextSplitter\n",
    "\n",
    "\n",
    "headers_to_split_on = [\n",
    "    (\"h1\", \"Header 1\"),\n",
    "    (\"h2\", \"Header 2\"),\n",
    "    (\"h3\", \"Header 3\"),\n",
    "]\n",
    "\n",
    "def parse_website(urls):\n",
    "    final_docs = []\n",
    "    loader = AsyncHtmlLoader(urls)\n",
    "    docs = loader.load()\n",
    "    html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)\n",
    "    #looping the URLS\n",
    "    for doc in docs:\n",
    "        try:\n",
    "            html_header_splits = html_splitter.split_text(doc.page_content)\n",
    "            for header_doc in html_header_splits:\n",
    "                if len(header_doc.metadata)>0:\n",
    "                    if len(header_doc.page_content)>300:\n",
    "                        header_doc.metadata.update(doc.metadata)\n",
    "                        final_docs.append(header_doc)\n",
    "        except:\n",
    "            pass\n",
    "    return final_docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XocDpZwlj9ZK",
    "outputId": "d378eec7-21ac-49a2-f779-db8fc65df13a"
   },
   "outputs": [],
   "source": [
    "#parsing the docs\n",
    "parsed_docs = parse_website(urls)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JS6i2RkMj9ZL"
   },
   "source": [
    "## Uploading the Docs to Clarifai VectorStore\n",
    "\n",
    "- Clarifai has inbuilt vectorstore in its application. \n",
    "- When input is uploaded into the app, it would convert it into embeddings and store it in the vectorstore.\n",
    "\n",
    "To know more about Clarifai Vectorstore: https://python.langchain.com/docs/integrations/vectorstores/clarifai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "f6NWUT22j9ZL"
   },
   "outputs": [],
   "source": [
    "#importing Clarifai Vectorstore from langchain\n",
    "from langchain.vectorstores import Clarifai as Clarifaivectorstore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 384
    },
    "id": "V4t4rHqDj9ZL",
    "outputId": "33609bb8-79da-44e5-94a5-a305851c98d8"
   },
   "outputs": [],
   "source": [
    "clarifai_vector_db = Clarifaivectorstore.from_documents(\n",
    "    user_id=\"user_id\",\n",
    "    app_id= \"app_id\",\n",
    "    documents = parsed_docs,\n",
    "    number_of_docs=1\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PUaj_BbCj9ZL"
   },
   "source": [
    "## Retrievar function(Custom Search function for Docstore)\n",
    "\n",
    "Refer: https://python.langchain.com/docs/modules/agents/agent_types/react_docstore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "gAzessknj9ZL"
   },
   "outputs": [],
   "source": [
    "from langchain.llms import Clarifai as Clarifaillm\n",
    "from langchain.retrievers.multi_query import MultiQueryRetriever"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use several language models from [clarifai](https://clarifai.com/explore/models?filterData=%5B%7B%22field%22%3A%22use_cases%22%2C%22value%22%3A%5B%22llm%22%5D%7D%5D&page=1&perPage=24) platform."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Clarifai LLM for retriever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Model URL from Clarifai Community\n",
    "MODEL_URL = \"https://clarifai.com/openai/chat-completion/models/GPT-4\"\n",
    "\n",
    "llm=Clarifaillm(model_url= MODEL_URL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MultiQueryRetriever\n",
    "\n",
    "- The MultiQueryRetriever automates the process of prompt tuning by using an LLM to generate multiple queries from different perspectives for a given user input query.\n",
    "- By generating multiple perspectives on the same question, the MultiQueryRetriever might be able to overcome some of the limitations of the distance-based retrieval and get a richer set of results.\n",
    "\n",
    "To know more on MultiQueryRetriever: https://python.langchain.com/docs/modules/data_connection/retrievers/MultiQueryRetriever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "uR4CZX5kj9ZL"
   },
   "outputs": [],
   "source": [
    "retriever_from_llm = MultiQueryRetriever.from_llm(\n",
    "    retriever=clarifai_vector_db.as_retriever(), llm=llm\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Custom Lookup function for the React agent\n",
    "\n",
    "- This function will retrieve the similar documents based on the similarity between the given query and the uploaded documents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qz-EKxvnj9ZL"
   },
   "outputs": [],
   "source": [
    "def doc_lookup(search_query):\n",
    "    unique_docs = retriever_from_llm.get_relevant_documents(query=search_query)\n",
    "    return unique_docs[0].page_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QCHL-IyUj9ZL"
   },
   "outputs": [],
   "source": [
    "lookup_function = doc_lookup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## React Docstore Agent\n",
    "\n",
    "This agent uses the ReAct framework to interact with a docstore. This agent is equivalent to the original [ReAct paper](https://arxiv.org/pdf/2210.03629.pdf), specifically the Wikipedia example.\n",
    "\n",
    "https://python.langchain.com/docs/modules/agents/agent_types/react_docstore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import necessary libraries.\n",
    "import langchain\n",
    "from langchain.agents import AgentType, Tool, initialize_agent\n",
    "from langchain.agents.react.base import DocstoreExplorer\n",
    "from langchain.docstore import DocstoreFn\n",
    "from langchain.llms import Clarifai as Clarifaillm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing the tools for the agent\n",
    "\n",
    "To know more on tools: https://python.langchain.com/docs/modules/agents/tools/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "cemVjYdNj9ZL"
   },
   "outputs": [],
   "source": [
    "docstore = DocstoreExplorer(DocstoreFn(lookup_fn=lookup_function))\n",
    "tools = [\n",
    "    Tool(\n",
    "        name=\"Search\",\n",
    "        func=docstore.search,\n",
    "        description=\"useful for when you need to ask with search\",\n",
    "    ),\n",
    "    Tool(\n",
    "        name=\"Lookup\",\n",
    "        func=docstore.lookup,\n",
    "        description=\"useful for when you need to ask with lookup\",\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initializing the agent with Clarifai LLM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### GPT-4\n",
    "OpenAI's GPT-4 is a generative language model (GLM) that provides insightful responses. As a state-of-the-art large language model (LLM), ChatGPT generates contextually relevant text.\n",
    "\n",
    "You can use several language models from [clarifai](https://clarifai.com/explore/models?filterData=%5B%7B%22field%22%3A%22use_cases%22%2C%22value%22%3A%5B%22llm%22%5D%7D%5D&page=1&perPage=24) platform."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Model URL from Clarifai Community\n",
    "MODEL_URL = \"https://clarifai.com/openai/chat-completion/models/GPT-4\"\n",
    "\n",
    "llm=Clarifaillm(model_url=MODEL_URL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#initializing the agent\n",
    "react = initialize_agent(tools, llm, agent=AgentType.REACT_DOCSTORE, verbose=True,handle_parsing_errors=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Custom Promt Template\n",
    "\n",
    "- Here we are tweaking the Prompt Template of the LLM to leverage the agent for our specific use case.\n",
    "- Below is an example of giving our own Prompt Template for better accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Defining the Template\n",
    "CUSTOM_PROMPT_TEMPLATE = \"\"\"Question: How to make prediction with a model in Clarifai?\n",
    "Thought: I need to search how to make prediction with a model in clarifai docs.\n",
    "Action: Search[How to make prediction with a model]\n",
    "Observation: These are the six key steps in the process for building new models:  \\nGathering data—Involves collecting data either from Clarifai’s data reserves or collecting your own unique datasets.Building a visual dictionary—Involves defining the process and the success criteria.Preparing or ‘cleaning’ the data—This step prepares the data for use in training the model. You can recognize important variables or visual features, and check for data imbalances that could impact the predictions of your model.Training the model—Involves using a process called training to “teach” the model what it will eventually predict on, based on the data you prepared. This happens over many interactions, improving accuracy.\n",
    "Thought: It explains about the process of building new models. I need to search how to make prediction with a model in clarifai docs.\n",
    "Action: Search[Model Prediction]\n",
    "Observation: You can use the Clarifai portal to analyze your inputs and understand what's inside of them. The portal will return a list of concepts with corresponding probabilities of how likely it is that these concepts are contained within the provided inputs.\n",
    "Predictions are ready the moment you upload an input. You can make predictions using custom or public models and workflows. You can search for your preferred model on the Community platform and use it to make predictions.\n",
    "Thought: It explains about how to make prediction with a model. So this is the answer.\n",
    "Action: Finish[So to make prediction with a model, Use the clarifai portal to analyze the inputs and you can use custom or public models to make predictions.]\n",
    "\n",
    "Question: How to create workflow in Clarifai?\n",
    "Thought: I need to search how to create  a workflow in clarifai docs.\n",
    "Action: Search[How to create workflow?]\n",
    "Observation: To build a workflow, just grab a model from the left-hand sidebar and drag it onto your workspace. This model will automatically be configured as a node in your workflow. Once a node is added to your workflow, you can configure the model parameters in the right-hand sidebar.  \\nThe models in your workflow will automatically connect when they are placed near each other. You can also grab the node connectors on each model and configure your workflow nodes manually.\n",
    "Thought: It explains about the process of creating a workflow. So this is the answer.\n",
    "Action: Finish[Grab a model from the left-hand sidebar and drag it into your workspace. Once a node is added, you can configure the parameters in the right-hand sidebar. You can also grab the node connectors and configure your nodes manually.]\n",
    "\n",
    "Question: How to create moduels in Clarifai?\n",
    "Thought: I need to search how to create  a module in clarifai docs.\n",
    "Action: Search[How to create workflow?]\n",
    "Observation: To create a new module, go to the individual page of your application. Then, select the Modules option on the collapsible left sidebar.You'll be redirected to the Modules manager page, where you can create new modules and view already created ones.Click the Create Module button at the upper-right corner of the page.\n",
    "Thought: It explains about the process of creating a workflow. So this is the answer.\n",
    "Action: Finish[1) Go to individual page of you application. 2) Select the Modules option on the collapsible left sidebar. 3) Action: Finish[1) Go to individual page of you application. 2) Select the Modules option on the collapsible left sidebar. 3) reate Module button at the upper-right corner of the page.]\n",
    "\n",
    "Question: {input}\n",
    "{agent_scratchpad}\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assiging our own Custom Prompt Template to the Agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question: How to make prediction with a model in Clarifai?\n",
      "Thought: I need to search how to make prediction with a model in clarifai docs.\n",
      "Action: Search[How to make prediction with a model]\n",
      "Observation: These are the six key steps in the process for building new models:  \n",
      "Gathering data—Involves collecting data either from Clarifai’s data reserves or collecting your own unique datasets.Building a visual dictionary—Involves defining the process and the success criteria.Preparing or ‘cleaning’ the data—This step prepares the data for use in training the model. You can recognize important variables or visual features, and check for data imbalances that could impact the predictions of your model.Training the model—Involves using a process called training to “teach” the model what it will eventually predict on, based on the data you prepared. This happens over many interactions, improving accuracy.\n",
      "Thought: It explains about the process of building new models. I need to search how to make prediction with a model in clarifai docs.\n",
      "Action: Search[Model Prediction]\n",
      "Observation: You can use the Clarifai portal to analyze your inputs and understand what's inside of them. The portal will return a list of concepts with corresponding probabilities of how likely it is that these concepts are contained within the provided inputs.\n",
      "Predictions are ready the moment you upload an input. You can make predictions using custom or public models and workflows. You can search for your preferred model on the Community platform and use it to make predictions.\n",
      "Thought: It explains about how to make prediction with a model. So this is the answer.\n",
      "Action: Finish[So to make prediction with a model, Use the clarifai portal to analyze the inputs and you can use custom or public models to make predictions.]\n",
      "\n",
      "Question: How to create workflow in Clarifai?\n",
      "Thought: I need to search how to create  a workflow in clarifai docs.\n",
      "Action: Search[How to create workflow?]\n",
      "Observation: To build a workflow, just grab a model from the left-hand sidebar and drag it onto your workspace. This model will automatically be configured as a node in your workflow. Once a node is added to your workflow, you can configure the model parameters in the right-hand sidebar.  \n",
      "The models in your workflow will automatically connect when they are placed near each other. You can also grab the node connectors on each model and configure your workflow nodes manually.\n",
      "Thought: It explains about the process of creating a workflow. So this is the answer.\n",
      "Action: Finish[Grab a model from the left-hand sidebar and drag it into your workspace. Once a node is added, you can configure the parameters in the right-hand sidebar. You can also grab the node connectors and configure your nodes manually.]\n",
      "\n",
      "Question: How to create moduels in Clarifai?\n",
      "Thought: I need to search how to create  a module in clarifai docs.\n",
      "Action: Search[How to create workflow?]\n",
      "Observation: To create a new module, go to the individual page of your application. Then, select the Modules option on the collapsible left sidebar.You'll be redirected to the Modules manager page, where you can create new modules and view already created ones.Click the Create Module button at the upper-right corner of the page.\n",
      "Thought: It explains about the process of creating a workflow. So this is the answer.\n",
      "Action: Finish[1) Go to individual page of you application. 2) Select the Modules option on the collapsible left sidebar. 3) Action: Finish[1) Go to individual page of you application. 2) Select the Modules option on the collapsible left sidebar. 3) reate Module button at the upper-right corner of the page.]\n",
      "\n",
      "Question: {input}\n",
      "{agent_scratchpad}\n"
     ]
    }
   ],
   "source": [
    "react.agent.llm_chain.prompt.template = CUSTOM_PROMPT_TEMPLATE\n",
    "print(react.agent.llm_chain.prompt.template) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interacting with the Docstore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 385
    },
    "id": "6l72SwI9j9ZL",
    "outputId": "406fe792-09a3-4f45-e4aa-7dd2f4d08391"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\u001b[1m> Entering new AgentExecutor chain...\u001b[0m\n",
      "\u001b[32;1m\u001b[1;3mThought: I need to search how to install a module in clarifai docs.\n",
      "Action: Search[How to install module in Clarifai]\u001b[0m"
     ]
    },
    {
     "data": {
      "text/html": [
       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">2023-12-26 21:55:47 </span><span style=\"color: #000080; text-decoration-color: #000080\">INFO    </span> INFO:langchain.retrievers.multi_query:Generated queries: <span style=\"font-weight: bold\">[</span><span style=\"color: #008000; text-decoration-color: #008000\">'What are</span> <a href=\"file:///Users/sanjay/virtualenv/v1/lib/python3.9/site-packages/langchain/retrievers/multi_query.py\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">multi_query.py</span></a><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">:</span><a href=\"file:///Users/sanjay/virtualenv/v1/lib/python3.9/site-packages/langchain/retrievers/multi_query.py#194\" target=\"_blank\"><span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">194</span></a>\n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008000; text-decoration-color: #008000\">the steps to add a module in Clarifai?'</span>, <span style=\"color: #008000; text-decoration-color: #008000\">'Can you guide me through </span> <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                  </span>\n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008000; text-decoration-color: #008000\">the process of installing a module on Clarifai?'</span>, <span style=\"color: #008000; text-decoration-color: #008000\">\"What's the </span>      <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                  </span>\n",
       "<span style=\"color: #7fbfbf; text-decoration-color: #7fbfbf\">                    </span>         <span style=\"color: #008000; text-decoration-color: #008000\">procedure for setting up a module in Clarifai?\"</span><span style=\"font-weight: bold\">]</span>                    <span style=\"color: #7f7f7f; text-decoration-color: #7f7f7f\">                  </span>\n",
       "</pre>\n"
      ],
      "text/plain": [
       "\u001b[2;36m2023-12-26 21:55:47\u001b[0m\u001b[2;36m \u001b[0m\u001b[34mINFO    \u001b[0m INFO:langchain.retrievers.multi_query:Generated queries: \u001b[1m[\u001b[0m\u001b[32m'What are\u001b[0m \u001b]8;id=268033;file:///Users/sanjay/virtualenv/v1/lib/python3.9/site-packages/langchain/retrievers/multi_query.py\u001b\\\u001b[2mmulti_query.py\u001b[0m\u001b]8;;\u001b\\\u001b[2m:\u001b[0m\u001b]8;id=350357;file:///Users/sanjay/virtualenv/v1/lib/python3.9/site-packages/langchain/retrievers/multi_query.py#194\u001b\\\u001b[2m194\u001b[0m\u001b]8;;\u001b\\\n",
       "\u001b[2;36m                    \u001b[0m         \u001b[32mthe steps to add a module in Clarifai?'\u001b[0m, \u001b[32m'Can you guide me through \u001b[0m \u001b[2m                  \u001b[0m\n",
       "\u001b[2;36m                    \u001b[0m         \u001b[32mthe process of installing a module on Clarifai?'\u001b[0m, \u001b[32m\"What's the \u001b[0m      \u001b[2m                  \u001b[0m\n",
       "\u001b[2;36m                    \u001b[0m         \u001b[32mprocedure for setting up a module in Clarifai?\"\u001b[0m\u001b[1m]\u001b[0m                    \u001b[2m                  \u001b[0m\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Observation: \u001b[36;1m\u001b[1;3mThere are two steps for creating modules:  \n",
      "1. Creating a module and its versions—This is the process of authoring a new module and registering it on our AI lake. At the end of this process, it won’t be interactable with our UI just yet; the next process of installing the module version into the sidebar handles that. Creating a module requires familiarity with GitHub and Python development. You’ll start by coding your module, which is a great experience even locally, and then creating the module in the Clarifai platform, where we will fully host it for you. Each time you update the code of your module, you can simply create a new module version to capture that change.  \n",
      "2. Installing a module—Once a module is created (or you find an already created one in our Community platform, or from your team members), you can install the module. This process will register the module in your Clarifai app, and it will appear on the portal’s collapsible left sidebar so that you can interact with it.\u001b[0m\n",
      "Thought:\u001b[32;1m\u001b[1;3mIt explains about the process of installing a module. So this is the answer.\n",
      "Action: Finish[To install a module, you need to register it on the Clarifai platform. Once a module is created, you can install the module. This process will register the module in your Clarifai app, and it will appear on the portal’s collapsible left sidebar so that you can interact with it.]\u001b[0m\n",
      "\n",
      "\u001b[1m> Finished chain.\u001b[0m\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'To install a module, you need to register it on the Clarifai platform. Once a module is created, you can install the module. This process will register the module in your Clarifai app, and it will appear on the portal’s collapsible left sidebar so that you can interact with it.'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "question = \"How to install a module in Clarifai?\"\n",
    "react.run(question)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clarifai Resources\n",
    "\n",
    "**Website**: [https://www.clarifai.com](https://www.clarifai.com/)\n",
    "\n",
    "**Demo**: [https://clarifai.com/demo](https://clarifai.com/demo)\n",
    "\n",
    "**Sign up for a free Account**: [https://clarifai.com/signup](https://clarifai.com/signup)\n",
    "\n",
    "**Developer Guide**: [https://docs.clarifai.com](https://docs.clarifai.com/)\n",
    "\n",
    "**Clarifai Community**: [https://clarifai.com/explore](https://clarifai.com/explore)\n",
    "\n",
    "**Python SDK Docs**: [https://docs.clarifai.com/python-sdk/api-reference](https://docs.clarifai.com/python-sdk/api-reference)\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}