Add GooseAI, CerebriumAI, Petals, ForefrontAI (#981)

Add GooseAI, CerebriumAI, Petals, ForefrontAI

docs/ecosystem/cerebriumai.md

@@ -0,0 +1,17 @@
+# CerebriumAI
+
+This page covers how to use the CerebriumAI ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific CerebriumAI wrappers.
+
+## Installation and Setup
+- Install with `pip install cerebrium`
+- Get an CerebriumAI api key and set it as an environment variable (`CEREBRIUMAI_API_KEY`)
+
+## Wrappers
+
+### LLM
+
+There exists an CerebriumAI LLM wrapper, which you can access with 
+```python
+from langchain.llms import CerebriumAI
+```

docs/ecosystem/forefrontai.md

@@ -0,0 +1,16 @@
+# ForefrontAI
+
+This page covers how to use the ForefrontAI ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific ForefrontAI wrappers.
+
+## Installation and Setup
+- Get an ForefrontAI api key and set it as an environment variable (`FOREFRONTAI_API_KEY`)
+
+## Wrappers
+
+### LLM
+
+There exists an ForefrontAI LLM wrapper, which you can access with 
+```python
+from langchain.llms import ForefrontAI
+```

docs/ecosystem/gooseai.md

@@ -0,0 +1,23 @@
+# GooseAI
+
+This page covers how to use the GooseAI ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific GooseAI wrappers.
+
+## Installation and Setup
+- Install the Python SDK with `pip install openai`
+- Get your GooseAI api key from this link [here](https://goose.ai/).
+- Set the environment variable (`GOOSEAI_API_KEY`).
+
+```python
+import os
+os.environ["GOOSEAI_API_KEY"] = "YOUR_API_KEY"
+```
+
+## Wrappers
+
+### LLM
+
+There exists an GooseAI LLM wrapper, which you can access with: 
+```python
+from langchain.llms import GooseAI
+```

docs/ecosystem/petals.md

@@ -0,0 +1,17 @@
+# Petals
+
+This page covers how to use the Petals ecosystem within LangChain.
+It is broken into two parts: installation and setup, and then references to specific Petals wrappers.
+
+## Installation and Setup
+- Install with `pip install petals`
+- Get an Huggingface api key and set it as an environment variable (`HUGGINGFACE_API_KEY`)
+
+## Wrappers
+
+### LLM
+
+There exists an Petals LLM wrapper, which you can access with 
+```python
+from langchain.llms import Petals
+```

docs/modules/llms/integrations.rst

@@ -9,6 +9,14 @@ The examples here are all "how-to" guides for how to integrate with various LLM
 
 `Manifest <./integrations/manifest.html>`_: Covers how to utilize the Manifest wrapper.
 
+`Goose AI <./integrations/gooseai_example.html>`_: Covers how to utilize the Goose AI wrapper.
+
+`Cerebrium <./integrations/cerebriumai_example.html>`_: Covers how to utilize the Cerebrium AI wrapper.
+
+`Petals <./integrations/petals_example.html>`_: Covers how to utilize the Petals wrapper.
+
+`Forefront AI <./integrations/forefrontai_example.html>`_: Covers how to utilize the Forefront AI wrapper.
+
 
 .. toctree::
    :maxdepth: 1

docs/modules/llms/integrations/cerebriumai_example.ipynb

@@ -0,0 +1,156 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# CerebriumAI LLM Example\n",
+    "This notebook goes over how to use Langchain with [CerebriumAI](https://docs.cerebrium.ai/introduction)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Install cerebrium\n",
+    "The `cerebrium` package is required to use the CerebriumAI API. Install `cerebrium` using `pip3 install cerebrium`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "$ pip3 install cerebrium"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from langchain.llms import CerebriumAI\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set the Environment API Key\n",
+    "Make sure to get your API key from CerebriumAI. You are given a 1 hour free of serverless GPU compute to test different models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"CEREBRIUMAI_API_KEY\"] = \"YOUR_KEY_HERE\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the CerebriumAI instance\n",
+    "You can specify different parameters such as the model endpoint url, max length, temperature, etc. You must provide an endpoint url."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = CerebriumAI(endpoint_url=\"YOUR ENDPOINT URL HERE\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a Prompt Template\n",
+    "We will create a prompt template for Question and Answer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initiate the LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the LLMChain\n",
+    "Provide a question and run the LLMChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
+    "\n",
+    "llm_chain.run(question)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.12 ('palm')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.9.12"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "a0a0263b650d907a3bfe41c0f8d6a63a071b884df3cfdc1579f00cdc1aed6b03"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/modules/llms/integrations/forefrontai_example.ipynb

@@ -0,0 +1,139 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# ForefrontAI LLM Example\n",
+    "This notebook goes over how to use Langchain with [ForefrontAI](https://www.forefront.ai/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from langchain.llms import ForefrontAI\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set the Environment API Key\n",
+    "Make sure to get your API key from ForefrontAI. You are given a 5 day free trial to test different models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"FOREFRONTAI_API_KEY\"] = \"YOUR_KEY_HERE\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the ForefrontAI instance\n",
+    "You can specify different parameters such as the model endpoint url, length, temperature, etc. You must provide an endpoint url."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = ForefrontAI(endpoint_url=\"YOUR ENDPOINT URL HERE\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a Prompt Template\n",
+    "We will create a prompt template for Question and Answer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initiate the LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the LLMChain\n",
+    "Provide a question and run the LLMChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
+    "\n",
+    "llm_chain.run(question)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.12 ('palm')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.9.12"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "a0a0263b650d907a3bfe41c0f8d6a63a071b884df3cfdc1579f00cdc1aed6b03"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/modules/llms/integrations/gooseai_example.ipynb

@@ -0,0 +1,156 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# GooseAI LLM Example\n",
+    "This notebook goes over how to use Langchain with [GooseAI](https://goose.ai/)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Install openai\n",
+    "The `openai` package is required to use the GooseAI API. Install `openai` using `pip3 install openai`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "$ pip3 install openai"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from langchain.llms import GooseAI\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set the Environment API Key\n",
+    "Make sure to get your API key from GooseAI. You are given $10 in free credits to test different models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"GOOSEAI_API_KEY\"] = \"YOUR_KEY_HERE\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the GooseAI instance\n",
+    "You can specify different parameters such as the model name, max tokens generated, temperature, etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = GooseAI()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a Prompt Template\n",
+    "We will create a prompt template for Question and Answer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initiate the LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the LLMChain\n",
+    "Provide a question and run the LLMChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
+    "\n",
+    "llm_chain.run(question)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.12 ('palm')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.9.12"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "a0a0263b650d907a3bfe41c0f8d6a63a071b884df3cfdc1579f00cdc1aed6b03"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/modules/llms/integrations/petals_example.ipynb

@@ -0,0 +1,156 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Petals LLM Example\n",
+    "This notebook goes over how to use Langchain with [Petals](https://github.com/bigscience-workshop/petals)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Install petals\n",
+    "The `petals` package is required to use the Petals API. Install `petals` using `pip3 install petals`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "$ pip3 install petals"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from langchain.llms import Petals\n",
+    "from langchain import PromptTemplate, LLMChain"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Set the Environment API Key\n",
+    "Make sure to get your API key from Huggingface."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "os.environ[\"HUGGINGFACE_API_KEY\"] = \"YOUR_KEY_HERE\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create the Petals instance\n",
+    "You can specify different parameters such as the model name, max new tokens, temperature, etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm = Petals(model_name=\"bigscience/bloom-petals\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create a Prompt Template\n",
+    "We will create a prompt template for Question and Answer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template = \"\"\"Question: {question}\n",
+    "\n",
+    "Answer: Let's think step by step.\"\"\"\n",
+    "\n",
+    "prompt = PromptTemplate(template=template, input_variables=[\"question\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initiate the LLMChain"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "llm_chain = LLMChain(prompt=prompt, llm=llm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run the LLMChain\n",
+    "Provide a question and run the LLMChain."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "question = \"What NFL team won the Super Bowl in the year Justin Beiber was born?\"\n",
+    "\n",
+    "llm_chain.run(question)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.9.12 ('palm')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.9.12"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "a0a0263b650d907a3bfe41c0f8d6a63a071b884df3cfdc1579f00cdc1aed6b03"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

docs/reference/integrations.md

@@ -12,9 +12,18 @@ The following use cases require specific installs and api keys:
 - _Cohere_:
   - Install requirements with `pip install cohere`
   - Get a Cohere api key and either set it as an environment variable (`COHERE_API_KEY`) or pass it to the LLM constructor as `cohere_api_key`.
+- _GooseAI_:
+  - Install requirements with `pip install openai`
+  - Get an GooseAI api key and either set it as an environment variable (`GOOSEAI_API_KEY`) or pass it to the LLM constructor as `gooseai_api_key`.
 - _Hugging Face Hub_
   - Install requirements with `pip install huggingface_hub`
   - Get a Hugging Face Hub api token and either set it as an environment variable (`HUGGINGFACEHUB_API_TOKEN`) or pass it to the LLM constructor as `huggingfacehub_api_token`.
+- _Petals_:
+  - Install requirements with `pip install petals`
+  - Get an GooseAI api key and either set it as an environment variable (`HUGGINGFACE_API_KEY`) or pass it to the LLM constructor as `huggingface_api_key`.
+- _CerebriumAI_:
+  - Install requirements with `pip install cerebrium`
+  - Get a Cerebrium api key and either set it as an environment variable (`CEREBRIUMAI_API_KEY`) or pass it to the LLM constructor as `cerebriumai_api_key`.
 - _SerpAPI_:
   - Install requirements with `pip install google-search-results`
   - Get a SerpAPI api key and either set it as an environment variable (`SERPAPI_API_KEY`) or pass it to the LLM constructor as `serpapi_api_key`.

langchain/__init__.py

@@ -22,7 +22,16 @@ from langchain.chains import (
     VectorDBQAWithSourcesChain,
 )
 from langchain.docstore import InMemoryDocstore, Wikipedia
-from langchain.llms import Anthropic, Cohere, HuggingFaceHub, OpenAI
+from langchain.llms import (
+    Anthropic,
+    CerebriumAI,
+    Cohere,
+    ForefrontAI,
+    GooseAI,
+    HuggingFaceHub,
+    OpenAI,
+    Petals,
+)
 from langchain.llms.huggingface_pipeline import HuggingFacePipeline
 from langchain.prompts import (
     BasePromptTemplate,
@@ -51,8 +60,12 @@ __all__ = [
     "GoogleSearchAPIWrapper",
     "WolframAlphaAPIWrapper",
     "Anthropic",
+    "CerebriumAI",
     "Cohere",
+    "ForefrontAI",
+    "GooseAI",
     "OpenAI",
+    "Petals",
     "BasePromptTemplate",
     "Prompt",
     "FewShotPromptTemplate",

langchain/llms/__init__.py

@@ -4,17 +4,25 @@ from typing import Dict, Type
 from langchain.llms.ai21 import AI21
 from langchain.llms.anthropic import Anthropic
 from langchain.llms.base import BaseLLM
+from langchain.llms.cerebriumai import CerebriumAI
 from langchain.llms.cohere import Cohere
+from langchain.llms.forefrontai import ForefrontAI
+from langchain.llms.gooseai import GooseAI
 from langchain.llms.huggingface_hub import HuggingFaceHub
 from langchain.llms.huggingface_pipeline import HuggingFacePipeline
 from langchain.llms.nlpcloud import NLPCloud
 from langchain.llms.openai import AzureOpenAI, OpenAI
+from langchain.llms.petals import Petals
 
 __all__ = [
     "Anthropic",
+    "CerebriumAI",
     "Cohere",
+    "ForefrontAI",
+    "GooseAI",
     "NLPCloud",
     "OpenAI",
+    "Petals",
     "HuggingFaceHub",
     "HuggingFacePipeline",
     "AI21",
@@ -24,10 +32,14 @@ __all__ = [
 type_to_cls_dict: Dict[str, Type[BaseLLM]] = {
     "ai21": AI21,
     "anthropic": Anthropic,
+    "cerebriumai": CerebriumAI,
     "cohere": Cohere,
+    "forefrontai": ForefrontAI,
+    "gooseai": GooseAI,
     "huggingface_hub": HuggingFaceHub,
     "nlpcloud": NLPCloud,
     "openai": OpenAI,
+    "petals": Petals,
     "huggingface_pipeline": HuggingFacePipeline,
     "azure": AzureOpenAI,
 }

langchain/llms/cerebriumai.py

@@ -0,0 +1,103 @@
+"""Wrapper around CerebriumAI API."""
+import logging
+from typing import Any, Dict, List, Mapping, Optional
+
+from pydantic import BaseModel, Extra, Field, root_validator
+
+from langchain.llms.base import LLM
+from langchain.llms.utils import enforce_stop_tokens
+from langchain.utils import get_from_dict_or_env
+
+logger = logging.getLogger(__name__)
+
+
+class CerebriumAI(LLM, BaseModel):
+    """Wrapper around CerebriumAI large language models.
+
+    To use, you should have the ``cerebrium`` python package installed, and the
+    environment variable ``CEREBRIUMAI_API_KEY`` set with your API key.
+
+    Any parameters that are valid to be passed to the call can be passed
+    in, even if not explicitly saved on this class.
+
+    Example:
+        .. code-block:: python
+            from langchain import CerebriumAI
+            cerebrium = CerebriumAI(endpoint_url="")
+
+    """
+
+    endpoint_url: str = ""
+    """model endpoint to use"""
+
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """Holds any model parameters valid for `create` call not
+    explicitly specified."""
+
+    cerebriumai_api_key: Optional[str] = None
+
+    class Config:
+        """Configuration for this pydantic config."""
+
+        extra = Extra.forbid
+
+    @root_validator(pre=True)
+    def build_extra(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Build extra kwargs from additional params that were passed in."""
+        all_required_field_names = {field.alias for field in cls.__fields__.values()}
+
+        extra = values.get("model_kwargs", {})
+        for field_name in list(values):
+            if field_name not in all_required_field_names:
+                if field_name in extra:
+                    raise ValueError(f"Found {field_name} supplied twice.")
+                logger.warning(
+                    f"""{field_name} was transfered to model_kwargs.
+                    Please confirm that {field_name} is what you intended."""
+                )
+                extra[field_name] = values.pop(field_name)
+        values["model_kwargs"] = extra
+        return values
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        cerebriumai_api_key = get_from_dict_or_env(
+            values, "cerebriumai_api_key", "CEREBRIUMAI_API_KEY"
+        )
+        values["cerebriumai_api_key"] = cerebriumai_api_key
+        return values
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {
+            **{"endpoint_url": self.endpoint_url},
+            **{"model_kwargs": self.model_kwargs},
+        }
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "cerebriumai"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        """Call to CerebriumAI endpoint."""
+        try:
+            from cerebrium import model_api_request
+        except ImportError:
+            raise ValueError(
+                "Could not import cerebrium python package. "
+                "Please install it with `pip install cerebrium`."
+            )
+
+        params = self.model_kwargs or {}
+        response = model_api_request(
+            self.endpoint_url, {"prompt": prompt, **params}, self.cerebriumai_api_key
+        )
+        text = response["data"]["result"]
+        if stop is not None:
+            # I believe this is required since the stop tokens
+            # are not enforced by the model parameters
+            text = enforce_stop_tokens(text, stop)
+        return text

langchain/llms/forefrontai.py

@@ -0,0 +1,113 @@
+"""Wrapper around ForefrontAI APIs."""
+from typing import Any, Dict, List, Mapping, Optional
+
+import requests
+from pydantic import BaseModel, Extra, root_validator
+
+from langchain.llms.base import LLM
+from langchain.llms.utils import enforce_stop_tokens
+from langchain.utils import get_from_dict_or_env
+
+
+class ForefrontAI(LLM, BaseModel):
+    """Wrapper around ForefrontAI large language models.
+
+    To use, you should have the environment variable ``FOREFRONTAI_API_KEY``
+    set with your API key.
+
+    Example:
+        .. code-block:: python
+
+            from langchain import ForefrontAI
+            forefrontai = ForefrontAI(endpoint_url="")
+    """
+
+    endpoint_url: str = ""
+    """Model name to use."""
+
+    temperature: float = 0.7
+    """What sampling temperature to use."""
+
+    length: int = 256
+    """The maximum number of tokens to generate in the completion."""
+
+    top_p: float = 1.0
+    """Total probability mass of tokens to consider at each step."""
+
+    top_k: int = 40
+    """The number of highest probability vocabulary tokens to
+    keep for top-k-filtering."""
+
+    repetition_penalty: int = 1
+    """Penalizes repeated tokens according to frequency."""
+
+    forefrontai_api_key: Optional[str] = None
+
+    base_url: Optional[str] = None
+    """Base url to use, if None decides based on model name."""
+
+    class Config:
+        """Configuration for this pydantic object."""
+
+        extra = Extra.forbid
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key exists in environment."""
+        forefrontai_api_key = get_from_dict_or_env(
+            values, "forefrontai_api_key", "FOREFRONTAI_API_KEY"
+        )
+        values["forefrontai_api_key"] = forefrontai_api_key
+        return values
+
+    @property
+    def _default_params(self) -> Mapping[str, Any]:
+        """Get the default parameters for calling ForefrontAI API."""
+        return {
+            "temperature": self.temperature,
+            "length": self.length,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "repetition_penalty": self.repetition_penalty,
+        }
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {**{"endpoint_url": self.endpoint_url}, **self._default_params}
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "forefrontai"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        """Call out to ForefrontAI's complete endpoint.
+
+        Args:
+            prompt: The prompt to pass into the model.
+            stop: Optional list of stop words to use when generating.
+
+        Returns:
+            The string generated by the model.
+
+        Example:
+            .. code-block:: python
+
+                response = ForefrontAI("Tell me a joke.")
+        """
+        response = requests.post(
+            url=self.endpoint_url,
+            headers={
+                "Authorization": f"Bearer {self.forefrontai_api_key}",
+                "Content-Type": "application/json",
+            },
+            json={"text": prompt, **self._default_params},
+        )
+        response_json = response.json()
+        text = response_json["result"][0]["completion"]
+        if stop is not None:
+            # I believe this is required since the stop tokens
+            # are not enforced by the model parameters
+            text = enforce_stop_tokens(text, stop)
+        return text

langchain/llms/gooseai.py

@@ -0,0 +1,143 @@
+"""Wrapper around GooseAI API."""
+import logging
+from typing import Any, Dict, List, Mapping, Optional
+
+from pydantic import BaseModel, Extra, Field, root_validator
+
+from langchain.llms.base import LLM
+from langchain.utils import get_from_dict_or_env
+
+logger = logging.getLogger(__name__)
+
+
+class GooseAI(LLM, BaseModel):
+    """Wrapper around OpenAI large language models.
+
+    To use, you should have the ``openai`` python package installed, and the
+    environment variable ``GOOSEAI_API_KEY`` set with your API key.
+
+    Any parameters that are valid to be passed to the openai.create call can be passed
+    in, even if not explicitly saved on this class.
+
+    Example:
+        .. code-block:: python
+            from langchain import GooseAI
+            gooseai = GooseAI(model_name="gpt-neo-20b")
+
+    """
+
+    client: Any
+
+    model_name: str = "gpt-neo-20b"
+    """Model name to use"""
+
+    temperature: float = 0.7
+    """What sampling temperature to use"""
+
+    max_tokens: int = 256
+    """The maximum number of tokens to generate in the completion.
+    -1 returns as many tokens as possible given the prompt and
+    the models maximal context size."""
+
+    top_p: float = 1
+    """Total probability mass of tokens to consider at each step."""
+
+    min_tokens: int = 1
+    """The minimum number of tokens to generate in the completion."""
+
+    frequency_penalty: float = 0
+    """Penalizes repeated tokens according to frequency."""
+
+    presence_penalty: float = 0
+    """Penalizes repeated tokens."""
+
+    n: int = 1
+    """How many completions to generate for each prompt."""
+
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """Holds any model parameters valid for `create` call not explicitly specified."""
+
+    logit_bias: Optional[Dict[str, float]] = Field(default_factory=dict)
+    """Adjust the probability of specific tokens being generated."""
+
+    gooseai_api_key: Optional[str] = None
+
+    class Config:
+        """Configuration for this pydantic config."""
+
+        extra = Extra.ignore
+
+    @root_validator(pre=True)
+    def build_extra(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Build extra kwargs from additional params that were passed in."""
+        all_required_field_names = {field.alias for field in cls.__fields__.values()}
+
+        extra = values.get("model_kwargs", {})
+        for field_name in list(values):
+            if field_name not in all_required_field_names:
+                if field_name in extra:
+                    raise ValueError(f"Found {field_name} supplied twice.")
+                logger.warning(
+                    f"""WARNING! {field_name} is not default parameter.
+                    {field_name} was transfered to model_kwargs.
+                    Please confirm that {field_name} is what you intended."""
+                )
+                extra[field_name] = values.pop(field_name)
+        values["model_kwargs"] = extra
+        return values
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        gooseai_api_key = get_from_dict_or_env(
+            values, "gooseai_api_key", "GOOSEAI_API_KEY"
+        )
+        try:
+            import openai
+
+            openai.api_key = gooseai_api_key
+            openai.api_base = "https://api.goose.ai/v1"
+            values["client"] = openai.Completion
+        except ImportError:
+            raise ValueError(
+                "Could not import openai python package. "
+                "Please install it with `pip install openai`."
+            )
+        return values
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling GooseAI API."""
+        normal_params = {
+            "temperature": self.temperature,
+            "max_tokens": self.max_tokens,
+            "top_p": self.top_p,
+            "min_tokens": self.min_tokens,
+            "frequency_penalty": self.frequency_penalty,
+            "presence_penalty": self.presence_penalty,
+            "n": self.n,
+            "logit_bias": self.logit_bias,
+        }
+        return {**normal_params, **self.model_kwargs}
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {**{"model_name": self.model_name}, **self._default_params}
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "gooseai"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        """Call the GooseAI API."""
+        params = self._default_params
+        if stop is not None:
+            if "stop" in params:
+                raise ValueError("`stop` found in both the input and default params.")
+            params["stop"] = stop
+
+        response = self.client.create(engine=self.model_name, prompt=prompt, **params)
+        text = response.choices[0].text
+        return text

langchain/llms/petals.py

@@ -0,0 +1,143 @@
+"""Wrapper around Petals API."""
+import logging
+from typing import Any, Dict, List, Mapping, Optional
+
+from pydantic import BaseModel, Extra, Field, root_validator
+
+from langchain.llms.base import LLM
+from langchain.llms.utils import enforce_stop_tokens
+from langchain.utils import get_from_dict_or_env
+
+logger = logging.getLogger(__name__)
+
+
+class Petals(LLM, BaseModel):
+    """Wrapper around Petals Bloom models.
+
+    To use, you should have the ``petals`` python package installed, and the
+    environment variable ``HUGGINGFACE_API_KEY`` set with your API key.
+
+    Any parameters that are valid to be passed to the call can be passed
+    in, even if not explicitly saved on this class.
+
+    Example:
+        .. code-block:: python
+            from langchain import petals
+            petals = Petals()
+
+    """
+
+    client: Any
+    """The client to use for the API calls."""
+
+    tokenizer: Any
+    """The tokenizer to use for the API calls."""
+
+    model_name: str = "bigscience/bloom-petals"
+    """The model to use."""
+
+    temperature: float = 0.7
+    """What sampling temperature to use"""
+
+    max_new_tokens: int = 256
+    """The maximum number of new tokens to generate in the completion."""
+
+    top_p: float = 0.9
+    """The cumulative probability for top-p sampling."""
+
+    top_k: Optional[int] = None
+    """The number of highest probability vocabulary tokens
+    to keep for top-k-filtering."""
+
+    do_sample: bool = True
+    """Whether or not to use sampling; use greedy decoding otherwise."""
+
+    max_length: Optional[int] = None
+    """The maximum length of the sequence to be generated."""
+
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """Holds any model parameters valid for `create` call
+    not explicitly specified."""
+
+    huggingface_api_key: Optional[str] = None
+
+    class Config:
+        """Configuration for this pydantic config."""
+
+        extra = Extra.forbid
+
+    @root_validator(pre=True)
+    def build_extra(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Build extra kwargs from additional params that were passed in."""
+        all_required_field_names = {field.alias for field in cls.__fields__.values()}
+
+        extra = values.get("model_kwargs", {})
+        for field_name in list(values):
+            if field_name not in all_required_field_names:
+                if field_name in extra:
+                    raise ValueError(f"Found {field_name} supplied twice.")
+                logger.warning(
+                    f"""WARNING! {field_name} is not default parameter.
+                    {field_name} was transfered to model_kwargs.
+                    Please confirm that {field_name} is what you intended."""
+                )
+                extra[field_name] = values.pop(field_name)
+        values["model_kwargs"] = extra
+        return values
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        huggingface_api_key = get_from_dict_or_env(
+            values, "huggingface_api_key", "HUGGINGFACE_API_KEY"
+        )
+        try:
+            from petals import DistributedBloomForCausalLM
+            from transformers import BloomTokenizerFast
+
+            model_name = values["model_name"]
+            values["tokenizer"] = BloomTokenizerFast.from_pretrained(model_name)
+            values["client"] = DistributedBloomForCausalLM.from_pretrained(model_name)
+            values["huggingface_api_key"] = huggingface_api_key
+
+        except ImportError:
+            raise ValueError(
+                "Could not import transformers or petals python package."
+                "Please install with `pip install -U transformers petals`."
+            )
+        return values
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling Petals API."""
+        normal_params = {
+            "temperature": self.temperature,
+            "max_new_tokens": self.max_new_tokens,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "do_sample": self.do_sample,
+            "max_length": self.max_length,
+        }
+        return {**normal_params, **self.model_kwargs}
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {**{"model_name": self.model_name}, **self._default_params}
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "petals"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        """Call the Petals API."""
+        params = self._default_params
+        inputs = self.tokenizer(prompt, return_tensors="pt")["input_ids"]
+        outputs = self.client.generate(inputs, **params)
+        text = self.tokenizer.decode(outputs[0])
+        if stop is not None:
+            # I believe this is required since the stop tokens
+            # are not enforced by the model parameters
+            text = enforce_stop_tokens(text, stop)
+        return text

tests/integration_tests/llms/test_cerebrium.py

@@ -0,0 +1,10 @@
+"""Test CerebriumAI API wrapper."""
+
+from langchain.llms.cerebriumai import CerebriumAI
+
+
+def test_cerebriumai_call() -> None:
+    """Test valid call to cerebriumai."""
+    llm = CerebriumAI(max_length=10)
+    output = llm("Say foo:")
+    assert isinstance(output, str)

tests/integration_tests/llms/test_forefrontai.py

@@ -0,0 +1,10 @@
+"""Test ForefrontAI API wrapper."""
+
+from langchain.llms.forefrontai import ForefrontAI
+
+
+def test_forefrontai_call() -> None:
+    """Test valid call to forefrontai."""
+    llm = ForefrontAI(length=10)
+    output = llm("Say foo:")
+    assert isinstance(output, str)

tests/integration_tests/llms/test_gooseai.py

@@ -0,0 +1,28 @@
+"""Test GooseAI API wrapper."""
+
+from langchain.llms.gooseai import GooseAI
+
+
+def test_gooseai_call() -> None:
+    """Test valid call to gooseai."""
+    llm = GooseAI(max_tokens=10)
+    output = llm("Say foo:")
+    assert isinstance(output, str)
+
+
+def test_gooseai_call_fairseq() -> None:
+    """Test valid call to gooseai with fairseq model."""
+    llm = GooseAI(model_name="fairseq-1-3b", max_tokens=10)
+    output = llm("Say foo:")
+    assert isinstance(output, str)
+
+
+def test_gooseai_stop_valid() -> None:
+    """Test gooseai stop logic on valid configuration."""
+    query = "write an ordered list of five items"
+    first_llm = GooseAI(stop="3", temperature=0)
+    first_output = first_llm(query)
+    second_llm = GooseAI(temperature=0)
+    second_output = second_llm(query, stop=["3"])
+    # Because it stops on new lines, shouldn't return anything
+    assert first_output == second_output

tests/integration_tests/llms/test_petals.py

@@ -0,0 +1,10 @@
+"""Test Petals API wrapper."""
+
+from langchain.llms.petals import Petals
+
+
+def test_gooseai_call() -> None:
+    """Test valid call to gooseai."""
+    llm = Petals(max_new_tokens=10)
+    output = llm("Say foo:")
+    assert isinstance(output, str)