diff --git a/docs/source/notebooks/tool_usage/benchmark_all_tasks.ipynb b/docs/source/notebooks/tool_usage/benchmark_all_tasks.ipynb
index 70893eb..817a967 100644
--- a/docs/source/notebooks/tool_usage/benchmark_all_tasks.ipynb
+++ b/docs/source/notebooks/tool_usage/benchmark_all_tasks.ipynb
@@ -16,9 +16,22 @@
     "Note that this requires `langsmith>=0.0.72` to run the viz parts at the end."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "4525d100-b612-4118-af91-6bdc4aa3fb38",
+   "metadata": {},
+   "source": [
+    "## Set Up\n",
+    "\n",
+    "\n",
+    "### Credentials\n",
+    "\n",
+    "First, let's set up the models to be tested and the credentials."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 74,
+   "execution_count": null,
    "id": "387c494b-ad7e-452e-8d11-0d5d28db855c",
    "metadata": {
     "tags": []
@@ -31,9 +44,8 @@
     "# This is just the default list below\n",
     "required_env_vars = [\n",
     "    \"LANGCHAIN_API_KEY\",\n",
-    "    \"ANYSCALE_API_KEY\",\n",
+    "    \"CHATFIREWORKS_API_KEY\",\n",
     "    \"OPENAI_API_KEY\",\n",
-    "    \"ANTHROPIC_API_KEY\",\n",
     "]\n",
     "for var in required_env_vars:\n",
     "    if var not in os.environ:\n",
@@ -41,100 +53,92 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "ef54aa5f-02c7-4fa0-acd3-ed236d3c9cfc",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
+   "cell_type": "markdown",
+   "id": "d45e54ab-ebbe-4b9a-a596-facae66e1ced",
+   "metadata": {},
    "source": [
-    "# The current anthropic tools agent requires the code in https://github.com/anthropics/anthropic-tools/tree/main\n",
-    "# This will likely change in the near future.\n",
-    "# To run, clone the repo, install the deps from requirements.txt, then insert into your path\n",
-    "# import sys\n",
-    "# sys.path.insert(0, \"path/to/anthropic-tools/\")"
+    "### Instantiate Models"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "id": "13a7483b-d08f-49fa-83da-619863171e5b",
-   "metadata": {
-    "tags": []
-   },
+   "execution_count": 2,
+   "id": "d3a4e40a-5850-4a0b-b9af-36e9c8b55e8b",
+   "metadata": {},
    "outputs": [],
    "source": [
-    "import datetime\n",
+    "from langchain_anthropic import ChatAnthropic\n",
+    "from langchain_openai import ChatOpenAI\n",
     "\n",
-    "from langsmith.client import Client\n",
+    "from langchain_benchmarks.tool_usage.agents import StandardAgentFactory\n",
     "\n",
-    "from langchain_benchmarks import (\n",
-    "    __version__,\n",
-    "    clone_public_dataset,\n",
-    "    model_registry,\n",
-    "    registry,\n",
-    ")\n",
-    "from langchain_benchmarks.rate_limiting import RateLimiter\n",
-    "from langchain_benchmarks.tool_usage.agents import (\n",
-    "    AnthropicToolUserFactory,\n",
-    "    CustomAgentFactory,\n",
-    "    OpenAIAgentFactory,\n",
-    "    OpenAIAssistantFactory,\n",
-    ")"
+    "tests = [\n",
+    "    (\n",
+    "        \"claude-3-opus-20240229\",\n",
+    "        ChatAnthropic(model=\"claude-3-opus-20240229\", temperature=0),\n",
+    "    ),\n",
+    "    (\n",
+    "        \"claude-3-haiku-20240307\",\n",
+    "        ChatAnthropic(model=\"claude-3-haiku-20240307\", temperature=0),\n",
+    "    ),\n",
+    "    (\n",
+    "        \"claude-3-sonnet-20240229\",\n",
+    "        ChatAnthropic(model=\"claude-3-sonnet-20240229\", temperature=0),\n",
+    "    ),\n",
+    "    (\"gpt-3.5-turbo-0125\", ChatOpenAI(model=\"gpt-3.5-turbo-0125\", temperature=0)),\n",
+    "    (\n",
+    "        \"gpt-4-turbo-2024-04-09\",\n",
+    "        ChatOpenAI(model=\"gpt-4-turbo-2024-04-09\", temperature=0),\n",
+    "    ),\n",
+    "]"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "50bbe23b-a3b1-4607-929d-ea6e88b7085e",
+   "id": "6308c18a-209c-44f8-b762-7a07851101f2",
    "metadata": {},
    "source": [
-    "Prior to starting the tests, you may want to verify\n",
-    "that the task that you're working with and the models are propelry defined."
+    "### Set up the experiment"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "id": "e0f2bb0c-c741-4fb4-96bc-54b3ee88bf5b",
-   "metadata": {
-    "tags": []
-   },
+   "execution_count": 3,
+   "id": "16a15ce9-8244-49f1-9f38-28475891abff",
+   "metadata": {},
    "outputs": [],
    "source": [
-    "task = registry[\"Multiverse Math\"]"
+    "import datetime\n",
+    "import warnings\n",
+    "\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "\n",
+    "from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder\n",
+    "from langsmith.client import Client\n",
+    "\n",
+    "from langchain_benchmarks import (\n",
+    "    __version__,\n",
+    "    clone_public_dataset,\n",
+    "    model_registry,\n",
+    "    registry,\n",
+    ")\n",
+    "from langchain_benchmarks.rate_limiting import RateLimiter"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "adfbcaa9-349c-4223-89be-4abff9cf76ff",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'input': '(2 + 5) and then to the power of 0.5',\n",
-       " 'output': 'The answer is 192.54605765894036.',\n",
-       " 'intermediate_steps': [(OpenAIToolAgentAction(tool='add', tool_input={'a': 2, 'b': 5}, log=\"\\nInvoking: `add` with `{'a': 2, 'b': 5}`\\n\\n\\n\", message_log=[AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_76268389bcf249338904909d8c7d3c5d', 'function': {'arguments': '{\"a\": 2, \"b\": 5}', 'name': 'add'}, 'type': 'function'}]})], tool_call_id='call_76268389bcf249338904909d8c7d3c5d'),\n",
-       "   8.2),\n",
-       "  (OpenAIToolAgentAction(tool='power', tool_input={'a': 8.2, 'b': 0.5}, log=\"\\nInvoking: `power` with `{'a': 8.2, 'b': 0.5}`\\n\\n\\n\", message_log=[AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_5a5c579e178e4cc295344da7e9cd51c4', 'function': {'arguments': '{\"a\": 8.2, \"b\": 0.5}', 'name': 'power'}, 'type': 'function'}]})], tool_call_id='call_5a5c579e178e4cc295344da7e9cd51c4'),\n",
-       "   192.54605765894036)]}"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "id": "7db07dd7-0b73-4c0c-a13e-262a5e6433fa",
+   "metadata": {},
+   "outputs": [],
    "source": [
-    "agent_factory = OpenAIAgentFactory(\n",
-    "    task, model=\"mistral-7b-instruct-v0.1\"\n",
-    ")  # Follows OpenAI function format\n",
-    "# agent_factory = OpenAIAgentFactory(task, model='gpt-3.5-turbo-1106')\n",
-    "agent_factory().invoke({\"question\": \"(2 + 5) and then to the power of 0.5\"})"
+    "prompt = ChatPromptTemplate.from_messages(\n",
+    "    [\n",
+    "        (\"system\", \"{instructions}\"),  # Populated from task.instructions automatically\n",
+    "        (\"human\", \"{input}\"),  # Populated from the test dataset by each example\n",
+    "        MessagesPlaceholder(\"agent_scratchpad\"),  # Workspace for the agent\n",
+    "    ]\n",
+    ")"
    ]
   },
   {
@@ -147,14 +151,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "id": "066d7695-416c-4faf-8c33-c40e5f136672",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "experiment_uuid = \"woof\"  # Or generate ranom using uuid.uuid4().hex[:4]"
+    "experiment_uuid = \"sky1\"  # Or generate ranom using uuid.uuid4().hex[:4]\n",
+    "# experiment_uuid = uuid.uuid4().hex[:4]"
    ]
   },
   {
@@ -165,28 +170,6 @@
     "Define the test cases"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "26d390b6-9ade-424c-aabb-d450f52ed121",
-   "metadata": {
-    "tags": []
-   },
-   "outputs": [],
-   "source": [
-    "tests = [\n",
-    "    # 2-tuple of (architecture, model name)\n",
-    "    (\"anthropic_tool_user\", \"claude-2.1\"),\n",
-    "    (\"openai_functions\", \"mistral-7b-instruct-v0.1\"),\n",
-    "    (\"openai_functions\", \"gpt-3.5-turbo-1106\"),\n",
-    "    (\"openai_functions\", \"gpt-3.5-turbo-0613\"),\n",
-    "    (\"openai_functions\", \"gpt-4-1106-preview\"),\n",
-    "    (\"openai_functions\", \"gpt-4-0613\"),\n",
-    "    (\"openai_assistant\", \"gpt-4-1106-preview\"),\n",
-    "    (\"openai_assistant\", \"gpt-3.5-turbo-1106\"),\n",
-    "]"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "b55b7c24-8b4d-4bd7-8b00-365fbe61897f",
@@ -198,99 +181,45 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "e6fbc3ef-7a3f-430f-8b79-45af5861b3ee",
-   "metadata": {
-    "tags": []
-   },
+   "id": "03c4c45e-88a6-4c96-ba5d-cfaf03905789",
+   "metadata": {},
    "outputs": [],
    "source": [
-    "import uuid\n",
-    "\n",
     "client = Client()  # Launch langsmith client for cloning datasets\n",
     "today = datetime.date.today().isoformat()\n",
-    "rate_limiter = RateLimiter(requests_per_second=2)\n",
-    "num_retries = 0\n",
-    "# Whether to delete and re-run test projects that already exist\n",
-    "# False means skip\n",
-    "overwrite_project = False\n",
-    "overwrite_unfinished = True\n",
     "\n",
-    "for task in registry:\n",
+    "for task in registry.tasks:\n",
     "    if task.type != \"ToolUsageTask\":\n",
     "        continue\n",
     "\n",
-    "    dataset_name = task.name\n",
+    "    if task.name == \"Multiverse Math (Tiny)\":\n",
+    "        continue\n",
+    "\n",
+    "    dataset_name = task.name + f\" ({today})\"\n",
     "    clone_public_dataset(task.dataset_id, dataset_name=dataset_name)\n",
-    "    dataset = client.read_dataset(dataset_name=dataset_name)\n",
     "\n",
-    "    for arch, model in tests:\n",
+    "    for model_name, model in tests:\n",
     "        print()\n",
-    "        print(f\"Benchmarking {task.name} with model: {model} and arch: {arch}\")\n",
+    "        print(f\"Benchmarking {task.name} with model: {model_name}\")\n",
     "        eval_config = task.get_eval_config()\n",
+    "        rate_limiter = RateLimiter(requests_per_second=1)\n",
+    "        agent_factory = StandardAgentFactory(\n",
+    "            task, model, prompt, rate_limiter=rate_limiter\n",
+    "        )\n",
     "\n",
-    "        if arch == \"openai_functions\":\n",
-    "            agent_factory = OpenAIAgentFactory(\n",
-    "                task, model=model, rate_limiter=rate_limiter, num_retries=num_retries\n",
-    "            )\n",
-    "        elif arch == \"custom_agent\":\n",
-    "            agent_factory = CustomAgentFactory(\n",
-    "                task, model=model, rate_limiter=rate_limiter, num_retries=num_retries\n",
-    "            )\n",
-    "        elif arch == \"anthropic_tool_user\":\n",
-    "            agent_factory = AnthropicToolUserFactory(task)\n",
-    "        elif arch == \"openai_assistant\":\n",
-    "            agent_factory = OpenAIAssistantFactory(\n",
-    "                task, model=model, rate_limiter=rate_limiter, num_retries=num_retries\n",
-    "            )\n",
-    "        else:\n",
-    "            raise ValueError()\n",
-    "        project_name = f\"{model}-{arch}-{task.name}-{today}-{experiment_uuid}\"\n",
-    "        existing_project = None\n",
-    "        try:\n",
-    "            existing_project = client.read_project(project_name=project_name)\n",
-    "        except:\n",
-    "            pass\n",
-    "        if existing_project:\n",
-    "            if overwrite_project:\n",
-    "                print(f\"Archiving previous project {existing_project.name}\")\n",
-    "                new_name = f\"{existing_project.name} - Archived[{uuid.uuid4().hex[:4]}]\"\n",
-    "                client.update_project(\n",
-    "                    project_id=existing_project.id,\n",
-    "                    name=new_name,\n",
-    "                    metadata={**existing_project.metadata, \"archived\": True},\n",
-    "                )\n",
-    "            elif (\n",
-    "                overwrite_unfinished\n",
-    "                and existing_project.end_time is None\n",
-    "                and existing_project.run_count < dataset.example_count\n",
-    "            ):\n",
-    "                print(f\"Archiving unfinished project {existing_project.name}\")\n",
-    "                new_name = f\"{existing_project.name} - Archived[{uuid.uuid4().hex[:4]}]\"\n",
-    "                client.update_project(\n",
-    "                    project_id=existing_project.id,\n",
-    "                    name=new_name,\n",
-    "                    end_time=datetime.datetime.utcnow(),\n",
-    "                    metadata={**existing_project.metadata, \"archived\": True},\n",
-    "                )\n",
-    "            else:\n",
-    "                print(f\"Skipping {project_name} - already run\")\n",
-    "                continue\n",
     "        client.run_on_dataset(\n",
     "            dataset_name=dataset_name,\n",
     "            llm_or_chain_factory=agent_factory,\n",
     "            evaluation=eval_config,\n",
     "            verbose=False,\n",
-    "            project_name=project_name,\n",
-    "            tags=[model],\n",
+    "            project_name=f\"{model_name}-{task.name}-{today}-{experiment_uuid}\",\n",
     "            concurrency_level=5,\n",
     "            project_metadata={\n",
-    "                \"model\": model,\n",
+    "                \"model\": model_name,\n",
     "                \"id\": experiment_uuid,\n",
     "                \"task\": task.name,\n",
     "                \"date\": today,\n",
     "                \"langchain_benchmarks_version\": __version__,\n",
-    "                \"arch\": arch,\n",
-    "                \"archived\": False,\n",
     "            },\n",
     "        )"
    ]
@@ -307,7 +236,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 14,
+   "id": "598b92f0-7d64-4731-b294-05948d4db562",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install --quiet -U pandas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
    "id": "7818572a-a5fb-4153-bbe0-6f9e90813a22",
    "metadata": {
     "tags": []
@@ -330,36 +269,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": 17,
    "id": "44822aa4-8c4e-46be-8126-b79a9acdf8e1",
    "metadata": {
     "tags": []
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\"None of ['example_id'] are in the columns\" 0\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/var/folders/gf/6rnp_mbx5914kx7qmmh7xzmw0000gn/T/ipykernel_60065/1691579366.py:29: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
-      "  df = pd.concat(dfs)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "experiment_ids = [\"woof\"]\n",
+    "experiment_ids = [\"sky1\"]\n",
     "dataset_names = [task.name for task in registry.filter(Type=\"ToolUsageTask\")]\n",
     "\n",
     "client = Client()\n",
     "projects = []\n",
     "for dataset_name in dataset_names:\n",
-    "    for project in client.list_projects(reference_dataset_name=dataset_name):\n",
+    "    dataset_name_ = dataset_name + f\" ({today})\"\n",
+    "    for project in client.list_projects(reference_dataset_name=dataset_name_):\n",
     "        if (\n",
     "            project.metadata.get(\"id\") in experiment_ids\n",
     "            and project.end_time is not None\n",
@@ -397,7 +321,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 22,
    "id": "b3c0466a-25f4-44d7-bd2a-20da51461994",
    "metadata": {
     "tags": []
@@ -408,7 +332,7 @@
     "\n",
     "for r in df.to_dict(orient=\"records\"):\n",
     "    if \"Typewriter\" in r[\"task\"]:\n",
-    "        correct.append(r[\"feedback.Correct Final State\"])\n",
+    "        correct.append(r[\"feedback.correct final state\"])\n",
     "    else:\n",
     "        correct.append(r[\"feedback.correctness\"])\n",
     "\n",
@@ -426,17 +350,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": 26,
    "id": "c59d080c-d3ac-43c3-a527-9961913db2ba",
    "metadata": {
     "tags": []
    },
    "outputs": [],
    "source": [
-    "num_correct = (\n",
-    "    df.groupby([\"model\", \"arch\", \"task\"])[\"correct\"].sum().to_frame(\"num_correct\")\n",
-    ")\n",
-    "total = df.groupby([\"task\", \"model\", \"arch\"]).size().to_frame(\"total\")\n",
+    "num_correct = df.groupby([\"model\", \"task\"])[\"correct\"].sum().to_frame(\"num_correct\")\n",
+    "total = df.groupby([\"task\", \"model\"]).size().to_frame(\"total\")\n",
     "stats_df = total.join(num_correct)\n",
     "stats_df[\"% correct\"] = stats_df[\"num_correct\"] / stats_df[\"total\"]\n",
     "stats_df[\"error\"] = np.sqrt(\n",
@@ -451,8 +373,23 @@
     "]\n",
     "\n",
     "stats_df = stats_df.reset_index()\n",
-    "models = stats_df[\"model\"].unique()\n",
-    "arches = stats_df[\"arch\"].unique()"
+    "models = stats_df[\"model\"].unique()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "d07e1df5-8c68-4376-b997-337e6463ad3e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "models = [\n",
+    "    \"claude-3-haiku-20240307\",\n",
+    "    \"claude-3-sonnet-20240229\",\n",
+    "    \"claude-3-opus-20240229\",\n",
+    "    \"gpt-3.5-turbo-0125\",\n",
+    "    \"gpt-4-turbo-2024-04-09\",\n",
+    "]"
    ]
   },
   {
@@ -467,7 +404,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": 42,
    "id": "69df66a1-960c-40a3-abc8-58b503fceda5",
    "metadata": {
     "tags": []
@@ -475,7 +412,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1600x400 with 1 Axes>"
       ]
@@ -494,15 +431,11 @@
     "fig, ax = plt.subplots(layout=\"constrained\", figsize=(16, 4))\n",
     "colormap = plt.get_cmap(\"Set2\").colors\n",
     "idx = 0\n",
-    "for model, arch in product(models, arches):\n",
+    "for model in models:\n",
     "    try:\n",
     "        results = stats_df.set_index(\"model\").loc[model]\n",
     "    except:\n",
     "        continue\n",
-    "    try:\n",
-    "        results = results.set_index(\"arch\").loc[arch]\n",
-    "    except:\n",
-    "        continue\n",
     "    if len(results) == 0:\n",
     "        continue\n",
     "    color = colormap[idx]\n",
@@ -518,7 +451,7 @@
     "        x + offset,\n",
     "        values,\n",
     "        width,\n",
-    "        label=f\"{model} ({arch})\",\n",
+    "        label=f\"{model}\",\n",
     "        yerr=results[\"error\"],\n",
     "        color=color,\n",
     "    )\n",
@@ -554,7 +487,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.2"
+   "version": "3.11.4"
   }
  },
  "nbformat": 4,
diff --git a/langchain_benchmarks/tool_usage/agents/tool_using_agent.py b/langchain_benchmarks/tool_usage/agents/tool_using_agent.py
index cc1de36..767f8ab 100644
--- a/langchain_benchmarks/tool_usage/agents/tool_using_agent.py
+++ b/langchain_benchmarks/tool_usage/agents/tool_using_agent.py
@@ -2,11 +2,14 @@
 
 This is useful for agents that follow the standard LangChain tool format.
 """
+from typing import Optional
+
 from langchain.agents import AgentExecutor
 from langchain_core.language_models import BaseChatModel
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.runnables import Runnable
 
+from langchain_benchmarks.rate_limiting import RateLimiter, with_rate_limit
 from langchain_benchmarks.schema import ToolUsageTask
 from langchain_benchmarks.tool_usage.agents.adapters import apply_agent_executor_adapter
 
@@ -23,6 +26,8 @@ def __init__(
         task: ToolUsageTask,
         model: BaseChatModel,
         prompt: ChatPromptTemplate,
+        *,
+        rate_limiter: Optional[RateLimiter] = None,
     ) -> None:
         """Create an agent factory for the given tool usage task.
 
@@ -41,10 +46,12 @@ def __init__(
                         MessagesPlaceholder("agent_scratchpad"),
                     ]
                 )
+            rate_limiter: will be appended to the agent runnable
         """
         self.task = task
         self.model = model
         self.prompt = prompt
+        self.rate_limiter = rate_limiter
 
     def __call__(self) -> Runnable:
         """Call the factory to create Runnable agent."""
@@ -60,6 +67,9 @@ def __call__(self) -> Runnable:
 
         agent = create_tool_calling_agent(self.model, env.tools, finalized_prompt)
 
+        if self.rate_limiter:
+            agent = with_rate_limit(agent, self.rate_limiter)
+
         executor = AgentExecutor(
             agent=agent,
             tools=env.tools,
diff --git a/poetry.lock b/poetry.lock
index 4b9a42e..a68dbb5 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -599,6 +599,25 @@ files = [
 [package.dependencies]
 colorama = {version = "*", markers = "platform_system == \"Windows\""}
 
+[[package]]
+name = "cohere"
+version = "5.1.8"
+description = ""
+optional = false
+python-versions = "<4.0,>=3.8"
+files = [
+    {file = "cohere-5.1.8-py3-none-any.whl", hash = "sha256:420ebd0fe8fb34c69adfd6081d75cd3954f498f27dff44e0afa539958e9179ed"},
+    {file = "cohere-5.1.8.tar.gz", hash = "sha256:2ce7e8541c834d5c01991ededf1d1535f76fef48515fb06dc00f284b62245b9c"},
+]
+
+[package.dependencies]
+fastavro = ">=1.9.4,<2.0.0"
+httpx = ">=0.21.2"
+pydantic = ">=1.9.2"
+requests = ">=2.31.0,<3.0.0"
+types-requests = ">=2.31.0.20240311,<3.0.0.0"
+typing_extensions = ">=4.0.0"
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -822,6 +841,52 @@ files = [
 [package.extras]
 tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"]
 
+[[package]]
+name = "fastavro"
+version = "1.9.4"
+description = "Fast read/write of AVRO files"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fastavro-1.9.4-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:60cb38f07462a7fb4e4440ed0de67d3d400ae6b3d780f81327bebde9aa55faef"},
+    {file = "fastavro-1.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:063d01d197fc929c20adc09ca9f0ca86d33ac25ee0963ce0b438244eee8315ae"},
+    {file = "fastavro-1.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87a9053fcfbc895f2a16a4303af22077e3a8fdcf1cd5d6ed47ff2ef22cbba2f0"},
+    {file = "fastavro-1.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:02bf1276b7326397314adf41b34a4890f6ffa59cf7e0eb20b9e4ab0a143a1598"},
+    {file = "fastavro-1.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:56bed9eca435389a8861e6e2d631ec7f8f5dda5b23f93517ac710665bd34ca29"},
+    {file = "fastavro-1.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:0cd2099c8c672b853e0b20c13e9b62a69d3fbf67ee7c59c7271ba5df1680310d"},
+    {file = "fastavro-1.9.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:af8c6d8c43a02b5569c093fc5467469541ac408c79c36a5b0900d3dd0b3ba838"},
+    {file = "fastavro-1.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4a138710bd61580324d23bc5e3df01f0b82aee0a76404d5dddae73d9e4c723f"},
+    {file = "fastavro-1.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:903d97418120ca6b6a7f38a731166c1ccc2c4344ee5e0470d09eb1dc3687540a"},
+    {file = "fastavro-1.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c443eeb99899d062dbf78c525e4614dd77e041a7688fa2710c224f4033f193ae"},
+    {file = "fastavro-1.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ac26ab0774d1b2b7af6d8f4300ad20bbc4b5469e658a02931ad13ce23635152f"},
+    {file = "fastavro-1.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:cf7247874c22be856ba7d1f46a0f6e0379a6025f1a48a7da640444cbac6f570b"},
+    {file = "fastavro-1.9.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:68912f2020e1b3d70557260b27dd85fb49a4fc6bfab18d384926127452c1da4c"},
+    {file = "fastavro-1.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6925ce137cdd78e109abdb0bc33aad55de6c9f2d2d3036b65453128f2f5f5b92"},
+    {file = "fastavro-1.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b928cd294e36e35516d0deb9e104b45be922ba06940794260a4e5dbed6c192a"},
+    {file = "fastavro-1.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:90c9838bc4c991ffff5dd9d88a0cc0030f938b3fdf038cdf6babde144b920246"},
+    {file = "fastavro-1.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:eca6e54da571b06a3c5a72dbb7212073f56c92a6fbfbf847b91c347510f8a426"},
+    {file = "fastavro-1.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a4b02839ac261100cefca2e2ad04cdfedc556cb66b5ec735e0db428e74b399de"},
+    {file = "fastavro-1.9.4-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:4451ee9a305a73313a1558d471299f3130e4ecc10a88bf5742aa03fb37e042e6"},
+    {file = "fastavro-1.9.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8524fccfb379565568c045d29b2ebf71e1f2c0dd484aeda9fe784ef5febe1a8"},
+    {file = "fastavro-1.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33d0a00a6e09baa20f6f038d7a2ddcb7eef0e7a9980e947a018300cb047091b8"},
+    {file = "fastavro-1.9.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:23d7e5b29c9bf6f26e8be754b2c8b919838e506f78ef724de7d22881696712fc"},
+    {file = "fastavro-1.9.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2e6ab3ee53944326460edf1125b2ad5be2fadd80f7211b13c45fa0c503b4cf8d"},
+    {file = "fastavro-1.9.4-cp38-cp38-win_amd64.whl", hash = "sha256:64d335ec2004204c501f8697c385d0a8f6b521ac82d5b30696f789ff5bc85f3c"},
+    {file = "fastavro-1.9.4-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:7e05f44c493e89e73833bd3ff3790538726906d2856f59adc8103539f4a1b232"},
+    {file = "fastavro-1.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:253c63993250bff4ee7b11fb46cf3a4622180a783bedc82a24c6fdcd1b10ca2a"},
+    {file = "fastavro-1.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24d6942eb1db14640c2581e0ecd1bbe0afc8a83731fcd3064ae7f429d7880cb7"},
+    {file = "fastavro-1.9.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d47bb66be6091cd48cfe026adcad11c8b11d7d815a2949a1e4ccf03df981ca65"},
+    {file = "fastavro-1.9.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c293897f12f910e58a1024f9c77f565aa8e23b36aafda6ad8e7041accc57a57f"},
+    {file = "fastavro-1.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:f05d2afcb10a92e2a9e580a3891f090589b3e567fdc5641f8a46a0b084f120c3"},
+    {file = "fastavro-1.9.4.tar.gz", hash = "sha256:56b8363e360a1256c94562393dc7f8611f3baf2b3159f64fb2b9c6b87b14e876"},
+]
+
+[package.extras]
+codecs = ["cramjam", "lz4", "zstandard"]
+lz4 = ["lz4"]
+snappy = ["cramjam"]
+zstandard = ["zstandard"]
+
 [[package]]
 name = "fastjsonschema"
 version = "2.19.1"
@@ -852,6 +917,23 @@ docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1
 testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8.0.1)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"]
 typing = ["typing-extensions (>=4.8)"]
 
+[[package]]
+name = "fireworks-ai"
+version = "0.13.0"
+description = "Python client library for the Fireworks.ai Generative AI Platform"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "fireworks-ai-0.13.0.tar.gz", hash = "sha256:d6db1e60f65f237b6e87e3e9c028681be0ba77496df398db386ae2876dab54e0"},
+    {file = "fireworks_ai-0.13.0-py3-none-any.whl", hash = "sha256:900559d7eeea8a86dc5789f9034b3873684a685a2e96b56a63e6be3a04803eb6"},
+]
+
+[package.dependencies]
+httpx = "*"
+httpx-sse = "*"
+Pillow = "*"
+pydantic = "*"
+
 [[package]]
 name = "fqdn"
 version = "1.5.1"
@@ -1069,6 +1151,25 @@ files = [
 docs = ["Sphinx", "furo"]
 test = ["objgraph", "psutil"]
 
+[[package]]
+name = "groq"
+version = "0.4.2"
+description = "The official Python library for the groq API"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "groq-0.4.2-py3-none-any.whl", hash = "sha256:5b2b472c64d9f35210e0487db465415d47162da3a114031ecbfc8843d26302a5"},
+    {file = "groq-0.4.2.tar.gz", hash = "sha256:42e8b0abd0f2b2da024b9a747d28960d62951a5364f078e1537c9fceeca8259d"},
+]
+
+[package.dependencies]
+anyio = ">=3.5.0,<5"
+distro = ">=1.7.0,<2"
+httpx = ">=0.23.0,<1"
+pydantic = ">=1.9.0,<3"
+sniffio = "*"
+typing-extensions = ">=4.7,<5"
+
 [[package]]
 name = "h11"
 version = "0.14.0"
@@ -1125,6 +1226,17 @@ cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
 http2 = ["h2 (>=3,<5)"]
 socks = ["socksio (==1.*)"]
 
+[[package]]
+name = "httpx-sse"
+version = "0.4.0"
+description = "Consume Server-Sent Event (SSE) messages with HTTPX."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "httpx-sse-0.4.0.tar.gz", hash = "sha256:1e81a3a3070ce322add1d3529ed42eb5f70817f45ed6ec915ab753f961139721"},
+    {file = "httpx_sse-0.4.0-py3-none-any.whl", hash = "sha256:f329af6eae57eaa2bdfd962b42524764af68075ea87370a2de920af5341e318f"},
+]
+
 [[package]]
 name = "huggingface-hub"
 version = "0.22.2"
@@ -1813,6 +1925,26 @@ reference = "HEAD"
 resolved_reference = "9eb6f538f058af294e365c87ab2c7dae150f535d"
 subdirectory = "libs/partners/anthropic"
 
+[[package]]
+name = "langchain-cohere"
+version = "0.1.1"
+description = "An integration package connecting Cohere and LangChain"
+optional = false
+python-versions = ">=3.8.1,<4.0"
+files = []
+develop = false
+
+[package.dependencies]
+cohere = ">=5.1.8,<5.2"
+langchain-core = "^0.1.32"
+
+[package.source]
+type = "git"
+url = "https://github.com/langchain-ai/langchain-cohere.git"
+reference = "HEAD"
+resolved_reference = "a5372aebf43a18e1e0020f4cf96ad120beb4ec2e"
+subdirectory = "libs/cohere"
+
 [[package]]
 name = "langchain-community"
 version = "0.0.32"
@@ -1866,6 +1998,71 @@ reference = "HEAD"
 resolved_reference = "9eb6f538f058af294e365c87ab2c7dae150f535d"
 subdirectory = "libs/core"
 
+[[package]]
+name = "langchain-fireworks"
+version = "0.1.1"
+description = "An integration package connecting Fireworks and LangChain"
+optional = false
+python-versions = ">=3.8.1,<4.0"
+files = []
+develop = false
+
+[package.dependencies]
+aiohttp = "^3.9.1"
+fireworks-ai = ">=0.13.0"
+langchain-core = "^0.1.27"
+openai = "^1.10.0"
+requests = "^2"
+
+[package.source]
+type = "git"
+url = "https://github.com/langchain-ai/langchain.git"
+reference = "HEAD"
+resolved_reference = "9eb6f538f058af294e365c87ab2c7dae150f535d"
+subdirectory = "libs/partners/fireworks"
+
+[[package]]
+name = "langchain-groq"
+version = "0.1.1"
+description = "An integration package connecting Groq and LangChain"
+optional = false
+python-versions = ">=3.8.1,<4.0"
+files = []
+develop = false
+
+[package.dependencies]
+groq = ">=0.4.1,<1"
+langchain-core = "^0.1.41"
+
+[package.source]
+type = "git"
+url = "https://github.com/langchain-ai/langchain.git"
+reference = "HEAD"
+resolved_reference = "9eb6f538f058af294e365c87ab2c7dae150f535d"
+subdirectory = "libs/partners/groq"
+
+[[package]]
+name = "langchain-mistralai"
+version = "0.1.2rc1"
+description = "An integration package connecting Mistral and LangChain"
+optional = false
+python-versions = ">=3.8.1,<4.0"
+files = []
+develop = false
+
+[package.dependencies]
+httpx = ">=0.25.2,<1"
+httpx-sse = ">=0.3.1,<1"
+langchain-core = "^0.1.42rc1"
+tokenizers = "^0.15.1"
+
+[package.source]
+type = "git"
+url = "https://github.com/langchain-ai/langchain.git"
+reference = "HEAD"
+resolved_reference = "9eb6f538f058af294e365c87ab2c7dae150f535d"
+subdirectory = "libs/partners/mistralai"
+
 [[package]]
 name = "langchain-openai"
 version = "0.1.3rc1"
@@ -2657,6 +2854,92 @@ files = [
     {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"},
 ]
 
+[[package]]
+name = "pillow"
+version = "10.3.0"
+description = "Python Imaging Library (Fork)"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"},
+    {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"},
+    {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"},
+    {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"},
+    {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"},
+    {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"},
+    {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"},
+    {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"},
+    {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"},
+    {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"},
+    {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"},
+    {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"},
+    {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"},
+    {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"},
+    {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"},
+    {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"},
+    {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"},
+    {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"},
+    {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"},
+    {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"},
+    {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"},
+    {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"},
+    {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"},
+    {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"},
+    {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"},
+    {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"},
+    {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"},
+    {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"},
+    {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"},
+    {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"},
+    {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"},
+    {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"},
+    {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"},
+    {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"},
+    {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"},
+    {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"},
+    {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"},
+    {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"},
+    {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"},
+    {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"},
+    {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"},
+    {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"},
+]
+
+[package.extras]
+docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"]
+fpx = ["olefile"]
+mic = ["olefile"]
+tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"]
+typing = ["typing-extensions"]
+xmp = ["defusedxml"]
+
 [[package]]
 name = "pkgutil-resolve-name"
 version = "1.3.10"
@@ -4319,6 +4602,20 @@ files = [
     {file = "types_python_dateutil-2.9.0.20240316-py3-none-any.whl", hash = "sha256:6b8cb66d960771ce5ff974e9dd45e38facb81718cc1e208b10b1baccbfdbee3b"},
 ]
 
+[[package]]
+name = "types-requests"
+version = "2.31.0.20240406"
+description = "Typing stubs for requests"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "types-requests-2.31.0.20240406.tar.gz", hash = "sha256:4428df33c5503945c74b3f42e82b181e86ec7b724620419a2966e2de604ce1a1"},
+    {file = "types_requests-2.31.0.20240406-py3-none-any.whl", hash = "sha256:6216cdac377c6b9a040ac1c0404f7284bd13199c0e1bb235f4324627e8898cf5"},
+]
+
+[package.dependencies]
+urllib3 = ">=2"
+
 [[package]]
 name = "typing-extensions"
 version = "4.11.0"
@@ -4602,4 +4899,4 @@ testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "p
 [metadata]
 lock-version = "2.0"
 python-versions = "^3.8.1"
-content-hash = "aa09bb84cdbc9c5eae4aaa6c5de4d1d0e1ffac256709979e8fe790d1b701ca7c"
+content-hash = "18b0ed104a1d2a2e6ae790dcb81c48f4b4686877ea097fec6ea72597d22086cb"
diff --git a/pyproject.toml b/pyproject.toml
index 756188d..963d01f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-benchmarks"
-version = "0.0.10"
+version = "0.0.11"
 description = "🦜💪 Flex those feathers!"
 authors = ["LangChain AI"]
 license = "MIT"
@@ -22,8 +22,13 @@ jupyter = "^1.0.0"
 langchain-core = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core"}
 langchain = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/langchain"}
 langchain-anthropic = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/anthropic"}
+langchain-fireworks = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/fireworks"}
+langchain-mistralai = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/mistralai"}
+langchain-cohere = {git = "https://github.com/langchain-ai/langchain-cohere.git", subdirectory="libs/cohere"}
+langchain-groq = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/groq"}
 langchain-openai = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/openai"}
 
+
 [tool.poetry.group.typing]
 optional = true
 
@@ -32,6 +37,10 @@ mypy = "^1.7.0"
 langchain-core = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core"}
 langchain = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/langchain"}
 langchain-anthropic = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/anthropic"}
+langchain-fireworks = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/fireworks"}
+langchain-mistralai = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/mistralai"}
+langchain-cohere = {git = "https://github.com/langchain-ai/langchain-cohere.git", subdirectory="libs/cohere"}
+langchain-groq = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/groq"}
 langchain-openai = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/openai"}
 
 [tool.poetry.group.lint]
@@ -67,9 +76,12 @@ freezegun = "^1.3.1"
 langchain-core = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core"}
 langchain = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/langchain"}
 langchain-anthropic = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/anthropic"}
+langchain-fireworks = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/fireworks"}
+langchain-mistralai = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/mistralai"}
+langchain-cohere = {git = "https://github.com/langchain-ai/langchain-cohere.git", subdirectory="libs/cohere"}
+langchain-groq = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/groq"}
 langchain-openai = {git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/partners/openai"}
 
-
 [tool.ruff]
 select = [
     "E",  # pycodestyle