argocd-operator-chat-bot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "edaeb877-99b1-4492-b94a-666332f54f98",
   "metadata": {},
   "source": [
    "# Chatbot for ArgoCD Operator\n",
    "\n",
    "This is an attempt to use an AI-powered chatbot to interact with the argocd-operator codebase.\n",
    "\n",
    "## Why?\n",
    "\n",
    "I was brainstorming ideas to automate CVE triage. The idea of a system that understands a CVE, analyzes it in a codebase to check if it is affected, and provides patches, sounded interesting, so I decided to give it a try.\n",
    "\n",
    "## How?\n",
    "\n",
    "LLMs(Large Language Model) are generally trained on general-purpose language understanding and generation. However they can be used to to perform domain specific tasks by providing them domain knowledge. This can be done using fine-tuning or RAG(Retrieval-augmented generation).\n",
    "\n",
    "I decided to used RAG technique for providing operator specific knowledge to LLM as fine-tuning requires creation of a structured dataset.\n",
    "\n",
    "### Chatbot working\n",
    "\n",
    "The argocd-operator specific knowledge is stored into a vector database which is retrieved based on provided query and passed as context along with query to LLM to generate an answer.\n",
    "\n",
    "#### Data indexing\n",
    "\n",
    "The operator knowledge i.e source code & github issues are are converted into vector embeddings and stored into database.\n",
    "\n",
    "![rag_indexing](https://python.langchain.com/assets/images/rag_indexing-8160f90a90a33253d0154659cf7d453f.png ) (Source: python.langchain.com)\n",
    "\n",
    "#### Data retrieval\n",
    "\n",
    "The chatbot will retrieve the data using vector similarity for provided query and pass it as context to the LLM to answer the query. \n",
    "![rag_retrieval_generation](https://python.langchain.com/assets/images/rag_retrieval_generation-1046a4668d6bb08786ef73c56d4f228a.png) (Source: python.langchain.com)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89a5677a-cea5-473f-b210-12fc2cb18726",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Implementation\n",
    "\n",
    "I have used `Langchain` framework to create the chatbot.  \n",
    "The LLM models used are\n",
    "1. BERT based `sentence-t5-base-nlpl-code_search_net` from [huggingfaces](https://huggingface.co/krlvi/sentence-t5-base-nlpl-code_search_net).  \n",
    "   This model has been trained on the with the code_search_net dataset and is used to generate embeddings to store in vector db.\n",
    "3. GPT based `gpt4all-falcon-q4_0.gguf` from [gpt4all.io](https://gpt4all.io/index.html).  \n",
    "   This model is used for conversations and answering questions.\n",
    "\n",
    "Refer [Chat Results](#chat-results) section for result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89b99453-0ca8-42d7-b45c-2946850c575d",
   "metadata": {},
   "source": [
    "### Data indexing\n",
    "\n",
    "The argocd-operator code and github issues are stored under `data/` directory in this repository. The github data is scrapped using [ghi-scraper](https://github.com/agateau/ghi-scraper) and processed using `json-to-text.py` helper script from this repository.\n",
    "\n",
    "#### Load raw data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ed12740a-3931-479e-8176-3ad16b03e35f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "couldn't load  icon.png\n",
      "couldn't load  logo.png\n",
      "couldn't load  login_via_keycloak.png\n",
      "couldn't load  login_with_openshift.png\n",
      "couldn't load  Keycloak_Manageaccount.png\n",
      "couldn't load  Keycloak_ChangePassword.png\n"
     ]
    }
   ],
   "source": [
    "from langchain.docstore.document import Document\n",
    "import os\n",
    "\n",
    "folder_name = \"data\"\n",
    "\n",
    "documents = []\n",
    "for root, dirs, files in os.walk(folder_name):\n",
    "    for file in files:\n",
    "        try:\n",
    "            with open(os.path.join(root, file), \"r\", encoding=\"utf-8\") as o:\n",
    "                code = o.readlines()\n",
    "                d = Document(page_content=\"\\n\".join(code), metadata={\"source\": os.path.join(root, file)})\n",
    "                documents.append(d)\n",
    "        except UnicodeDecodeError:\n",
    "            print(\"couldn't load \", file)\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d7ea1ed4-b1d5-458b-8144-ad3947a80abd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "783"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(documents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6a17ad8-dc6d-4468-9584-8d6ee91bf380",
   "metadata": {},
   "source": [
    "#### Store data in vector db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4135c75a-e4ce-48d2-ba99-a3e48e222786",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.embeddings import HuggingFaceEmbeddings\n",
    "from langchain.vectorstores import Chroma\n",
    "\n",
    "hfemb = HuggingFaceEmbeddings(model_name=\"krlvi/sentence-t5-base-nlpl-code_search_net\")\n",
    "persist_directory = \"db\"\n",
    "db = Chroma.from_documents(documents, hfemb, persist_directory=persist_directory)\n",
    "db.persist()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df80c9cd-c745-4fce-849c-8d9cd3b91d3d",
   "metadata": {},
   "source": [
    "### Data retrieval\n",
    "\n",
    "Load the vector db with operator knowledge and create a langchain retriever.\n",
    "\n",
    "#### Load vector db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "af10c68d-1b02-43c8-acac-af5b52eb9928",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.embeddings import HuggingFaceEmbeddings\n",
    "from langchain.vectorstores import Chroma\n",
    "\n",
    "hfemb = HuggingFaceEmbeddings(model_name=\"krlvi/sentence-t5-base-nlpl-code-x-glue\")\n",
    "\n",
    "persist_directory = \"db\"\n",
    "db = Chroma(persist_directory=persist_directory, embedding_function=hfemb)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3392bf00-9725-4455-b351-c676947f8e0e",
   "metadata": {},
   "source": [
    "#### Vector data retriever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5b8d8254-917d-4609-a2d4-cbe476b00094",
   "metadata": {},
   "outputs": [],
   "source": [
    "#retriever = db.as_retriever(search_type=\"similarity_score_threshold\", search_kwargs={\"score_threshold\": .2, \"k\": 5})\n",
    "\n",
    "retriever = db.as_retriever()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "468c19aa-fb94-4bdd-b5dd-8af2b063c2dd",
   "metadata": {},
   "source": [
    "### Chat LLM model\n",
    "\n",
    "The model `gpt4all-falcon-q4_0.gguf` is downloaded from [gpt4all.io](https://gpt4all.io/index.html) website and stored in `models` directory in this repository. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b3b967e8-b8fd-4bd5-a775-5f30135fb84a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.chains import ConversationalRetrievalChain\n",
    "from langchain.memory import ConversationSummaryMemory\n",
    "\n",
    "from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler\n",
    "from langchain.llms import GPT4All\n",
    "\n",
    "# Callbacks support token-wise streaming\n",
    "callbacks = [StreamingStdOutCallbackHandler()]\n",
    "\n",
    "# Verbose is required to pass to the callback manager\n",
    "llm = GPT4All(model=\"models/gpt4all-falcon-q4_0.gguf\", callbacks=callbacks, verbose=False)\n",
    "\n",
    "#memory = ConversationSummaryMemory(\n",
    "#    llm=llm, memory_key=\"chat_history\", return_messages=True\n",
    "#)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aa1f77a-b98e-4139-adfd-b742a67b54c1",
   "metadata": {},
   "source": [
    "### Setup Langchain\n",
    "\n",
    "Create Conversation chain for chatbot using GPT4All chat model and vector db as retriever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7f946427-ed0e-4d2f-b63c-9917ccd423ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.chains import ConversationalRetrievalChain\n",
    "\n",
    "qa_chain = ConversationalRetrievalChain.from_llm(llm=llm, retriever=retriever, return_source_documents=True, max_tokens_limit=2046)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "699c6210-8dd2-406b-9a5b-503261e2318a",
   "metadata": {},
   "source": [
    "### Query helper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0b545f94-d030-4224-b094-f6abf34e92a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def query(q):\n",
    "    result = qa_chain({\"question\":q, \"chat_history\":[]})\n",
    "    #print(f\"Answer: {result['answer']}\")\n",
    "    print(f\"\\n\\nSources\\n{[x.metadata['source'] for x in result['source_documents']]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3edfbd94-e7c6-47d2-b60d-9aa90017ebf1",
   "metadata": {},
   "source": [
    "## Chat Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e133e433-235e-4dc4-90c1-94cf452a0659",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Token indices sequence length is longer than the specified maximum sequence length for this model (2909 > 1024). Running this sequence through the model will result in indexing errors\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " argocd-operator is an operator in OKD that manages ArgoCD deployments and updates. It provides a way to manage ArgoCD deployments, including creating, updating, and deleting deployments. The operator also handles the creation of resources such as pods, services, and secrets for each deployment.\n",
      "\n",
      "Sources\n",
      "['data/issues/1081.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"What do you know about argocd-operator?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "daeb4d88-a611-4874-8d26-81fea9656f95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The source code language of argocd-operator is Go.\n",
      "\n",
      "Sources\n",
      "['data/issues/274.txt', 'data/issues/153.txt', 'data/issues/1001.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"What is the source code langauge of argocd-operator?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1c455c5b-c606-477b-bc00-0f95709c8ee1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " To use the ArgoCD Operator, you need to have a Kubernetes cluster running and have the operator installed. You can then create an ArgoCD Operator instance using the following command:\n",
      "\n",
      "```\n",
      "kubectl apply -f https://raw.githubusercontent.com/argoproj-labs/argocd-operator/master/examples/operator/argo-cd-operator/v0.0.9/deploy/kustomization.yaml\n",
      "```\n",
      "\n",
      "This will create an ArgoCD Operator instance in your Kubernetes cluster. You can then use the operator to manage your ArgoCD deployments and releases.\n",
      "\n",
      "To deploy a\n",
      "\n",
      "Sources\n",
      "['data/issues/256.txt', 'data/issues/49.txt', 'data/issues/79.txt', 'data/code/hack/test.sh']\n"
     ]
    }
   ],
   "source": [
    "query(\"How to use this operator?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "972100fc-cbd5-4d6f-b090-55437ce27393",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " To install the ArgoCD Operator on Kubernetes, you can follow these steps:\n",
      "\n",
      "1. Install the operator by running `make deploy`.\n",
      "2. Verify that the operator is installed by checking the status of the pods using `kubectl get pods -n argocd-operator-system`.\n",
      "3. Create a new ArgoCD resource by running `argocd create <resource_name>`.\n",
      "4. Verify that the resource was created by checking the status of the resource using `kubectl get resources -n argocd-operator-system`.\n",
      "5. Repeat steps 3-4 for each additional resource you want to create.\n",
      "6. Once all resources have been created, verify that the operator is running and has no errors by checking the status of the pods using `kubectl get pods -n argocd-operator-system`.\n",
      "7. To remove the operator from the cluster, run `make undeploy`.\n",
      "8. Verify that the operator has been removed by checking the status of the pods using `kubectl get pods -n argocd-operator-system`.\n",
      "\n",
      "Sources\n",
      "['data/code/docs/install/manual.md']\n"
     ]
    }
   ],
   "source": [
    "query(\"How to install it on kubernetes?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b72d73a1-9323-468f-83ac-287616c4791a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Yes, the argocd-operator project sources from a `go.mod` file.\n",
      "\n",
      "Sources\n",
      "['data/issues/461.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"does argocd-operator source as go.mod file?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0c86d969-c10b-40b4-9306-16b53e20112b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The go version in go.mod for this project is 1.16.\n",
      "\n",
      "Sources\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "query(\"Tell me the go version in go.mod of this project\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0f3d7f13-49aa-4bb4-b707-dabc75ec9909",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The go version used in this project is 1.20.\n",
      "\n",
      "Sources\n",
      "['data/code/Dockerfile', 'data/code/.github/workflows/codegen.yaml']\n"
     ]
    }
   ],
   "source": [
    "query(\"What is go version in this project?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5b6f1547-1997-4e84-9976-00a3dfa5d916",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " To update the go version to 1.21, you can modify the `env` section of the `jobs` configuration in the `check-go-modules` job. Here's an example of how you can do it:\n",
      "```yaml\n",
      "- name: Update go version\n",
      "  uses: actions/setup-go@v1\n",
      "  with:\n",
      "    go-version: 1.21\n",
      "```\n",
      "This will update the go version to 1.21 for the `check-go-modules` job. You can repeat this step for the `check-sdk-codegen` job as well.\n",
      "\n",
      "Sources\n",
      "['data/code/.github/workflows/codegen.yaml']\n"
     ]
    }
   ],
   "source": [
    "query(\"Write a patch to update go version to 1.21 for this project?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b23dcc4d-7fe4-454f-9c2e-aaa9cca1b9a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "To update the k8s.io/api in go.mod file in argocd-operator to v1.29, you can follow these steps:\n",
      "\n",
      "1. Open the `argocd-operator` directory in your terminal and navigate to the `cmd/k8s/apis` directory.\n",
      "2. Find the `api.go` file and open it in a text editor.\n",
      "3. Search for the line that starts with `//+k8s: k8s.io/api v1.29`.\n",
      "4. Replace this line with the following:\n",
      "```go\n",
      "//+k8s: k8s.io/api v1.29\n",
      "```\n",
      "5. Save and close the file.\n",
      "6. Run `make` to rebuild the argocd-operator package.\n",
      "7. Verify that the k8s.io/api version in the go.mod file has been updated\n",
      "\n",
      "Sources\n",
      "['data/issues/461.txt', 'data/issues/565.txt', 'data/issues/462.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"Write a patch to update k8s.io/api in go.mod file in argocd-operator to v1.29?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d6287840-9325-46c2-96a2-11641e469953",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Currently, argocd-operator supports both dex and keycloak SSO providers.\n",
      "\n",
      "Sources\n",
      "['data/issues/153.txt', 'data/issues/274.txt', 'data/issues/119.txt', 'data/issues/483.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"Which sso does argocd-operator support?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a9e90b65-11b9-4dd6-b093-000974670b71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Yes, ArgoCD supports Dex. To configure it, you need to add the following volume mount to your ArgoCD deployment:\n",
      "\n",
      "\n",
      "\n",
      "```\n",
      "- name: google-groups-credentials\n",
      "  secret:\n",
      "    defaultMode: 420\n",
      "    secretName: argocd-google-groups-credentials\n",
      "```\n",
      "\n",
      "This will mount a secret volume that contains the Google Groups credentials JSON. You can then use this JSON to authenticate and query Google Workspace directory for a user's groups.\n",
      "\n",
      "You can also configure the ArgoCD operator to use Dex by setting the `DISABLE_DEX` variable to `true`. This will disable the deployment of the bundled Dex server.\n",
      "\n",
      "Sources\n",
      "['data/issues/278.txt', 'data/issues/559.txt', 'data/issues/142.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"Does it support dex?If yes, can you share how to configure it?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "ca4abecc-407a-428c-8ee4-ae60f69e1f14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " To configure RBAC with argocd-operator, you need to follow these steps:\n",
      "\n",
      "1. Create a new role or patch an existing role bound to the SA to add RBAC permissions for the argocd-operator service account.\n",
      "2. Add the RBAC role to the argocd-operator service account.\n",
      "3. Apply the hack for the service account.\n",
      "4. Once you apply the hack for the service account, you can list the HorizontalPodAutoscalers resource in the API group \"autoscaling\".\n",
      "5. You can also configure RBAC with argocd-operator by using a custom role instead of the default role.\n",
      "6. To do this, create a new role and add RBAC permissions for the argocd-operator service account.\n",
      "7. Apply the hack for the service account.\n",
      "8. Once you apply the hack for the service account, you can list the HorizontalPodAutoscalers resource in the API group \"autoscaling\".\n",
      "9. You can also configure RBAC with argocd-operator by using a custom role instead of the default role.\n",
      "10. To do this, create a new role and add RBAC permissions for the argoc\n",
      "\n",
      "Sources\n",
      "['data/issues/780.txt', 'data/issues/22.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"How to configure rbac with argocd-operator?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a4ea9700-c5b2-437b-b8f0-ab8d4dbf01c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Namespace-scoped ArgoCD in the operator means that the ArgoCD instance will be managed by the operator and will only watch for changes in the specified namespace. This allows for a single operator to manage multiple ArgoCD instances, each with their own namespace. Cluster-scoped ArgoCD in the operator means that the ArgoCD instance will be managed by the operator and will watch for changes across all namespaces. This allows for a single operator to manage multiple ArgoCD instances, each with their own namespace.\n",
      "\n",
      "Sources\n",
      "['data/issues/665.txt', 'data/issues/107.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"What is namespace vs cluster scope ArgoCD in operator?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "32666095-ca60-49d6-aebd-587b9f6f7134",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " To create a ArgoCD cluster scope in the operator, you need to define the `clusterScope` field in the `operator.yaml` file. This field should contain the `apiVersion`, `kind`, and `metadata` fields for the ArgoCD resource that you want to manage.\n",
      "\n",
      "For example, if you want to create a new ArgoCD resource with the name `my-argocd-resource`, you can define it in the `operator.yaml` file as follows:\n",
      "```\n",
      "apiVersion: argoproj.io/v1alpha1\n",
      "kind: ArgoCD\n",
      "metadata:\n",
      "  name: my-argocd-resource\n",
      "```\n",
      "Once you have defined the `clusterScope` field, you can run the operator to create the ArgoCD resource and manage it using the `operator-sdk`.\n",
      "\n",
      "Sources\n",
      "['data/issues/92.txt', 'data/issues/339.txt']\n"
     ]
    }
   ],
   "source": [
    "query(\"How to make a ArgoCD cluster scope in operator?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "220eae14-1249-4ceb-bde0-32c3ed450755",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " The latest api version of ArgoCD CRD is `v1beta1`.\n",
      "\n",
      "Sources\n",
      "['data/issues/119.txt', 'data/issues/1090.txt', 'data/code/examples/argocd-basic.yaml', 'data/code/examples/argocd-autoscale.yaml']\n"
     ]
    }
   ],
   "source": [
    "query(\"What is the latest api version of ArgoCD CRD?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8b7c99f8-bbed-4845-b399-d5a086d1019e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Here is an example of a sample ArgoCD CRD for v1beta1:\n",
      "```yaml\n",
      "apiVersion: argoproj.io/v1beta1\n",
      "kind: ArgoCD\n",
      "metadata:\n",
      "  name: example-argocd\n",
      "spec:\n",
      "  server:\n",
      "    resources:\n",
      "      limits:\n",
      "        cpu: 500m\n",
      "        memory: 256Mi\n",
      "      requests:\n",
      "        cpu: 125m\n",
      "        memory: 128Mi\n",
      "  repo:\n",
      "    resources:\n",
      "      limits:\n",
      "        cpu: 1,000m\n",
      "        memory: 512Mi\n",
      "      requests:\n",
      "        cpu: 250m\n",
      "        memory: 256Mi\n",
      "  ha:\n",
      "    enabled: false\n",
      "    resources:\n",
      "      limits:\n",
      "        cpu: 500m\n",
      "        memory: 256Mi\n",
      "      requests:\n",
      "        cpu: 250m\n",
      "        memory: 128Mi\n",
      "  redis:\n",
      "    resources:\n",
      "      limits:\n",
      "        cpu: 500m\n",
      "        memory: 256Mi\n",
      "      requests:\n",
      "        cpu: 250m\n",
      "        memory: 128Mi\n",
      "  sso:\n",
      "    provider: dex\n",
      "    dex:\n",
      "      resources:\n",
      "        limits:\n",
      "          cpu: 500m\n",
      "          memory: 256Mi\n",
      "        requests:\n",
      "          cpu: 250m\n",
      "          memory: 128Mi\n",
      "  controller:\n",
      "   \n",
      "\n",
      "Sources\n",
      "['data/code/examples/argocd-basic.yaml', 'data/code/config/samples/argoproj.io_v1alpha1_argocdexport.yaml', 'data/code/config/samples/argoproj.io_v1beta1_argocd.yaml', 'data/code/examples/argocd-import.yaml']\n"
     ]
    }
   ],
   "source": [
    "query(\"Provide a sample for v1beta1 ArgoCD CRD?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c21653a0-0a25-45c4-bd98-3ea382b50766",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "This was a simple experiment, so I didn't expect exceptional results. The chatbot performed adequately on QA tasks, considering the limited amount of unstructured data, RAG technique, and models used. However, for code/instruction generation tasks, the results were not that good. Further exploration, such as using domain-specific LLM models or fine-tuning, might yield better outcomes.\n",
    "\n",
    "## References \n",
    "\n",
    "- https://towardsdatascience.com/code-understanding-on-your-own-hardware-dd38c4f266d6\n",
    "- https://python.langchain.com/docs/use_cases/question_answering/\n",
    "- https://python.langchain.com/docs/use_cases/question_answering/code_understanding\n",
    "- https://huggingface.co/krlvi/sentence-t5-base-nlpl-code_search_net\n",
    "- https://python.langchain.com/docs/integrations/llms/gpt4all\n",
    "- https://www.youtube.com/watch?v=DYOU_Z0hAwo\n",
    "- https://www.youtube.com/watch?v=9ISVjh8mdlA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9b20a77-01f7-4c4c-93dc-fbd31e053da5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}