feat: claude integration (#552)

* feat: bare bones implementation of claude client (WIP)

* feat: client implementation of Claude (WIP)

* fix: add claude to store

* feat: bare bones implementation of claude client (WIP)

* switch eventsource

* Try new method of calling claude with anthropic sdk

* (WIP) Finish initial claude client implementation and api

* debugging update

* fix(ClaudeClient.js): fix prompt prefixes for HUMAN_PROMPT and AI_PROMPT
fix(ClaudeClient.js): refactor buildMessages logic for correct handling of messages
refactor(ClaudeClient.js): refactor buildPrompt method to buildMessages for use in BaseClient sendMessage method
refactor(ClaudeClient.js): refactor getCompletion method to sendCompletion for use in BaseClient sendMessage method
refactor(ClaudeClient.js): omit getMessageMapMethod method for future refactoring
refactor(ClaudeClient.js): remove unused sendMessage method to prefer BaseClient message
fix(askClaude.js): error in getIds method was causing a frontend crash, userMessage was not defined
fix(askClaude.js): import abortMessage function from utils module
feat(askClaude.js): add /abort route to handle message abort requests
feat(askClaude.js): create abortControllers map to store abort controllers
feat(askClaude.js): implement abortAsk function to handle message abort logic
feat(askClaude.js): add onStart callback to handle message start logic
feat(HoverButtons.jsx): add 'claude' as a supported endpoint for branching

* fix(ClaudeClient.js): update defaultPrefix and promptPrefix messages

includes 'Remember your instructions' as Claude is trained to recognize labels preceding colons as participants of a conversation

* Change name from claude to anthropic

* add settings to handleSubmit and models to endpoints

* Implement Claude settings

* use svg for anthropic icon

* Implement abort

* Implement reverse proxy

* remove png icons

* replace web browser plugin

* remove default prefix

* fix styling of claude icon

* fix console error from svg properties

* remove single quote requirement from eslintrc

* fix(AnthropicClient.js): fix labels for HUMAN_PROMPT and AI_PROMPT
feat(AnthropicClient.js): add support for custom userLabel and modelLabel options
feat(AnthropicClient.js): add user_id metadata to requestOptions in getCompletion method
feat(anthropic, AnthropicClient.js): add debug logging

* refactor(AnthropicClient.js): change promptSuffix variable declaration from let to const

* fix(EndpointOptionsDialog.jsx): remove unnecessary code that changes endpointName from 'anthropic' to 'Claude'
fix(utils/index.jsx): fix alternateName value for 'anthropic' from 'Claude' to 'Anthropic'

* fix(AnthropicIcon): fix sizing/rendering/name of anthropic icon

* fix(AnthropicClient.js): change maxContextTokens default value to 99999
fix(AnthropicClient.js): change maxResponseTokens default value to 1500
fix(AnthropicClient.js): remove unnecessary code for setting maxContextTokens and maxResponseTokens based on modelOptions
fix(AnthropicClient.js): change max_tokens_to_sample default value to 1500
fix(anthropic.js): pass endpointOption.token to AnthropicClient constructor

* Update .env.example

* fix(AnthropicClient.js): remove exceeding message when it puts us over the token limit
fix(AnthropicClient.js): handle case when the first message exceeds the token limit
fix(AnthropicClient.js): throw error when prompt is too long
fix(AnthropicClient.js): adjust max tokens calculation to use maxOutputTokens
fix(anthropic.js): remove console.log statement in ask route

* feat(server/index): increase incoming json payload allowed size

---------

Co-authored-by: Danny Avila <messagedaniel@protonmail.com>

api/app/clients/AnthropicClient.js

@@ -0,0 +1,319 @@
+const Keyv = require('keyv');
+// const { Agent, ProxyAgent } = require('undici');
+const BaseClient = require('./BaseClient');
+const {
+  encoding_for_model: encodingForModel,
+  get_encoding: getEncoding
+} = require('@dqbd/tiktoken');
+const Anthropic = require('@anthropic-ai/sdk');
+
+const HUMAN_PROMPT = '\n\nHuman:';
+const AI_PROMPT = '\n\nAssistant:';
+
+const tokenizersCache = {};
+
+class AnthropicClient extends BaseClient {
+
+  constructor(apiKey, options = {}, cacheOptions = {}) {
+    super(apiKey, options, cacheOptions)
+    cacheOptions.namespace = cacheOptions.namespace || 'anthropic';
+    this.conversationsCache = new Keyv(cacheOptions);
+    this.apiKey = apiKey || process.env.ANTHROPIC_API_KEY;
+    this.sender = 'Anthropic';
+    this.userLabel = HUMAN_PROMPT;
+    this.assistantLabel = AI_PROMPT;
+    this.setOptions(options);
+  }
+
+  setOptions(options) {
+    if (this.options && !this.options.replaceOptions) {
+      // nested options aren't spread properly, so we need to do this manually
+      this.options.modelOptions = {
+        ...this.options.modelOptions,
+        ...options.modelOptions
+      };
+      delete options.modelOptions;
+      // now we can merge options
+      this.options = {
+        ...this.options,
+        ...options,
+      };
+    } else {
+      this.options = options;
+    }
+
+    const modelOptions = this.options.modelOptions || {};
+    this.modelOptions = {
+      ...modelOptions,
+      // set some good defaults (check for undefined in some cases because they may be 0)
+      model: modelOptions.model || 'claude-1',
+      temperature: typeof modelOptions.temperature === 'undefined' ? 0.7 : modelOptions.temperature, // 0 - 1, 0.7 is recommended
+      topP: typeof modelOptions.topP === 'undefined' ? 0.7 : modelOptions.topP, // 0 - 1, default: 0.7
+      topK: typeof modelOptions.topK === 'undefined' ? 40 : modelOptions.topK, // 1-40, default: 40
+      stop: modelOptions.stop // no stop method for now
+    };
+
+    this.maxContextTokens = this.options.maxContextTokens || 99999;
+    this.maxResponseTokens = this.modelOptions.maxOutputTokens || 1500;
+    this.maxPromptTokens =
+      this.options.maxPromptTokens || this.maxContextTokens - this.maxResponseTokens;
+
+    if (this.maxPromptTokens + this.maxResponseTokens > this.maxContextTokens) {
+      throw new Error(
+        `maxPromptTokens + maxOutputTokens (${this.maxPromptTokens} + ${this.maxResponseTokens} = ${
+          this.maxPromptTokens + this.maxResponseTokens
+        }) must be less than or equal to maxContextTokens (${this.maxContextTokens})`
+      );
+    }
+
+    this.startToken = '||>';
+    this.endToken = '';
+    this.gptEncoder = this.constructor.getTokenizer('cl100k_base');
+
+    if (!this.modelOptions.stop) {
+      const stopTokens = [this.startToken];
+      if (this.endToken && this.endToken !== this.startToken) {
+        stopTokens.push(this.endToken);
+      }
+      stopTokens.push(`${this.userLabel}`);
+      stopTokens.push('<|diff_marker|>');
+
+      this.modelOptions.stop = stopTokens;
+    }
+
+    return this;
+  }
+
+  getClient() {
+    if(this.options.reverseProxyUrl) {
+      return new Anthropic({
+        apiKey: this.apiKey,
+        baseURL: this.options.reverseProxyUrl
+      });
+    }
+    else {
+      return new Anthropic({
+        apiKey: this.apiKey,
+      });
+    }
+  };
+
+  async buildMessages(messages, parentMessageId) {
+    const orderedMessages = this.constructor.getMessagesForConversation(messages, parentMessageId);
+    if (this.options.debug) {
+      console.debug('AnthropicClient: orderedMessages', orderedMessages, parentMessageId);
+    }
+
+    const formattedMessages = orderedMessages.map((message) => ({
+      author: message.isCreatedByUser ? this.userLabel : this.assistantLabel,
+      content: message?.content ?? message.text
+    }));
+
+    let identityPrefix = '';
+    if (this.options.userLabel) {
+      identityPrefix = `\nHuman's name: ${this.options.userLabel}`;
+    }
+
+    if (this.options.modelLabel) {
+      identityPrefix = `${identityPrefix}\nYou are ${this.options.modelLabel}`;
+    }
+
+    let promptPrefix = (this.options.promptPrefix || '').trim();
+    if (promptPrefix) {
+      // If the prompt prefix doesn't end with the end token, add it.
+      if (!promptPrefix.endsWith(`${this.endToken}`)) {
+        promptPrefix = `${promptPrefix.trim()}${this.endToken}\n\n`;
+      }
+      promptPrefix = `\nContext:\n${promptPrefix}`;
+    }
+
+    if (identityPrefix) {
+      promptPrefix = `${identityPrefix}${promptPrefix}`;
+    }
+
+    const promptSuffix = `${promptPrefix}${this.assistantLabel}\n`; // Prompt AI to respond.
+    let currentTokenCount = this.getTokenCount(promptSuffix);
+
+    let promptBody = '';
+    const maxTokenCount = this.maxPromptTokens;
+
+    const context = [];
+
+    // Iterate backwards through the messages, adding them to the prompt until we reach the max token count.
+    // Do this within a recursive async function so that it doesn't block the event loop for too long.
+    // Also, remove the next message when the message that puts us over the token limit is created by the user.
+    // Otherwise, remove only the exceeding message. This is due to Anthropic's strict payload rule to start with "Human:".
+    const nextMessage = {
+      remove: false,
+      tokenCount: 0,
+      messageString: '',
+    };
+
+    const buildPromptBody = async () => {
+      if (currentTokenCount < maxTokenCount && formattedMessages.length > 0) {
+        const message = formattedMessages.pop();
+        const isCreatedByUser = message.author === this.userLabel;
+        const messageString = `${message.author}\n${message.content}${this.endToken}\n`;
+        let newPromptBody = `${messageString}${promptBody}`;
+
+        context.unshift(message);
+
+        const tokenCountForMessage = this.getTokenCount(messageString);
+        const newTokenCount = currentTokenCount + tokenCountForMessage;
+
+        if (!isCreatedByUser) {
+          nextMessage.messageString = messageString;
+          nextMessage.tokenCount = tokenCountForMessage;
+        }
+
+        if (newTokenCount > maxTokenCount) {
+          if (!promptBody) {
+            // This is the first message, so we can't add it. Just throw an error.
+            throw new Error(`Prompt is too long. Max token count is ${maxTokenCount}, but prompt is ${newTokenCount} tokens long.`);
+          }
+
+          // Otherwise, ths message would put us over the token limit, so don't add it.
+          // if created by user, remove next message, otherwise remove only this message
+          if (isCreatedByUser) {
+            nextMessage.remove = true;
+          }
+
+          return false;
+        }
+        promptBody = newPromptBody;
+        currentTokenCount = newTokenCount;
+        // wait for next tick to avoid blocking the event loop
+        await new Promise(resolve => setImmediate(resolve));
+        return buildPromptBody();
+      }
+      return true;
+    };
+
+    await buildPromptBody();
+
+    if (nextMessage.remove) {
+      promptBody = promptBody.replace(nextMessage.messageString, '');
+      currentTokenCount -= nextMessage.tokenCount;
+      context.shift();
+    }
+
+    const prompt = `${promptBody}${promptSuffix}`;
+    // Add 2 tokens for metadata after all messages have been counted.
+    currentTokenCount += 2;
+
+    // Use up to `this.maxContextTokens` tokens (prompt + response), but try to leave `this.maxTokens` tokens for the response.
+    this.modelOptions.maxOutputTokens = Math.min(this.maxContextTokens - currentTokenCount, this.maxResponseTokens);
+
+    return { prompt, context };
+  }
+
+  getCompletion() {
+    console.log('AnthropicClient doesn\'t use getCompletion (all handled in sendCompletion)');
+  }
+
+  // TODO: implement abortController usage
+  async sendCompletion(payload, { onProgress, abortController }) {
+    if (!abortController) {
+      abortController = new AbortController();
+    }
+
+    const { signal } = abortController;
+
+    const modelOptions = { ...this.modelOptions };
+    if (typeof onProgress === 'function') {
+      modelOptions.stream = true;
+    }
+
+    const { debug } = this.options;
+    if (debug) {
+      console.debug();
+      console.debug(modelOptions);
+      console.debug();
+    }
+
+    const client = this.getClient();
+    const metadata = {
+      user_id: this.user,
+    };
+
+    let text = '';
+    const requestOptions = {
+      prompt: payload,
+      model: this.modelOptions.model,
+      stream: this.modelOptions.stream || true,
+      max_tokens_to_sample: this.modelOptions.maxOutputTokens || 1500,
+      metadata,
+      ...modelOptions
+    };
+    if (this.options.debug) {
+      console.log('AnthropicClient: requestOptions');
+      console.dir(requestOptions, { depth: null });
+    }
+    const response = await client.completions.create(requestOptions);
+
+    signal.addEventListener('abort', () => {
+      if (this.options.debug) {
+        console.log('AnthropicClient: message aborted!');
+      }
+      response.controller.abort();
+    });
+
+    for await (const completion of response) {
+      if (this.options.debug) {
+        // Uncomment to debug message stream
+        // console.debug(completion);
+      }
+      text += completion.completion;
+      onProgress(completion.completion);
+    }
+
+    signal.removeEventListener('abort', () => {
+      if (this.options.debug) {
+        console.log('AnthropicClient: message aborted!');
+      }
+      response.controller.abort();
+    });
+
+    return text.trim();
+  }
+
+  // I commented this out because I will need to refactor this for the BaseClient/all clients
+  // getMessageMapMethod() {
+  //   return ((message) => ({
+  //     author: message.isCreatedByUser ? this.userLabel : this.assistantLabel,
+  //     content: message?.content ?? message.text
+  //   })).bind(this);
+  // }
+
+  getSaveOptions() {
+    return {
+      ...this.modelOptions
+    };
+  }
+
+  getBuildMessagesOptions() {
+    if (this.options.debug) {
+      console.log('AnthropicClient doesn\'t use getBuildMessagesOptions');
+    }
+  }
+
+  static getTokenizer(encoding, isModelName = false, extendSpecialTokens = {}) {
+    if (tokenizersCache[encoding]) {
+      return tokenizersCache[encoding];
+    }
+    let tokenizer;
+    if (isModelName) {
+      tokenizer = encodingForModel(encoding, extendSpecialTokens);
+    } else {
+      tokenizer = getEncoding(encoding, extendSpecialTokens);
+    }
+    tokenizersCache[encoding] = tokenizer;
+    return tokenizer;
+  }
+
+  getTokenCount(text) {
+    return this.gptEncoder.encode(text, 'all').length;
+  }
+}
+
+module.exports = AnthropicClient;

api/app/clients/BaseClient.js

@@ -370,7 +370,6 @@ class BaseClient {
   }
 
   async sendMessage(message, opts = {}) {
-    console.log('BaseClient: sendMessage', message, opts);
     const {
       user,
       conversationId,
@@ -379,6 +378,7 @@ class BaseClient {
       userMessage,
     } = await this.handleStartMethods(message, opts);
 
+    this.user = user;
     // It's not necessary to push to currentMessages
     // depending on subclass implementation of handling messages
     this.currentMessages.push(userMessage);

api/app/clients/index.js

@@ -3,6 +3,7 @@ const OpenAIClient = require('./OpenAIClient');
 const PluginsClient = require('./PluginsClient');
 const GoogleClient = require('./GoogleClient');
 const TextStream = require('./TextStream');
+const AnthropicClient = require('./AnthropicClient');
 const toolUtils = require('./tools/util');
 
 module.exports = {
@@ -11,5 +12,6 @@ module.exports = {
   PluginsClient,
   GoogleClient,
   TextStream,
+  AnthropicClient,
   ...toolUtils
 };

api/app/clients/tools/manifest.json

@@ -34,7 +34,7 @@
     "name": "Browser",
     "pluginKey": "browser",
     "description": "Scrape and summarize webpage data",
-    "icon": "/assets/web-browser.png",
+    "icon": "/assets/web-browser.svg",
     "authConfig": [
       {
         "authField": "OPENAI_API_KEY",

api/models/schema/defaults.js

@@ -1,5 +1,5 @@
 const conversationPreset = {
-  // endpoint: [azureOpenAI, openAI, bingAI, chatGPTBrowser]
+  // endpoint: [azureOpenAI, openAI, bingAI, anthropic, chatGPTBrowser]
   endpoint: {
     type: String,
     default: null,
@@ -151,7 +151,7 @@ const agentOptions = {
     default: null
   }
 };
-  
+
 module.exports = {
   conversationPreset,
   agentOptions

api/package.json

@@ -20,7 +20,9 @@
   },
   "homepage": "https://github.com/danny-avila/LibreChat#readme",
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.5.0",
     "@dqbd/tiktoken": "^1.0.2",
+    "@fortaine/fetch-event-source": "^3.0.6",
     "@keyv/mongo": "^2.1.8",
     "@waylaidwanderer/chatgpt-api": "^1.37.0",
     "axios": "^1.3.4",

api/server/index.js

@@ -24,8 +24,8 @@ config.validate(); // Validate the config
 
   const app = express();
   app.use(errorController);
-  app.use(express.json());
-  app.use(express.urlencoded({ extended: true }));
+  app.use(express.json({ limit: '3mb' }));
+  app.use(express.urlencoded({ extended: true, limit: '3mb' }));
   app.use(express.static(path.join(projectPath, 'dist')));
   app.use(express.static(path.join(projectPath, 'public')));
 

api/server/routes/ask/anthropic.js

@@ -0,0 +1,186 @@
+const express = require('express');
+const router = express.Router();
+const crypto = require('crypto');
+const { titleConvo, AnthropicClient } = require('../../../app');
+const requireJwtAuth = require('../../../middleware/requireJwtAuth');
+const { abortMessage } = require('../../../utils');
+const { saveMessage, getConvoTitle, saveConvo, getConvo } = require('../../../models');
+const { handleError, sendMessage, createOnProgress } = require('./handlers');
+
+const abortControllers = new Map();
+
+router.post('/abort', requireJwtAuth, async (req, res) => {
+  return await abortMessage(req, res, abortControllers);
+});
+
+router.post('/', requireJwtAuth, async (req, res) => {
+  const { endpoint, text, parentMessageId, conversationId: oldConversationId } = req.body;
+  if (text.length === 0) return handleError(res, { text: 'Prompt empty or too short' });
+  if (endpoint !== 'anthropic') return handleError(res, { text: 'Illegal request' });
+
+  const endpointOption = {
+    promptPrefix: req.body?.promptPrefix ?? null,
+    modelLabel: req.body?.modelLabel ?? null,
+    token: req.body?.token ?? null,
+    modelOptions: {
+      model: req.body?.model ?? 'claude-1',
+      temperature: req.body?.temperature ?? 0.7,
+      maxOutputTokens: req.body?.maxOutputTokens ?? 1024,
+      topP: req.body?.topP ?? 0.7,
+      topK: req.body?.topK ?? 40
+    }
+  };
+
+  const conversationId = oldConversationId || crypto.randomUUID();
+
+  return await ask({
+    text,
+    endpointOption,
+    conversationId,
+    parentMessageId,
+    req,
+    res
+  });
+});
+
+const ask = async ({ text, endpointOption, parentMessageId = null, conversationId, req, res }) => {
+  res.writeHead(200, {
+    Connection: 'keep-alive',
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Access-Control-Allow-Origin': '*',
+    'X-Accel-Buffering': 'no'
+  });
+
+  let userMessage;
+  let userMessageId;
+  let responseMessageId;
+  let lastSavedTimestamp = 0;
+  const { overrideParentMessageId = null } = req.body;
+
+  try {
+    const getIds = (data) => {
+      userMessage = data.userMessage;
+      userMessageId = data.userMessage.messageId;
+      responseMessageId = data.responseMessageId;
+      if (!conversationId) {
+        conversationId = data.conversationId;
+      }
+    };
+
+    const { onProgress: progressCallback, getPartialText } = createOnProgress({
+      onProgress: ({ text: partialText }) => {
+        const currentTimestamp = Date.now();
+        if (currentTimestamp - lastSavedTimestamp > 500) {
+          lastSavedTimestamp = currentTimestamp;
+          saveMessage({
+            messageId: responseMessageId,
+            sender: 'Anthropic',
+            conversationId,
+            parentMessageId: overrideParentMessageId || userMessageId,
+            text: partialText,
+            unfinished: true,
+            cancelled: false,
+            error: false
+          });
+        }
+      }
+    });
+
+    const abortController = new AbortController();
+    abortController.abortAsk = async function () {
+      this.abort();
+
+      const responseMessage = {
+        messageId: responseMessageId,
+        sender: 'Anthropic',
+        conversationId,
+        parentMessageId: overrideParentMessageId || userMessageId,
+        text: getPartialText(),
+        model: endpointOption.modelOptions.model,
+        unfinished: false,
+        cancelled: true,
+        error: false,
+      };
+
+      saveMessage(responseMessage);
+
+      return {
+        title: await getConvoTitle(req.user.id, conversationId),
+        final: true,
+        conversation: await getConvo(req.user.id, conversationId),
+        requestMessage: userMessage,
+        responseMessage: responseMessage
+      };
+    };
+
+    const onStart = (userMessage) => {
+      sendMessage(res, { message: userMessage, created: true });
+      abortControllers.set(userMessage.conversationId, { abortController, ...endpointOption });
+    }
+
+    const client = new AnthropicClient(endpointOption.token);
+
+    let response = await client.sendMessage(text, {
+      getIds,
+      debug: false,
+      user: req.user.id,
+      conversationId,
+      parentMessageId,
+      overrideParentMessageId,
+      ...endpointOption,
+      onProgress: progressCallback.call(null, {
+        res,
+        text,
+        parentMessageId: overrideParentMessageId || userMessageId
+      }),
+      onStart,
+      abortController
+    });
+
+    if (overrideParentMessageId) {
+      response.parentMessageId = overrideParentMessageId;
+    }
+
+    await saveConvo(req.user.id, {
+      ...endpointOption,
+      ...endpointOption.modelOptions,
+      conversationId,
+      endpoint: 'anthropic'
+    });
+
+    await saveMessage(response);
+    sendMessage(res, {
+      title: await getConvoTitle(req.user.id, conversationId),
+      final: true,
+      conversation: await getConvo(req.user.id, conversationId),
+      requestMessage: userMessage,
+      responseMessage: response
+    });
+    res.end();
+
+    if (parentMessageId == '00000000-0000-0000-0000-000000000000') {
+      const title = await titleConvo({ text, response });
+      await saveConvo(req.user.id, {
+        conversationId,
+        title
+      });
+    }
+  } catch (error) {
+    console.error(error);
+    const errorMessage = {
+      messageId: responseMessageId,
+      sender: 'Anthropic',
+      conversationId,
+      parentMessageId,
+      unfinished: false,
+      cancelled: false,
+      error: true,
+      text: error.message
+    };
+    await saveMessage(errorMessage);
+    handleError(res, errorMessage);
+  }
+};
+
+module.exports = router;

api/server/routes/ask/index.js

@@ -7,6 +7,7 @@ const google = require('./google');
 const askBingAI = require('./askBingAI');
 const gptPlugins = require('./gptPlugins');
 const askChatGPTBrowser = require('./askChatGPTBrowser');
+const anthropic = require('./anthropic');
 
 // router.use('/azureOpenAI', askAzureOpenAI);
 router.use(['/azureOpenAI', '/openAI'], openAI);
@@ -14,5 +15,6 @@ router.use('/google', google);
 router.use('/bingAI', askBingAI);
 router.use('/chatGPTBrowser', askChatGPTBrowser);
 router.use('/gptPlugins', gptPlugins);
+router.use('/anthropic', anthropic);
 
 module.exports = router;

api/server/routes/endpoints.js

@@ -16,6 +16,12 @@ const getChatGPTBrowserModels = () => {
 
   return models;
 };
+const getAnthropicModels = () => {
+  let models = ['claude-1', 'claude-1-100k', 'claude-instant-1', 'claude-instant-1-100k', 'claude-2'];
+  if (process.env.ANTHROPIC_MODELS) models = String(process.env.ANTHROPIC_MODELS).split(',');
+
+  return models;
+};
 
 const getPluginModels = () => {
   let models = ['gpt-4', 'gpt-4-0613', 'gpt-3.5-turbo', 'gpt-3.5-turbo-16k', 'gpt-3.5-turbo-0613', 'gpt-3.5-turbo-0301'];
@@ -55,7 +61,7 @@ router.get('/', async function (req, res) {
     ? { availableModels: getOpenAIModels(), userProvide: openAIApiKey === 'user_provided' }
     : false;
   const azureOpenAI = azureOpenAIApiKey
-    ? { availableModels: getOpenAIModels({ azure: true}), userProvide: azureOpenAIApiKey === 'user_provided' }
+    ? { availableModels: getOpenAIModels({ azure: true }), userProvide: azureOpenAIApiKey === 'user_provided' }
     : false;
   const gptPlugins = openAIApiKey || azureOpenAIApiKey
     ? { availableModels: getPluginModels(), availableTools, availableAgents: ['classic', 'functions'], userProvide: userProvidedOpenAI }
@@ -69,8 +75,14 @@ router.get('/', async function (req, res) {
       availableModels: getChatGPTBrowserModels()
     }
     : false;
+  const anthropic = process.env.ANTHROPIC_API_KEY
+    ? {
+      userProvide: process.env.ANTHROPIC_API_KEY == 'user_provided',
+      availableModels: getAnthropicModels()
+    }
+    : false;
 
-  res.send(JSON.stringify({ azureOpenAI, openAI, google, bingAI, chatGPTBrowser, gptPlugins }));
+  res.send(JSON.stringify({ azureOpenAI, openAI, google, bingAI, chatGPTBrowser, gptPlugins, anthropic }));
 });
 
 module.exports = { router, getOpenAIModels, getChatGPTBrowserModels };