5 - camel agent with solidity compiler tool.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9af9734e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent, AgentOutputParser\n",
    "from langchain.prompts import StringPromptTemplate\n",
    "from langchain import OpenAI, SerpAPIWrapper, LLMChain\n",
    "from typing import List, Union\n",
    "from langchain.schema import AgentAction, AgentFinish\n",
    "from langchain.agents.agent_toolkits import NLAToolkit\n",
    "from langchain.tools.plugin import AIPlugin\n",
    "import re\n",
    "from dotenv import load_dotenv\n",
    "import os\n",
    "import json\n",
    "import re\n",
    "from langchain import Anthropic\n",
    "from langchain.chat_models import ChatAnthropic\n",
    "from langchain.prompts.chat import (\n",
    "    SystemMessagePromptTemplate,\n",
    "    HumanMessagePromptTemplate,\n",
    ")\n",
    "from langchain.schema import (\n",
    "    HumanMessage,\n",
    ")\n",
    "from typing import List\n",
    "from langchain.agents import Tool, initialize_agent, AgentType\n",
    "from langchain.agents import tool\n",
    "from pydantic import BaseModel, Field\n",
    "from solcx import install_solc, compile_source\n",
    "from langchain.chat_models import ChatOpenAI\n",
    "from langchain.schema import SystemMessage, BaseMessage, HumanMessage, AIMessage\n",
    "from dotenv import load_dotenv\n",
    "from typing import List\n",
    "from langchain.agents import Tool, initialize_agent, AgentType\n",
    "from langchain.chat_models import ChatOpenAI\n",
    "from langchain.schema import SystemMessage, BaseMessage, HumanMessage, AIMessage\n",
    "from utils.tools import compile_solidity, SolidityCompilerInput\n",
    "\n",
    "\n",
    "load_dotenv()\n",
    "\n",
    "\n",
    "def get_secret(name):\n",
    "    if name in os.environ:\n",
    "        return os.environ[name]\n",
    "    return os.getenv(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f91d8b4",
   "metadata": {},
   "source": [
    "## Setup LLM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a1a3b59c",
   "metadata": {},
   "outputs": [],
   "source": [
    "llm = OpenAI(temperature=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "becda2a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "@tool(return_direct=False)\n",
    "def compile_solidity(solidity_code_str):\n",
    "    \"\"\"\n",
    "    This function compiles Solidity files using a specific version of solc.\n",
    "    :return: Dict, the compiled contracts.\n",
    "    \"\"\"\n",
    "    solidity_code_str = solidity_code_str.strip('`')\n",
    "    solc_version = '0.8.2'\n",
    "    # Install the specified version of solc\n",
    "    install_solc(solc_version)\n",
    "    try:\n",
    "        result = compile_source(solidity_code_str)\n",
    "    except Exception as e:\n",
    "        print(f\"couldn't compile {solidity_code_str}\\n{str(e)}\")\n",
    "        return f'Compilation Failed. Either the code is invalid or current compiler({solc_version}) didnt match'\n",
    "    print(result)\n",
    "    return 'Compilation Successful. It is a valid solidity code.'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17362717",
   "metadata": {},
   "source": [
    "## Tool Retriever\n",
    "\n",
    "We will use a vectorstore to create embeddings for each tool description. Then, for an incoming query we can create embeddings for that query and do a similarity search for relevant tools."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "735a7566",
   "metadata": {},
   "outputs": [],
   "source": [
    "tools = [\n",
    "    Tool(\n",
    "        func=compile_solidity,\n",
    "        name=\"solidity compiler\",\n",
    "        description=\"Can compile solidity code. Accepts ONLY solidity code\",\n",
    "        args_schema=SolidityCompilerInput,\n",
    "    ),\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7699afd7",
   "metadata": {},
   "source": [
    "We can now test this retriever to see if it seems to work."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e7a075c",
   "metadata": {},
   "source": [
    "## Prompt Template\n",
    "\n",
    "The prompt template is pretty standard, because we're not actually changing that much logic in the actual prompt template, but rather we are just changing how retrieval is done."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "339b1bb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up the base template\n",
    "template = \"\"\"Answer the following questions as best you can, but speaking as a pirate might speak. You have access to the following tools:\n",
    "\n",
    "{tools}\n",
    "\n",
    "Use the following format:\n",
    "\n",
    "Question: the input question you must answer\n",
    "Thought: you should always think about what to do\n",
    "Action: the action to take, should be one of [{tool_names}]\n",
    "Action Input: the input to the action\n",
    "Observation: the result of the action\n",
    "... (this Thought/Action/Action Input/Observation can repeat N times)\n",
    "Thought: I now know the final answer\n",
    "Final Answer: the final answer to the original input question\n",
    "\n",
    "Begin! Remember to speak as a pirate when giving your final answer. Use lots of \"Arg\"s\n",
    "\n",
    "Question: {input}\n",
    "{agent_scratchpad}\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1583acdc",
   "metadata": {},
   "source": [
    "The custom prompt template now has the concept of a tools_getter, which we call on the input to select the tools to use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fd969d31",
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Callable\n",
    "# Set up a prompt template\n",
    "class CustomPromptTemplate(StringPromptTemplate):\n",
    "    # The template to use\n",
    "    template: str\n",
    "    ############## NEW ######################\n",
    "    # The list of tools available\n",
    "    tools_getter: Callable\n",
    "    \n",
    "    def format(self, **kwargs) -> str:\n",
    "        # Get the intermediate steps (AgentAction, Observation tuples)\n",
    "        # Format them in a particular way\n",
    "        intermediate_steps = kwargs.pop(\"intermediate_steps\")\n",
    "        thoughts = \"\"\n",
    "        for action, observation in intermediate_steps:\n",
    "            thoughts += action.log\n",
    "            thoughts += f\"\\nObservation: {observation}\\nThought: \"\n",
    "        # Set the agent_scratchpad variable to that value\n",
    "        kwargs[\"agent_scratchpad\"] = thoughts\n",
    "        ############## NEW ######################\n",
    "        tools = self.tools_getter(kwargs[\"input\"])\n",
    "        # Create a tools variable from the list of tools provided\n",
    "        kwargs[\"tools\"] = \"\\n\".join([f\"{tool.name}: {tool.description}\" for tool in tools])\n",
    "        # Create a list of tool names for the tools provided\n",
    "        kwargs[\"tool_names\"] = \", \".join([tool.name for tool in tools])\n",
    "        return self.template.format(**kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "798ef9fb",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValidationError",
     "evalue": "1 validation error for CustomPromptTemplate\ntools_getter\n  [Tool(name='solidity compiler', description='Can compile solidity code. Accepts ONLY solidity code', args_schema=<class 'utils.tools.SolidityCompilerInput'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=StructuredTool(name='compile_solidity', description='compile_solidity(solidity_code_str) - This function compiles Solidity files using a specific version of solc.\\n    :return: Dict, the compiled contracts.', args_schema=<class 'pydantic.main.compile_soliditySchemaSchema'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=<function compile_solidity at 0x7f7d631e1240>, coroutine=None), coroutine=None)] is not callable (type=type_error.callable; value=[Tool(name='solidity compiler', description='Can compile solidity code. Accepts ONLY solidity code', args_schema=<class 'utils.tools.SolidityCompilerInput'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=StructuredTool(name='compile_solidity', description='compile_solidity(solidity_code_str) - This function compiles Solidity files using a specific version of solc.\\n    :return: Dict, the compiled contracts.', args_schema=<class 'pydantic.main.compile_soliditySchemaSchema'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=<function compile_solidity at 0x7f7d631e1240>, coroutine=None), coroutine=None)])",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValidationError\u001b[0m                           Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[15], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m prompt \u001b[38;5;241m=\u001b[39m \u001b[43mCustomPromptTemplate\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      2\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtemplate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtemplate\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      3\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtools_getter\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtools\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      4\u001b[0m \u001b[43m    \u001b[49m\u001b[43minput_variables\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43minput\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mintermediate_steps\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m      5\u001b[0m \u001b[43m)\u001b[49m\n",
      "File \u001b[0;32m~/anaconda3/envs/test/lib/python3.10/site-packages/pydantic/main.py:341\u001b[0m, in \u001b[0;36mpydantic.main.BaseModel.__init__\u001b[0;34m()\u001b[0m\n",
      "\u001b[0;31mValidationError\u001b[0m: 1 validation error for CustomPromptTemplate\ntools_getter\n  [Tool(name='solidity compiler', description='Can compile solidity code. Accepts ONLY solidity code', args_schema=<class 'utils.tools.SolidityCompilerInput'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=StructuredTool(name='compile_solidity', description='compile_solidity(solidity_code_str) - This function compiles Solidity files using a specific version of solc.\\n    :return: Dict, the compiled contracts.', args_schema=<class 'pydantic.main.compile_soliditySchemaSchema'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=<function compile_solidity at 0x7f7d631e1240>, coroutine=None), coroutine=None)] is not callable (type=type_error.callable; value=[Tool(name='solidity compiler', description='Can compile solidity code. Accepts ONLY solidity code', args_schema=<class 'utils.tools.SolidityCompilerInput'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=StructuredTool(name='compile_solidity', description='compile_solidity(solidity_code_str) - This function compiles Solidity files using a specific version of solc.\\n    :return: Dict, the compiled contracts.', args_schema=<class 'pydantic.main.compile_soliditySchemaSchema'>, return_direct=False, verbose=False, callbacks=None, callback_manager=None, handle_tool_error=False, func=<function compile_solidity at 0x7f7d631e1240>, coroutine=None), coroutine=None)])"
     ]
    }
   ],
   "source": [
    "prompt = CustomPromptTemplate(\n",
    "    template=template,\n",
    "    tools_getter=tools,\n",
    "    input_variables=[\"input\", \"intermediate_steps\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef3a1af3",
   "metadata": {},
   "source": [
    "## Output Parser\n",
    "\n",
    "The output parser is unchanged from the previous notebook, since we are not changing anything about the output format."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c6fe0d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CustomOutputParser(AgentOutputParser):\n",
    "    \n",
    "    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:\n",
    "        # Check if agent should finish\n",
    "        if \"Final Answer:\" in llm_output:\n",
    "            return AgentFinish(\n",
    "                # Return values is generally always a dictionary with a single `output` key\n",
    "                # It is not recommended to try anything else at the moment :)\n",
    "                return_values={\"output\": llm_output.split(\"Final Answer:\")[-1].strip()},\n",
    "                log=llm_output,\n",
    "            )\n",
    "        # Parse out the action and action input\n",
    "        regex = r\"Action\\s*\\d*\\s*:(.*?)\\nAction\\s*\\d*\\s*Input\\s*\\d*\\s*:[\\s]*(.*)\"\n",
    "        match = re.search(regex, llm_output, re.DOTALL)\n",
    "        if not match:\n",
    "            raise ValueError(f\"Could not parse LLM output: `{llm_output}`\")\n",
    "        action = match.group(1).strip()\n",
    "        action_input = match.group(2)\n",
    "        # Return the action and action input\n",
    "        return AgentAction(tool=action, tool_input=action_input.strip(\" \").strip('\"'), log=llm_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d278706a",
   "metadata": {},
   "outputs": [],
   "source": [
    "output_parser = CustomOutputParser()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "170587b1",
   "metadata": {},
   "source": [
    "## Set up LLM, stop sequence, and the agent\n",
    "\n",
    "Also the same as the previous notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9d4c374",
   "metadata": {},
   "outputs": [],
   "source": [
    "llm = OpenAI(temperature=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b1cc2a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# LLM chain consisting of the LLM and a prompt\n",
    "llm_chain = LLMChain(llm=llm, prompt=prompt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4f5092f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tool_names = [tool.name for tool in tools]\n",
    "agent = LLMSingleActionAgent(\n",
    "    llm_chain=llm_chain, \n",
    "    output_parser=output_parser,\n",
    "    stop=[\"\\nObservation:\"], \n",
    "    allowed_tools=tool_names\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa8a5326",
   "metadata": {},
   "source": [
    "## Use the Agent\n",
    "\n",
    "Now we can use it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "490604e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "653b1617",
   "metadata": {},
   "outputs": [],
   "source": [
    "agent_executor.run(solidity_code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2481ee76",
   "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.10.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "18784188d7ecd866c0586ac068b02361a6896dc3a29b64f5cc957f09c590acef"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}