init commit

.idea/workspace.xml

@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="3dc50299-1dad-4898-8eba-684fc694db9d" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+    <option name="RESET_MODE" value="HARD" />
+  </component>
+  <component name="MarkdownSettingsMigration">
+    <option name="stateVersion" value="1" />
+  </component>
+  <component name="ProjectId" id="2VHNEcYX4qIZfWloxtEWlDzDWqk" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "WebServerToolWindowFactoryState": "false",
+    "git-widget-placeholder": "main",
+    "last_opened_file_path": "/Users/jiefeng/Dropbox/Apps/admixer/marketing-analytics-bot",
+    "node.js.detected.package.eslint": "true",
+    "node.js.detected.package.tslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "vue.rearranger.settings.migration": "true"
+  }
+}]]></component>
+  <component name="RunManager">
+    <configuration name="marketing-analytics-bot" type="Python.FlaskServer">
+      <module name="marketing-analytics-bot" />
+      <option name="target" value="$PROJECT_DIR$/app.py" />
+      <option name="targetType" value="PATH" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="" />
+      <option name="IS_MODULE_SDK" value="false" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+      <option name="launchJavascriptDebuger" value="false" />
+      <method v="2" />
+    </configuration>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="3dc50299-1dad-4898-8eba-684fc694db9d" name="Changes" comment="" />
+      <created>1694488935255</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1694488935255</updated>
+      <workItem from="1694488936855" duration="1127000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+  <component name="Vcs.Log.Tabs.Properties">
+    <option name="TAB_STATES">
+      <map>
+        <entry key="MAIN">
+          <value>
+            <State />
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+</project>

CITATION.cff

@@ -0,0 +1,8 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- family-names: "Chase"
+  given-names: "Harrison"
+title: "LangChain"
+date-released: 2022-10-17
+url: "https://github.com/hwchase17/langchain"

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+COPY ./requirements.txt ~/app/requirements.txt
+RUN pip install -r requirements.txt
+COPY . .
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Harrison Chase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

Makefile

@@ -0,0 +1,53 @@
+.PHONY: all clean format lint test tests test_watch integration_tests help
+
+all: help
+	
+coverage:
+	poetry run pytest --cov \
+		--cov-config=.coveragerc \
+		--cov-report xml \
+		--cov-report term-missing:skip-covered
+
+clean: docs_clean
+
+docs_build:
+	cd docs && poetry run make html
+
+docs_clean:
+	cd docs && poetry run make clean
+
+docs_linkcheck:
+	poetry run linkchecker docs/_build/html/index.html
+
+format:
+	poetry run black .
+	poetry run ruff --select I --fix .
+
+lint:
+	poetry run mypy .
+	poetry run black . --check
+	poetry run ruff .
+
+test:
+	poetry run pytest tests/unit_tests
+
+tests:
+	poetry run pytest tests/unit_tests
+
+test_watch:
+	poetry run ptw --now . -- tests/unit_tests
+
+integration_tests:
+	poetry run pytest tests/integration_tests
+
+help:
+	@echo '----'
+	@echo 'coverage            - run unit tests and generate coverage report'
+	@echo 'docs_build          - build the documentation'
+	@echo 'docs_clean          - clean the documentation build artifacts'
+	@echo 'docs_linkcheck      - run linkchecker on the documentation'
+	@echo 'format              - run code formatters'
+	@echo 'lint                - run linters'
+	@echo 'test                - run unit tests'
+	@echo 'test_watch          - run unit tests in watch mode'
+	@echo 'integration_tests   - run integration tests'

Procfile

@@ -0,0 +1 @@
+web: gunicorn app:app

README.md

@@ -1,11 +1,82 @@
----
-title: Marketing Analytics Bot
-emoji: 🦀
-colorFrom: purple
-colorTo: purple
-sdk: docker
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🦜️🔗 LangChain
+
+⚡ Building applications with LLMs through composability ⚡
+
+[![lint](https://github.com/hwchase17/langchain/actions/workflows/lint.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/lint.yml) [![test](https://github.com/hwchase17/langchain/actions/workflows/test.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/test.yml) [![linkcheck](https://github.com/hwchase17/langchain/actions/workflows/linkcheck.yml/badge.svg)](https://github.com/hwchase17/langchain/actions/workflows/linkcheck.yml) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai) [![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+
+**Production Support:** As you move your LangChains into production, we'd love to offer more comprehensive support.
+Please fill out [this form](https://forms.gle/57d8AmXBYp8PP8tZA) and we'll set up a dedicated support Slack channel.
+
+## Quick Install
+
+`pip install langchain`
+
+## 🤔 What is this?
+
+Large language models (LLMs) are emerging as a transformative technology, enabling
+developers to build applications that they previously could not.
+But using these LLMs in isolation is often not enough to
+create a truly powerful app - the real power comes when you can combine them with other sources of computation or knowledge.
+
+This library is aimed at assisting in the development of those types of applications. Common examples of these types of applications include:
+
+**❓ Question Answering over specific documents**
+
+- [Documentation](https://langchain.readthedocs.io/en/latest/use_cases/question_answering.html)
+- End-to-end Example: [Question Answering over Notion Database](https://github.com/hwchase17/notion-qa)
+
+**💬 Chatbots**
+
+- [Documentation](https://langchain.readthedocs.io/en/latest/use_cases/chatbots.html)
+- End-to-end Example: [Chat-LangChain](https://github.com/hwchase17/chat-langchain)
+
+**🤖 Agents**
+
+- [Documentation](https://langchain.readthedocs.io/en/latest/use_cases/agents.html)
+- End-to-end Example: [GPT+WolframAlpha](https://huggingface.co/spaces/JavaFXpert/Chat-GPT-LangChain)
+
+## 📖 Documentation
+
+Please see [here](https://langchain.readthedocs.io/en/latest/?) for full documentation on:
+
+- Getting started (installation, setting up the environment, simple examples)
+- How-To examples (demos, integrations, helper functions)
+- Reference (full API docs)
+- Resources (high-level explanation of core concepts)
+
+## 🚀 What can this help with?
+
+There are six main areas that LangChain is designed to help with.
+These are, in increasing order of complexity:
+
+**📃 LLMs and Prompts:**
+
+This includes prompt management, prompt optimization, generic interface for all LLMs, and common utilities for working with LLMs.
+
+**🔗 Chains:**
+
+Chains go beyond just a single LLM call, and are sequences of calls (whether to an LLM or a different utility). LangChain provides a standard interface for chains, lots of integrations with other tools, and end-to-end chains for common applications.
+
+**📚 Data Augmented Generation:**
+
+Data Augmented Generation involves specific types of chains that first interact with an external datasource to fetch data to use in the generation step. Examples of this include summarization of long pieces of text and question/answering over specific data sources.
+
+**🤖 Agents:**
+
+Agents involve an LLM making decisions about which Actions to take, taking that Action, seeing an Observation, and repeating that until done. LangChain provides a standard interface for agents, a selection of agents to choose from, and examples of end to end agents.
+
+**🧠 Memory:**
+
+Memory is the concept of persisting state between calls of a chain/agent. LangChain provides a standard interface for memory, a collection of memory implementations, and examples of chains/agents that use memory.
+
+**🧐 Evaluation:**
+
+[BETA] Generative models are notoriously hard to evaluate with traditional metrics. One new way of evaluating them is using language models themselves to do the evaluation. LangChain provides some prompts/chains for assisting in this.
+
+For more information on these concepts, please see our [full documentation](https://langchain.readthedocs.io/en/latest/?).
+
+## 💁 Contributing
+
+As an open source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infra, or better documentation.
+
+For detailed information on how to contribute, see [here](.github/CONTRIBUTING.md).

app.py

@@ -0,0 +1,102 @@
+"""Python file to serve as the frontend"""
+from datetime import datetime
+
+import wandb
+
+from langchain.agents.agent_toolkits.sql.simple_sql import create_simple_sql_agent_excutor
+from langchain.callbacks import WandbCallbackHandler, CallbackManager, StdOutCallbackHandler
+from langchain.document_loaders import WebBaseLoader
+from langchain.embeddings import OpenAIEmbeddings
+# import faiss
+from langchain import OpenAI, FAISS, LLMChain
+from langchain.chains import VectorDBQAWithSourcesChain
+import pickle
+
+# root_dir = "/Users/jiefeng/Dropbox/Apps/admixer/neon_scrapy/data/"
+# index_path = "".join([root_dir, "docs.index"])
+# fass_store_path = "".join([root_dir, "faiss_store.pkl"])
+# Load the LangChain.
+
+from langchain.prompts import PromptTemplate
+import os
+from langchain import OpenAI, VectorDBQA
+from flask import Flask, request, jsonify
+from flask_cors import CORS, cross_origin
+from langchain.agents.agent_toolkits.sql.toolkit import SimpleSQLDatabaseToolkit
+from langchain.sql_database import SQLDatabase
+from langchain.llms.openai import OpenAI
+
+# create your SocketIO instance
+# handle chat messages
+
+
+url = "https://langchain.readthedocs.io/en/latest/"
+os.environ["OPENAI_API_KEY"] = "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"
+os.environ["WANDB_API_KEY"] = "7e3c65043f06598e45810ffdd5588f048ec870db"
+qa = None
+
+db = SQLDatabase.from_uri(
+    "postgresql+psycopg2://macbttqtwpbkxg:8e00539601577e6d3e73f4781d0d71913dc5a165a9b75229cf930abe79ddaae3@ec2-54-173-77-184.compute-1.amazonaws.com:5432/d8cb6alpt8ft06")
+toolkit = SimpleSQLDatabaseToolkit(db=db)
+
+session_group = datetime.now().strftime("%m.%d.%Y_%H.%M.%S")
+# wandb_callback = WandbCallbackHandler(
+#     job_type="inference",
+#     project="marketing_questions",
+#     group=f"minimal_{session_group}",
+#     name="llm",
+#     tags=["test"],
+# )
+manager = CallbackManager([StdOutCallbackHandler()])
+
+
+llm = OpenAI(temperature=0,
+             model_name="gpt-4",
+             callback_manager=manager,
+             verbose=True,
+             )
+
+agent_executor = create_simple_sql_agent_excutor(
+    llm=llm,
+    toolkit=toolkit,
+    callback_manager=manager,
+    verbose=True
+)
+# agent_executor.run("What are the most popular pages visited by our visitors?")
+
+# agent_executor.run("how many visitors profiles are from the Unite States?")
+# From here down is all the StreamLit UI.
+
+
+app = Flask(__name__)
+cors = CORS(app)
+
+@app.route('/')
+@cross_origin()
+def hello_world():
+    return 'Hello, World!'
+
+
+@app.route('/api/ask', methods=['POST'])
+@cross_origin()
+def submit():
+    print("request received")
+    data = request.get_json()
+    question = data['question']
+    sql_data_result = None
+    if question:
+        print(question)
+        sql_data_result = agent_executor.run(question)
+        #wandb_callback.flush_tracker(agent_executor, reset=False, finish=True)
+
+    # chartPrompt = PromptTemplate(
+    #     template="What chart is best for the data {data}?", input_variables=["data"])
+    #
+    # chartChain = LLMChain(llm=llm, prompt=chartPrompt)
+    # chartChain.run(sql_data_result)
+    result = jsonify(sql_data_result)
+    return result
+
+
+if __name__ == '__main__':
+    app.run(port=7860)

langchain/__init__.py

@@ -0,0 +1,109 @@
+"""Main entrypoint into package."""
+
+from typing import Optional
+
+from langchain.agents import MRKLChain, ReActChain, SelfAskWithSearchChain
+from langchain.cache import BaseCache
+from langchain.callbacks import (
+    set_default_callback_manager,
+    set_handler,
+    set_tracing_callback_manager,
+)
+from langchain.chains import (
+    ConversationChain,
+    LLMBashChain,
+    LLMChain,
+    LLMCheckerChain,
+    LLMMathChain,
+    PALChain,
+    QAWithSourcesChain,
+    SQLDatabaseChain,
+    VectorDBQA,
+    VectorDBQAWithSourcesChain,
+)
+from langchain.docstore import InMemoryDocstore, Wikipedia
+from langchain.llms import (
+    Anthropic,
+    Banana,
+    CerebriumAI,
+    Cohere,
+    ForefrontAI,
+    GooseAI,
+    HuggingFaceHub,
+    Modal,
+    OpenAI,
+    Petals,
+    SagemakerEndpoint,
+    StochasticAI,
+    Writer,
+)
+from langchain.llms.huggingface_pipeline import HuggingFacePipeline
+from langchain.prompts import (
+    BasePromptTemplate,
+    FewShotPromptTemplate,
+    Prompt,
+    PromptTemplate,
+)
+from langchain.sql_database import SQLDatabase
+from langchain.utilities.google_search import GoogleSearchAPIWrapper
+from langchain.utilities.google_serper import GoogleSerperAPIWrapper
+from langchain.utilities.searx_search import SearxSearchWrapper
+from langchain.utilities.serpapi import SerpAPIWrapper
+from langchain.utilities.wikipedia import WikipediaAPIWrapper
+from langchain.utilities.wolfram_alpha import WolframAlphaAPIWrapper
+from langchain.vectorstores import FAISS, ElasticVectorSearch
+
+verbose: bool = False
+llm_cache: Optional[BaseCache] = None
+set_default_callback_manager()
+
+# For backwards compatibility
+SerpAPIChain = SerpAPIWrapper
+
+__all__ = [
+    "LLMChain",
+    "LLMBashChain",
+    "LLMCheckerChain",
+    "LLMMathChain",
+    "SelfAskWithSearchChain",
+    "SerpAPIWrapper",
+    "SerpAPIChain",
+    "SearxSearchWrapper",
+    "GoogleSearchAPIWrapper",
+    "GoogleSerperAPIWrapper",
+    "WolframAlphaAPIWrapper",
+    "WikipediaAPIWrapper",
+    "Anthropic",
+    "Banana",
+    "CerebriumAI",
+    "Cohere",
+    "ForefrontAI",
+    "GooseAI",
+    "Modal",
+    "OpenAI",
+    "Petals",
+    "StochasticAI",
+    "Writer",
+    "BasePromptTemplate",
+    "Prompt",
+    "FewShotPromptTemplate",
+    "PromptTemplate",
+    "ReActChain",
+    "Wikipedia",
+    "HuggingFaceHub",
+    "SagemakerEndpoint",
+    "HuggingFacePipeline",
+    "SQLDatabase",
+    "SQLDatabaseChain",
+    "FAISS",
+    "MRKLChain",
+    "VectorDBQA",
+    "ElasticVectorSearch",
+    "InMemoryDocstore",
+    "ConversationChain",
+    "VectorDBQAWithSourcesChain",
+    "QAWithSourcesChain",
+    "PALChain",
+    "set_handler",
+    "set_tracing_callback_manager",
+]

langchain/agents/__init__.py

@@ -0,0 +1,43 @@
+"""Interface for agents."""
+from langchain.agents.agent import Agent, AgentExecutor
+from langchain.agents.agent_toolkits import (
+    create_csv_agent,
+    create_json_agent,
+    create_openapi_agent,
+    create_pandas_dataframe_agent,
+    create_sql_agent,
+    create_vectorstore_agent,
+    create_vectorstore_router_agent,
+)
+from langchain.agents.conversational.base import ConversationalAgent
+from langchain.agents.initialize import initialize_agent
+from langchain.agents.load_tools import get_all_tool_names, load_tools
+from langchain.agents.loading import load_agent
+from langchain.agents.mrkl.base import MRKLChain, ZeroShotAgent
+from langchain.agents.react.base import ReActChain, ReActTextWorldAgent
+from langchain.agents.self_ask_with_search.base import SelfAskWithSearchChain
+from langchain.agents.tools import Tool, tool
+
+__all__ = [
+    "MRKLChain",
+    "SelfAskWithSearchChain",
+    "ReActChain",
+    "AgentExecutor",
+    "Agent",
+    "Tool",
+    "tool",
+    "initialize_agent",
+    "ZeroShotAgent",
+    "ReActTextWorldAgent",
+    "load_tools",
+    "get_all_tool_names",
+    "ConversationalAgent",
+    "load_agent",
+    "create_sql_agent",
+    "create_json_agent",
+    "create_openapi_agent",
+    "create_vectorstore_router_agent",
+    "create_vectorstore_agent",
+    "create_pandas_dataframe_agent",
+    "create_csv_agent",
+]

langchain/agents/agent.py

@@ -0,0 +1,583 @@
+"""Chain that takes in an input and produces an action and action input."""
+from __future__ import annotations
+
+import json
+import logging
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+import yaml
+from pydantic import BaseModel, root_validator
+
+from langchain.agents.tools import InvalidTool
+from langchain.callbacks.base import BaseCallbackManager
+from langchain.chains.base import Chain
+from langchain.chains.llm import LLMChain
+from langchain.input import get_color_mapping
+from langchain.llms.base import BaseLLM
+from langchain.prompts.base import BasePromptTemplate
+from langchain.prompts.few_shot import FewShotPromptTemplate
+from langchain.prompts.prompt import PromptTemplate
+from langchain.schema import AgentAction, AgentFinish, BaseMessage, AgentClarify
+from langchain.tools.base import BaseTool
+
+logger = logging.getLogger()
+
+
+class Agent(BaseModel):
+    """Class responsible for calling the language model and deciding the action.
+
+    This is driven by an LLMChain. The prompt in the LLMChain MUST include
+    a variable called "agent_scratchpad" where the agent can put its
+    intermediary work.
+    """
+
+    llm_chain: LLMChain
+    allowed_tools: Optional[List[str]] = None
+    return_values: List[str] = ["output"]
+
+    @abstractmethod
+    def _extract_tool_and_input(self, text: str) -> Optional[Tuple[str, str]]:
+        """Extract tool and tool input from llm output."""
+
+    def _fix_text(self, text: str) -> str:
+        """Fix the text."""
+        raise ValueError("fix_text not implemented for this agent.")
+
+    @property
+    def _stop(self) -> List[str]:
+        return [
+            f"\n{self.observation_prefix.rstrip()}",
+            f"\n\t{self.observation_prefix.rstrip()}",
+        ]
+
+    def _construct_scratchpad(
+        self, intermediate_steps: List[Tuple[AgentAction, str]]
+    ) -> Union[str, List[BaseMessage]]:
+        """Construct the scratchpad that lets the agent continue its thought process."""
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\n{self.observation_prefix}{observation}\n{self.llm_prefix}"
+        return thoughts
+
+    def _get_next_action(self, full_inputs: Dict[str, str]) -> AgentAction:
+        full_output = self.llm_chain.predict(**full_inputs)
+        parsed_output = self._extract_tool_and_input(full_output)
+        while parsed_output is None:
+            full_output = self._fix_text(full_output)
+            full_inputs["agent_scratchpad"] += full_output
+            output = self.llm_chain.predict(**full_inputs)
+            full_output += output
+            parsed_output = self._extract_tool_and_input(full_output)
+        return AgentAction(
+            tool=parsed_output[0], tool_input=parsed_output[1], log=full_output
+        )
+
+    async def _aget_next_action(self, full_inputs: Dict[str, str]) -> AgentAction:
+        full_output = await self.llm_chain.apredict(**full_inputs)
+        parsed_output = self._extract_tool_and_input(full_output)
+        while parsed_output is None:
+            full_output = self._fix_text(full_output)
+            full_inputs["agent_scratchpad"] += full_output
+            output = await self.llm_chain.apredict(**full_inputs)
+            full_output += output
+            parsed_output = self._extract_tool_and_input(full_output)
+        return AgentAction(
+            tool=parsed_output[0], tool_input=parsed_output[1], log=full_output
+        )
+
+    def plan(
+        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
+    ) -> Union[AgentAction, AgentFinish, AgentClarify]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        full_inputs = self.get_full_inputs(intermediate_steps, **kwargs)
+        action = self._get_next_action(full_inputs)
+        if action.tool == self.finish_tool_name:
+            return AgentFinish({"output": action.tool_input}, action.log)
+        return action
+
+    async def aplan(
+        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
+    ) -> Union[AgentAction, AgentFinish]:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        full_inputs = self.get_full_inputs(intermediate_steps, **kwargs)
+        action = await self._aget_next_action(full_inputs)
+        if action.tool == self.finish_tool_name:
+            return AgentFinish({"output": action.tool_input}, action.log)
+        return action
+
+    def get_full_inputs(
+        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
+    ) -> Dict[str, Any]:
+        """Create the full inputs for the LLMChain from intermediate steps."""
+        thoughts = self._construct_scratchpad(intermediate_steps)
+        new_inputs = {"agent_scratchpad": thoughts, "stop": self._stop}
+        full_inputs = {**kwargs, **new_inputs}
+        return full_inputs
+
+    def prepare_for_new_call(self) -> None:
+        """Prepare the agent for new call, if needed."""
+        pass
+
+    @property
+    def finish_tool_name(self) -> str:
+        """Name of the tool to use to finish the chain."""
+        return "Final Answer"
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Return the input keys.
+
+        :meta private:
+        """
+        return list(set(self.llm_chain.input_keys) - {"agent_scratchpad"})
+
+    @root_validator()
+    def validate_prompt(cls, values: Dict) -> Dict:
+        """Validate that prompt matches format."""
+        prompt = values["llm_chain"].prompt
+        if "agent_scratchpad" not in prompt.input_variables:
+            logger.warning(
+                "`agent_scratchpad` should be a variable in prompt.input_variables."
+                " Did not find it, so adding it at the end."
+            )
+            prompt.input_variables.append("agent_scratchpad")
+            if isinstance(prompt, PromptTemplate):
+                prompt.template += "\n{agent_scratchpad}"
+            elif isinstance(prompt, FewShotPromptTemplate):
+                prompt.suffix += "\n{agent_scratchpad}"
+            else:
+                raise ValueError(f"Got unexpected prompt type {type(prompt)}")
+        return values
+
+    @property
+    @abstractmethod
+    def observation_prefix(self) -> str:
+        """Prefix to append the observation with."""
+
+    @property
+    @abstractmethod
+    def llm_prefix(self) -> str:
+        """Prefix to append the LLM call with."""
+
+    @classmethod
+    @abstractmethod
+    def create_prompt(cls, tools: Sequence[BaseTool]) -> BasePromptTemplate:
+        """Create a prompt for this class."""
+
+    @classmethod
+    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
+        """Validate that appropriate tools are passed in."""
+        pass
+
+    @classmethod
+    def from_llm_and_tools(
+        cls,
+        llm: BaseLLM,
+        tools: Sequence[BaseTool],
+        callback_manager: Optional[BaseCallbackManager] = None,
+        **kwargs: Any,
+    ) -> Agent:
+        """Construct an agent from an LLM and tools."""
+        cls._validate_tools(tools)
+        llm_chain = LLMChain(
+            llm=llm,
+            prompt=cls.create_prompt(tools),
+            callback_manager=callback_manager,
+        )
+        tool_names = [tool.name for tool in tools]
+        return cls(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)
+
+    def return_stopped_response(
+        self,
+        early_stopping_method: str,
+        intermediate_steps: List[Tuple[AgentAction, str]],
+        **kwargs: Any,
+    ) -> AgentFinish:
+        """Return response when agent has been stopped due to max iterations."""
+        if early_stopping_method == "force":
+            # `force` just returns a constant string
+            return AgentFinish({"output": "Agent stopped due to max iterations."}, "")
+        elif early_stopping_method == "generate":
+            # Generate does one final forward pass
+            thoughts = ""
+            for action, observation in intermediate_steps:
+                thoughts += action.log
+                thoughts += (
+                    f"\n{self.observation_prefix}{observation}\n{self.llm_prefix}"
+                )
+            # Adding to the previous steps, we now tell the LLM to make a final pred
+            thoughts += (
+                "\n\nI now need to return a final answer based on the previous steps:"
+            )
+            new_inputs = {"agent_scratchpad": thoughts, "stop": self._stop}
+            full_inputs = {**kwargs, **new_inputs}
+            full_output = self.llm_chain.predict(**full_inputs)
+            # We try to extract a final answer
+            parsed_output = self._extract_tool_and_input(full_output)
+            if parsed_output is None:
+                # If we cannot extract, we just return the full output
+                return AgentFinish({"output": full_output}, full_output)
+            tool, tool_input = parsed_output
+            if tool == self.finish_tool_name:
+                # If we can extract, we send the correct stuff
+                return AgentFinish({"output": tool_input}, full_output)
+            else:
+                # If we can extract, but the tool is not the final tool,
+                # we just return the full output
+                return AgentFinish({"output": full_output}, full_output)
+        else:
+            raise ValueError(
+                "early_stopping_method should be one of `force` or `generate`, "
+                f"got {early_stopping_method}"
+            )
+
+    @property
+    @abstractmethod
+    def _agent_type(self) -> str:
+        """Return Identifier of agent type."""
+
+    def dict(self, **kwargs: Any) -> Dict:
+        """Return dictionary representation of agent."""
+        _dict = super().dict()
+        _dict["_type"] = self._agent_type
+        return _dict
+
+    def save(self, file_path: Union[Path, str]) -> None:
+        """Save the agent.
+
+        Args:
+            file_path: Path to file to save the agent to.
+
+        Example:
+        .. code-block:: python
+
+            # If working with agent executor
+            agent.agent.save(file_path="path/agent.yaml")
+        """
+        # Convert file to Path object.
+        if isinstance(file_path, str):
+            save_path = Path(file_path)
+        else:
+            save_path = file_path
+
+        directory_path = save_path.parent
+        directory_path.mkdir(parents=True, exist_ok=True)
+
+        # Fetch dictionary to save
+        agent_dict = self.dict()
+
+        if save_path.suffix == ".json":
+            with open(file_path, "w") as f:
+                json.dump(agent_dict, f, indent=4)
+        elif save_path.suffix == ".yaml":
+            with open(file_path, "w") as f:
+                yaml.dump(agent_dict, f, default_flow_style=False)
+        else:
+            raise ValueError(f"{save_path} must be json or yaml")
+
+
+class AgentExecutor(Chain, BaseModel):
+    """Consists of an agent using tools."""
+
+    agent: Agent
+    tools: Sequence[BaseTool]
+    return_intermediate_steps: bool = False
+    max_iterations: Optional[int] = 15
+    early_stopping_method: str = "force"
+
+    @classmethod
+    def from_agent_and_tools(
+        cls,
+        agent: Agent,
+        tools: Sequence[BaseTool],
+        callback_manager: Optional[BaseCallbackManager] = None,
+        **kwargs: Any,
+    ) -> AgentExecutor:
+        """Create from agent and tools."""
+        return cls(
+            agent=agent, tools=tools, callback_manager=callback_manager, **kwargs
+        )
+
+    @root_validator()
+    def validate_tools(cls, values: Dict) -> Dict:
+        """Validate that tools are compatible with agent."""
+        agent = values["agent"]
+        tools = values["tools"]
+        if agent.allowed_tools is not None:
+            if set(agent.allowed_tools) != set([tool.name for tool in tools]):
+                raise ValueError(
+                    f"Allowed tools ({agent.allowed_tools}) different than "
+                    f"provided tools ({[tool.name for tool in tools]})"
+                )
+        return values
+
+    def save(self, file_path: Union[Path, str]) -> None:
+        """Raise error - saving not supported for Agent Executors."""
+        raise ValueError(
+            "Saving not supported for agent executors. "
+            "If you are trying to save the agent, please use the "
+            "`.save_agent(...)`"
+        )
+
+    def save_agent(self, file_path: Union[Path, str]) -> None:
+        """Save the underlying agent."""
+        return self.agent.save(file_path)
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Return the input keys.
+
+        :meta private:
+        """
+        return self.agent.input_keys
+
+    @property
+    def output_keys(self) -> List[str]:
+        """Return the singular output key.
+
+        :meta private:
+        """
+        if self.return_intermediate_steps:
+            return self.agent.return_values + ["intermediate_steps"]
+        else:
+            return self.agent.return_values
+
+    def _should_continue(self, iterations: int) -> bool:
+        if self.max_iterations is None:
+            return True
+        else:
+            return iterations < self.max_iterations
+
+    def _return(self, output: AgentFinish, intermediate_steps: list) -> Dict[str, Any]:
+        self.callback_manager.on_agent_finish(
+            output, color="green", verbose=self.verbose
+        )
+        final_output = output.return_values
+        if self.return_intermediate_steps:
+            final_output["intermediate_steps"] = intermediate_steps
+        return final_output
+
+    def _handle_clarify(self, output: AgentClarify, intermediate_steps: list) -> Dict[str, Any]:
+        self.callback_manager.on_agent_clarify(
+            output, color="yellow", verbose=self.verbose
+        )
+        final_output = {"clarify_question": output.question}
+        if self.return_intermediate_steps:
+            final_output["intermediate_steps"] = intermediate_steps
+        return final_output
+
+
+    async def _areturn(
+        self, output: AgentFinish, intermediate_steps: list
+    ) -> Dict[str, Any]:
+        if self.callback_manager.is_async:
+            await self.callback_manager.on_agent_finish(
+                output, color="green", verbose=self.verbose
+            )
+        else:
+            self.callback_manager.on_agent_finish(
+                output, color="green", verbose=self.verbose
+            )
+        final_output = output.return_values
+        if self.return_intermediate_steps:
+            final_output["intermediate_steps"] = intermediate_steps
+        return final_output
+
+    def _take_next_step(
+        self,
+        name_to_tool_map: Dict[str, BaseTool],
+        color_mapping: Dict[str, str],
+        inputs: Dict[str, str],
+        intermediate_steps: List[Tuple[AgentAction, str]],
+    ) -> Union[AgentFinish, Tuple[AgentAction, str], Tuple[AgentClarify, str]]:
+        """Take a single step in the thought-action-observation loop.
+
+        Override this to take control of how the agent makes and acts on choices.
+        """
+        # Call the LLM to see what to do.
+        output = self.agent.plan(intermediate_steps, **inputs)
+        # If the tool chosen is the finishing tool, then we end and return.
+        if isinstance(output, AgentFinish):
+            return output
+        if isinstance(output, AgentClarify):
+            return output
+        self.callback_manager.on_agent_action(
+            output, verbose=self.verbose, color="green"
+        )
+        # Otherwise we lookup the tool
+        if output.tool in name_to_tool_map:
+            tool = name_to_tool_map[output.tool]
+            return_direct = tool.return_direct
+            color = color_mapping[output.tool]
+            llm_prefix = "" if return_direct else self.agent.llm_prefix
+            # We then call the tool on the tool input to get an observation
+            observation = tool.run(
+                output.tool_input,
+                verbose=self.verbose,
+                color=color,
+                llm_prefix=llm_prefix,
+                observation_prefix=self.agent.observation_prefix,
+            )
+        else:
+            observation = InvalidTool().run(
+                output.tool,
+                verbose=self.verbose,
+                color=None,
+                llm_prefix="",
+                observation_prefix=self.agent.observation_prefix,
+            )
+        return output, observation
+
+    async def _atake_next_step(
+        self,
+        name_to_tool_map: Dict[str, BaseTool],
+        color_mapping: Dict[str, str],
+        inputs: Dict[str, str],
+        intermediate_steps: List[Tuple[AgentAction, str]],
+    ) -> Union[AgentFinish, Tuple[AgentAction, str]]:
+        """Take a single step in the thought-action-observation loop.
+
+        Override this to take control of how the agent makes and acts on choices.
+        """
+        # Call the LLM to see what to do.
+        output = await self.agent.aplan(intermediate_steps, **inputs)
+        # If the tool chosen is the finishing tool, then we end and return.
+        if isinstance(output, AgentFinish):
+            return output
+        if self.callback_manager.is_async:
+            await self.callback_manager.on_agent_action(
+                output, verbose=self.verbose, color="green"
+            )
+        else:
+            self.callback_manager.on_agent_action(
+                output, verbose=self.verbose, color="green"
+            )
+
+        # Otherwise we lookup the tool
+        if output.tool in name_to_tool_map:
+            tool = name_to_tool_map[output.tool]
+            return_direct = tool.return_direct
+            color = color_mapping[output.tool]
+            llm_prefix = "" if return_direct else self.agent.llm_prefix
+            # We then call the tool on the tool input to get an observation
+            observation = await tool.arun(
+                output.tool_input,
+                verbose=self.verbose,
+                color=color,
+                llm_prefix=llm_prefix,
+                observation_prefix=self.agent.observation_prefix,
+            )
+        else:
+            observation = await InvalidTool().arun(
+                output.tool,
+                verbose=self.verbose,
+                color=None,
+                llm_prefix="",
+                observation_prefix=self.agent.observation_prefix,
+            )
+            return_direct = False
+        return output, observation
+
+    def _call(self, inputs: Dict[str, str]) -> Dict[str, Any]:
+        """Run text through and get agent response."""
+        # Do any preparation necessary when receiving a new input.
+        self.agent.prepare_for_new_call()
+        # Construct a mapping of tool name to tool for easy lookup
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # We construct a mapping from each tool to a color, used for logging.
+        color_mapping = get_color_mapping(
+            [tool.name for tool in self.tools], excluded_colors=["green"]
+        )
+        intermediate_steps: List[Tuple[AgentAction, str]] = []
+        # Let's start tracking the iterations the agent has gone through
+        iterations = 0
+        # We now enter the agent loop (until it returns something).
+        while self._should_continue(iterations):
+            next_step_output = self._take_next_step(
+                name_to_tool_map, color_mapping, inputs, intermediate_steps
+            )
+            if isinstance(next_step_output, AgentFinish):
+                return self._return(next_step_output, intermediate_steps)
+
+            if isinstance(next_step_output, AgentClarify):
+                return self._handle_clarify(next_step_output, intermediate_steps)
+
+            intermediate_steps.append(next_step_output)
+            # See if tool should return directly
+            tool_return = self._get_tool_return(next_step_output)
+            if tool_return is not None:
+                return self._return(tool_return, intermediate_steps)
+            iterations += 1
+        output = self.agent.return_stopped_response(
+            self.early_stopping_method, intermediate_steps, **inputs
+        )
+        return self._return(output, intermediate_steps)
+
+    async def _acall(self, inputs: Dict[str, str]) -> Dict[str, str]:
+        """Run text through and get agent response."""
+        # Do any preparation necessary when receiving a new input.
+        self.agent.prepare_for_new_call()
+        # Construct a mapping of tool name to tool for easy lookup
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # We construct a mapping from each tool to a color, used for logging.
+        color_mapping = get_color_mapping(
+            [tool.name for tool in self.tools], excluded_colors=["green"]
+        )
+        intermediate_steps: List[Tuple[AgentAction, str]] = []
+        # Let's start tracking the iterations the agent has gone through
+        iterations = 0
+        # We now enter the agent loop (until it returns something).
+        while self._should_continue(iterations):
+            next_step_output = await self._atake_next_step(
+                name_to_tool_map, color_mapping, inputs, intermediate_steps
+            )
+            if isinstance(next_step_output, AgentFinish):
+                return await self._areturn(next_step_output, intermediate_steps)
+
+            intermediate_steps.append(next_step_output)
+            # See if tool should return directly
+            tool_return = self._get_tool_return(next_step_output)
+            if tool_return is not None:
+                return await self._areturn(tool_return, intermediate_steps)
+
+            iterations += 1
+        output = self.agent.return_stopped_response(
+            self.early_stopping_method, intermediate_steps, **inputs
+        )
+        return await self._areturn(output, intermediate_steps)
+
+    def _get_tool_return(
+        self, next_step_output: Tuple[AgentAction, str]
+    ) -> Optional[AgentFinish]:
+        """Check if the tool is a returning tool."""
+        agent_action, observation = next_step_output
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # Invalid tools won't be in the map, so we return False.
+        if agent_action.tool in name_to_tool_map:
+            if name_to_tool_map[agent_action.tool].return_direct:
+                return AgentFinish(
+                    {self.agent.return_values[0]: observation},
+                    "",
+                )
+        return None

langchain/agents/agent_toolkits/__init__.py

@@ -0,0 +1,39 @@
+"""Agent toolkits."""
+
+from langchain.agents.agent_toolkits.csv.base import create_csv_agent
+from langchain.agents.agent_toolkits.json.base import create_json_agent
+from langchain.agents.agent_toolkits.json.toolkit import JsonToolkit
+from langchain.agents.agent_toolkits.openapi.base import create_openapi_agent
+from langchain.agents.agent_toolkits.openapi.toolkit import OpenAPIToolkit
+from langchain.agents.agent_toolkits.pandas.base import create_pandas_dataframe_agent
+from langchain.agents.agent_toolkits.python.base import create_python_agent
+from langchain.agents.agent_toolkits.sql.base import create_sql_agent
+from langchain.agents.agent_toolkits.sql.toolkit import SQLDatabaseToolkit
+from langchain.agents.agent_toolkits.vectorstore.base import (
+    create_vectorstore_agent,
+    create_vectorstore_router_agent,
+)
+from langchain.agents.agent_toolkits.vectorstore.toolkit import (
+    VectorStoreInfo,
+    VectorStoreRouterToolkit,
+    VectorStoreToolkit,
+)
+from langchain.agents.agent_toolkits.zapier.toolkit import ZapierToolkit
+
+__all__ = [
+    "create_json_agent",
+    "create_sql_agent",
+    "create_openapi_agent",
+    "create_python_agent",
+    "create_vectorstore_agent",
+    "JsonToolkit",
+    "SQLDatabaseToolkit",
+    "OpenAPIToolkit",
+    "VectorStoreToolkit",
+    "create_vectorstore_router_agent",
+    "VectorStoreInfo",
+    "VectorStoreRouterToolkit",
+    "create_pandas_dataframe_agent",
+    "create_csv_agent",
+    "ZapierToolkit",
+]

langchain/agents/agent_toolkits/base.py

@@ -0,0 +1,15 @@
+"""Toolkits for agents."""
+from abc import abstractmethod
+from typing import List
+
+from pydantic import BaseModel
+
+from langchain.tools import BaseTool
+
+
+class BaseToolkit(BaseModel):
+    """Class responsible for defining a collection of related tools."""
+
+    @abstractmethod
+    def get_tools(self) -> List[BaseTool]:
+        """Get the tools in the toolkit."""

langchain/agents/agent_toolkits/csv/__init__.py

@@ -0,0 +1 @@
+"""CSV toolkit."""

langchain/agents/agent_toolkits/csv/base.py

@@ -0,0 +1,17 @@
+"""Agent for working with csvs."""
+from typing import Any, Optional
+
+from langchain.agents.agent import AgentExecutor
+from langchain.agents.agent_toolkits.pandas.base import create_pandas_dataframe_agent
+from langchain.llms.base import BaseLLM
+
+
+def create_csv_agent(
+    llm: BaseLLM, path: str, pandas_kwargs: Optional[dict] = None, **kwargs: Any
+) -> AgentExecutor:
+    """Create csv agent by loading to a dataframe and using pandas agent."""
+    import pandas as pd
+
+    _kwargs = pandas_kwargs or {}
+    df = pd.read_csv(path, **_kwargs)
+    return create_pandas_dataframe_agent(llm, df, **kwargs)

langchain/agents/agent_toolkits/json/__init__.py

@@ -0,0 +1 @@
+"""Json agent."""

langchain/agents/agent_toolkits/json/base.py

@@ -0,0 +1,43 @@
+"""Json agent."""
+from typing import Any, List, Optional
+
+from langchain.agents.agent import AgentExecutor
+from langchain.agents.agent_toolkits.json.prompt import JSON_PREFIX, JSON_SUFFIX
+from langchain.agents.agent_toolkits.json.toolkit import JsonToolkit
+from langchain.agents.mrkl.base import ZeroShotAgent
+from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
+from langchain.callbacks.base import BaseCallbackManager
+from langchain.chains.llm import LLMChain
+from langchain.llms.base import BaseLLM
+
+
+def create_json_agent(
+    llm: BaseLLM,
+    toolkit: JsonToolkit,
+    callback_manager: Optional[BaseCallbackManager] = None,
+    prefix: str = JSON_PREFIX,
+    suffix: str = JSON_SUFFIX,
+    format_instructions: str = FORMAT_INSTRUCTIONS,
+    input_variables: Optional[List[str]] = None,
+    verbose: bool = False,
+    **kwargs: Any,
+) -> AgentExecutor:
+    """Construct a json agent from an LLM and tools."""
+    tools = toolkit.get_tools()
+    prompt = ZeroShotAgent.create_prompt(
+        tools,
+        prefix=prefix,
+        suffix=suffix,
+        format_instructions=format_instructions,
+        input_variables=input_variables,
+    )
+    llm_chain = LLMChain(
+        llm=llm,
+        prompt=prompt,
+        callback_manager=callback_manager,
+    )
+    tool_names = [tool.name for tool in tools]
+    agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)
+    return AgentExecutor.from_agent_and_tools(
+        agent=agent, tools=toolkit.get_tools(), verbose=verbose
+    )

langchain/agents/agent_toolkits/json/prompt.py

@@ -0,0 +1,25 @@
+# flake8: noqa
+
+JSON_PREFIX = """You are an agent designed to interact with JSON.
+Your goal is to return a final answer by interacting with the JSON.
+You have access to the following tools which help you learn more about the JSON you are interacting with.
+Only use the below tools. Only use the information returned by the below tools to construct your final answer.
+Do not make up any information that is not contained in the JSON.
+Your input to the tools should be in the form of `data["key"][0]` where `data` is the JSON blob you are interacting with, and the syntax used is Python. 
+You should only use keys that you know for a fact exist. You must validate that a key exists by seeing it previously when calling `json_spec_list_keys`. 
+If you have not seen a key in one of those responses, you cannot use it.
+You should only add one key at a time to the path. You cannot add multiple keys at once.
+If you encounter a "KeyError", go back to the previous key, look at the available keys, and try again.
+
+If the question does not seem to be related to the JSON, just return "I don't know" as the answer.
+Always begin your interaction with the `json_spec_list_keys` tool with input "data" to see what keys exist in the JSON.
+
+Note that sometimes the value at a given path is large. In this case, you will get an error "Value is a large dictionary, should explore its keys directly".
+In this case, you should ALWAYS follow up by using the `json_spec_list_keys` tool to see what keys exist at that path.
+Do not simply refer the user to the JSON or a section of the JSON, as this is not a valid answer. Keep digging until you find the answer and explicitly return it.
+"""
+JSON_SUFFIX = """Begin!"
+
+Question: {input}
+Thought: I should look at the keys that exist in data to see what I have access to
+{agent_scratchpad}"""

langchain/agents/agent_toolkits/json/toolkit.py

@@ -0,0 +1,21 @@
+"""Toolkit for interacting with a JSON spec."""
+from __future__ import annotations
+
+from typing import List
+
+from langchain.agents.agent_toolkits.base import BaseToolkit
+from langchain.tools import BaseTool
+from langchain.tools.json.tool import JsonGetValueTool, JsonListKeysTool, JsonSpec
+
+
+class JsonToolkit(BaseToolkit):
+    """Toolkit for interacting with a JSON spec."""
+
+    spec: JsonSpec
+
+    def get_tools(self) -> List[BaseTool]:
+        """Get the tools in the toolkit."""
+        return [
+            JsonListKeysTool(spec=self.spec),
+            JsonGetValueTool(spec=self.spec),
+        ]

langchain/agents/agent_toolkits/openapi/__init__.py

@@ -0,0 +1 @@
+"""OpenAPI spec agent."""

langchain/agents/agent_toolkits/openapi/base.py

@@ -0,0 +1,46 @@
+"""OpenAPI spec agent."""
+from typing import Any, List, Optional
+
+from langchain.agents.agent import AgentExecutor
+from langchain.agents.agent_toolkits.openapi.prompt import (
+    OPENAPI_PREFIX,
+    OPENAPI_SUFFIX,
+)
+from langchain.agents.agent_toolkits.openapi.toolkit import OpenAPIToolkit
+from langchain.agents.mrkl.base import ZeroShotAgent
+from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
+from langchain.callbacks.base import BaseCallbackManager
+from langchain.chains.llm import LLMChain
+from langchain.llms.base import BaseLLM
+
+
+def create_openapi_agent(
+    llm: BaseLLM,
+    toolkit: OpenAPIToolkit,
+    callback_manager: Optional[BaseCallbackManager] = None,
+    prefix: str = OPENAPI_PREFIX,
+    suffix: str = OPENAPI_SUFFIX,
+    format_instructions: str = FORMAT_INSTRUCTIONS,
+    input_variables: Optional[List[str]] = None,
+    verbose: bool = False,
+    **kwargs: Any,
+) -> AgentExecutor:
+    """Construct a json agent from an LLM and tools."""
+    tools = toolkit.get_tools()
+    prompt = ZeroShotAgent.create_prompt(
+        tools,
+        prefix=prefix,
+        suffix=suffix,
+        format_instructions=format_instructions,
+        input_variables=input_variables,
+    )
+    llm_chain = LLMChain(
+        llm=llm,
+        prompt=prompt,
+        callback_manager=callback_manager,
+    )
+    tool_names = [tool.name for tool in tools]
+    agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)
+    return AgentExecutor.from_agent_and_tools(
+        agent=agent, tools=toolkit.get_tools(), verbose=verbose
+    )