ExternalVendorCode/ChainForge
1
0
Fork 0
mirror of https://github.com/ianarawjo/ChainForge.git synced 2025-03-14 08:16:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update INSTALL_GUIDE.md

Browse Source
This commit is contained in:
ianarawjo 2023-07-07 11:11:38 -04:00 committed by GitHub
parent 5691f0d65b
commit bfc0f2fafa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 39 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
INSTALL_GUIDE.md
View File

@ -1,8 +1,15 @@
# Installation Guide
There are two ways to use ChainForge:
- Via the web version, hosted at https://chainforge.ai/play/. This requires no installation, but is slightly more limited than the full version.
- By installing on your local machine. This has the benefit of being able to load API keys from environment variables, run Python evaluator nodes, and query Dalai-hosted models.
This document concerns the latter (local installation).
## Step 1. Install on your machine
The simplest and safest way to install the latest public build of ChainForge is to:
1. Create a new directory and `cd` into it
2. (Optional, but recommended!) Create a virtual environment. On Mac, you can do
2. _(Optional, but recommended!)_ Create a virtual environment. On Mac, you can do
```bash
python -m venv venv
source venv/bin/activate
@ -11,56 +18,53 @@ The simplest and safest way to install the latest public build of ChainForge is
```bash
pip install chainforge
```
4. (If you wish to use non-OpenAI models): Make sure you have installed the relevant packages. For more info, see below. You can also come back to do this later.
4. Run:
```bash
chainforge serve
```
5. Open [localhost:8000](http://localhost:8000/) on a recent version of Google Chrome.
5. Open [localhost:8000](http://localhost:8000/) on a recent version of Google Chrome or Mozilla Firefox.
> **Note**
> ChainForge alpha is tested on Google Chrome. It currently does not work in earlier versions of Safari. We recommend you open it in Chrome.
> ChainForge beta version currently does not support other browsers, but if you want support, please open an Issue or make a Pull Request. The main barrier at the moment is that CSS formatting is slightly different for Safari, Edge etc.; to fix this, we'd need to correct said formatting problems.
## Set API keys / install model APIs
## Step 2. Get and set API keys for certain model providers
Though you can run Chainforge, you can't do anything with it without the ability to call an LLM.
Currently we support OpenAI models GPT3.5 and GPT4, Anthropic model Claudev1, Google PaLM model `text-bison-001`, and (locally run) [Dalai](https://github.com/cocktailpeanut/dalai)-served Alpaca.7b at port 4000.
Though you can run Chainforge, you can't do anything with it without the ability to call an LLM. Currently we support model providers:
- OpenAI models GPT3.5 and GPT4, including all variants and function calls
- HuggingFace models (via the HuggingFace Inference and Inference Endpoints API)
- Anthropic models
- Google PaLM2 chat and text bison models
- Azure OpenAI Endpoints
- (Locally run) Alpaca and Llama models [Dalai](https://github.com/cocktailpeanut/dalai)-served Alpaca.7b at port 4000.
- To query models like Alpaca and Llama run on your local machine via Dalai, [install `dalai`](https://github.com/cocktailpeanut/dalai) and follow the instructions to download `alpaca.7b`. When everything is setup, run `npx dalai serve 4000`.
To use a specific model, you need to do two things:
1. Install the relevant package to your Python environment _(for all non-OpenAI models)_
2. Set the relevant API key _(for all non-Dalai models)_
### How to Set API keys for specific model providers (non-Dalai models)
To use a specific model provider, you need to do two things:
1. **Get an API key.** HuggingFace API keys [are free](https://huggingface.co/docs/api-inference/quicktour). OpenAI API keys are easy to access, and you can even [get one for free during a trial period](https://openaimaster.com/how-to-get-openai-api-key-for-free/). For other providers, see their pages and sign up for access.
3. **Set the relevant API key in ChainForge.** You can input your API keys manually via the Settings button in the top-right corner. However, this can become tedious fast. If you'd prefer to not be bothered every time you load ChainForge, you can set them as environment keys. To do so, follow [this guide](https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety), section 3, "Use Environment Variables in place of your API key." When following the instructions, **swap OPENAI_API_KEY for the alias of your specific model provider, listed below:**
- OpenAI: `OPENAI_API_KEY`
- HuggingFace: `HUGGINGFACE_API_KEY`
- Anthropic: `ANTHROPIC_API_KEY`
- Google PaLM2: `PALM_API_KEY`
- Azure OpenAI: Set two keys, `AZURE_OPENAI_KEY` and `AZURE_OPENAI_ENDPOINT`. Note that the endpoint should look like a base URL. For examples on what these keys look like, see the [Azure OpenAI documentation](https://learn.microsoft.com/en-us/azure/cognitive-services/openai/chatgpt-quickstart?tabs=command-line&pivots=programming-language-javascript).
- When you are done setting the API key(s), **reopen your terminal**. _(This is because the terminal loads the environment variables when it is first opened, so it needs to be refreshed before running `chainforge serve`.)_
### 1. Install packages (Anthropic, Google PaLM, and Dalai-hosted models)
For OpenAI models, move to Step 2. To use Anthropic and Google PaLM models, you need to install the relevant Python package in your Python environment before you can run those models:
- For [Anthropic](https://github.com/anthropics/anthropic-sdk-python), do `pip install anthropic`.
- For [Google PaLM](https://github.com/google/generative-ai-python), do `pip install google-generativeai`. (Note that PaLM officially supports Python 3.9+, but there's a minor type error that's easily fixed to make it work in Python 3.8.8.)
- For Dalai, [install `dalai`](https://github.com/cocktailpeanut/dalai) and follow the instructions to download `alpaca.7b`. When everything is setup, run:
```bash
npx dalai serve 4000
```
> **Note**
> We put these installs separate from package dependencies as some packages may not work or install on Python 3.8.
### 2. Set API keys (OpenAI, Anthropic, Google PaLM)
If you're just messing around, we recommend you input the API keys manually via the Settings button in the top-right corner. If you'd prefer to not be bothered every time you load ChainForge, you can set them as environment keys:
- For OpenAI models, you can set an environment variable with your OpenAI key:
https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety . For Mac, for instance, follow:
For instance, to set an OpenAI API key as an environment variable on Macs, do this from the terminal:
```bash
echo "export OPENAI_API_KEY='yourkey'" >> ~/.zshrc
source ~/.zshrc
echo $OPENAI_API_KEY
```
Then, **reopen your terminal**.
- To set Anthropic's API key on Mac, do the same as above but with `ANTHROPIC_API_KEY` replaced for `OpenAI_API_KEY`.
- To set Google PaLM's API key on Mac, do the same as above but with `PALM_API_KEY` replaced for `PALM_API_KEY`.
Then, make sure to **reopen your terminal**.
## Step 3. Check out Examples!
Click Example Flows to get a sense of what ChainForge is capable of. A popular choice is ground truth evaluations, which use Tabular Data nodes.
---------------------------------
# For developers
Below is a guide to running the alpha version of ChainForge directly, for people who want to modify, develop or extend it.
Below is a guide for running the beta version of ChainForge directly from source, for people who want to modify, develop or extend it.
Note that these steps may change in the future.
### Install requirements
@ -78,6 +82,8 @@ To install Node.js requirements, first make sure you have Node.js installed. The
npm install
```
> You might run into dependency conflicts. You can re-run with `--force` to force continued installation.
### Serving ChainForge manually
To serve ChainForge manually, you have two options:
@ -112,10 +118,7 @@ Regardless of which option you chose, `cd` into the root ChainForge directory an
python -m chainforge.app serve
```
> **Note**
> You can add the `--dummy-responses` flag in case you're worried about making calls to OpenAI. This will spoof all LLM responses as random strings, and is great for testing the interface without accidentally spending $$.
This script spins up two servers, the main one on port 8000 and a SocketIO server on port 8001 (used for streaming progress updates).
This script spins up a Flask server on port 8000. Note that most of the app logic is fully in the browser, but some calls (like loading API keys as environment variables, or querying Dalai-hosted models or Anthropic API) still go through the Flask server.
If you built the React app statically, go to `localhost:8000` in a web browser to view the app (ideally in Google Chrome).
If you served the React app with hot reloading with `npm run start`, go to the server address you ran it on (usually `localhost:3000`).