Skip to content

Setting up an LLMđź”—

To be able to use a third-party LLM as an AI assistant, provide access to at least one LLM from the list below.

Tip

You can also easily use LLMs available via GitHub Copilot.

Anthropicđź”—

To enable Anthropic’s AI models, create an API key in your Anthropic’s API account and enter it under Settings > AI Assistants > Anthropic.

Important

When using this preference, the API key will be stored in clear text. Use the following environment variable instead to set the key securely: ANTHROPIC_API_KEY

Configure available models in the settings under Settings > AI Assistants > Anthropic Models. Default supported models include choices like claude-3-5-sonnet-latest.

Thinking Modeđź”—

HDevelopEVO provides support for Claude’s “Thinking Mode” when using Sonnet-3.7. By setting a custom request parameter—either globally or for a specific chat session—you can instruct the model to “think more.” This is particularly useful for more difficult questions and shows its strengths when using agents like the Architect or Coder on complex coding tasks.

To enable Thinking Mode, you need to add the following custom request setting: 

"thinking": { "type": "enabled", "budget_tokens": 8192 }
You can configure this setting either:
  • Globally through the model settings
  • For a specific chat session by using the chat-specific settings icon in the chat window

Preview restriction

Keep in mind that the UI for chat-specific settings is currently experimental.

Azuređź”—

All models hosted on Azure that are compatible with the OpenAI API are accessible via the provider for OpenAI-compatible models via vLLM. Note that some models hosted on Azure may require different settings for the system message.

DeepSeekđź”—

Since DeepSeek conveniently provides an OpenAI-compatible API, integrating it into HDevelopEVO is straightforward. Alternatively, you can also host it yourself, for example via Ollama.

This is the configuration you can use to add DeepSeek Chat on the DeepSeek Platform as a custom OpenAI model to your settings.json file:

DeepSeek configuration 
"ai-features.openAiCustom.customOpenAiModels": [
       {
           "model": "deepseek-chat",
           "url": "https://api.deepseek.com",
           "id": "deepseek-chat",
           "apiKey": "<yourApiKey>",
           "enableStreaming": true,
           "supportsDeveloperMessage": false,
           "developerMessageSettings": "system"
       }
   ],
   "ai-features.agentSettings": {
       "Code Completion": {
           "languageModelRequirements": [
               {
                   "purpose": "code-completion",
                   "identifier": "deepseek-chat"
               }
           ]
       },
       "Architect": {
           "languageModelRequirements": [
               {
                   "purpose": "chat",
                   "identifier": "deepseek-chat"
               }
           ]
       },
       "Orchestrator": {
           "languageModelRequirements": [
               {
                   "purpose": "agent-selection",
                   "identifier": "deepseek-chat"
               }
           ]
       },
       "Universal": {
           "languageModelRequirements": [
               {
                   "purpose": "chat",
                   "identifier": "deepseek-chat"
               }
           ]
       },
       "Command": {
           "languageModelRequirements": [
               {
                   "purpose": "command",
                   "identifier": "deepseek-chat"
               }
           ]
       },
       "Coder": {
           "languageModelRequirements": [
               {
                   "purpose": "chat",
                   "identifier": "deepseek-chat"
               }
           ]
       }
   }

Set "supportsDeveloperMessage": false, as DeepSeek’s API does not yet support the newer “developer” message, which replaced the “system” role in most OpenAI models.

Alternatively, you can also adapt the agents settings in your AI Configuration. To get there, go to View > AI Configuration.

Google AIđź”—

To enable Google AI models, create an API key in your Google AI account and enter it in the Settings > AI Assistants > Google AI.

Important

When using this preference, the API key will be stored in clear text. Use the following environment variable instead to set the key securely: GOOGLE_API_KEY

Configure available models in the settings under AI Assistants > Google AI Models.

Hugging Faceđź”—

Many hosting options and models on Hugging Face support using an OpenAI compatible API. In this case, we recommend using the HDevelopEVO provider for OpenAI compatible models. The Hugging face provider only supports text generation at the moment for models not compatible with the OpenAI API

To enable Hugging Face as an AI provider, you need to create an API key in your Hugging Face account and enter it in the Settings > AI Assistants > Hugging Face.

Important

When using this preference, the API key will be stored in clear text. Use the following environment variable instead to set the key securely: HUGGINGFACE_API_KEY

Note

Hugging Face offers both paid and free-tier options (including “serverless”), and usage limits vary. Monitor your usage carefully to avoid unexpected costs, especially when using high-demand models.

Add or remove the desired Hugging Face models from the list of available models.

LlamaFile modelsđź”—

To configure a LlamaFile LLM in HDevelopEVO, add the necessary settings to your configuration:

LlamaFile configuration 
{
   "ai-features.llamafile.llamafiles": [
       {
           "name": "modelname", //you can choose a name for your model
           "uri": "file:///home/.../YourModel.llamafile",
           "port": 30000 //you can choose a port to be used by llamafile
       }
   ]
}

Replace name, uri, and port with your specific LlamaFile details.

HDevelopEVO also offers convenience commands to start and stop your LlamaFiles:

To start a LlamaFile:
Use the command Start Llamafile, then select the model you want to start.
To stop a LlamaFile:
Use the Stop Llamafile command, then select the running Llamafile which you want to terminate.

Ensure that your LlamaFiles are executable. For more details on LlamaFiles, including a quickstart, see the official Mozilla LlamaFile documentation .

Mistral modelsđź”—

Mistral models, including those on “La Platforme” can be used via the OpenAI API and support the same feature set.

Here is an example configuration:

Mistral models configuration 
"ai-features.openAiCustom.customOpenAiModels": [
    {
        "model": "mistral-large-latest",
        "url": "https://api.mistral.ai/v1",
        "id": "Mistral",
        "apiKey": "YourAPIKey",
        "developerMessageSettings": "system"
    },
    {
        "model": "codestral-latest",
        "url": "https://codestral.mistral.ai/v1",
        "id": "Codestral",
        "apiKey": "YourAPIKey",
        "developerMessageSettings": "system"
    }
]

Ollamađź”—

To connect to models hosted via Ollama, enter the corresponding URL, along with the available models, in your settings.json. Some models on Ollama also support using an OpenAI-compatible models via vLLM API.

The key fields are:

  • modelId: Unique identifier of the model
  • requestSettings: Provider-specific options, such as token limits or stopping criteria
  • providerId: Optionally, this specifies the provider for the settings, for example, Huggingface, Ollama, OpenAi. If omitted, settings apply to all providers that match the modelId.

OpenAI (hosted by OpenAI)đź”—

To enable the use of OpenAI, you need to create an API key in your OpenAI account and enter it in the settings File > Preferences > Settings > AI Assistants > OpenAI Official > OpenAI Api Key.

Important

When using this preference, the API key will be stored in clear text. Use the following environment variable instead to set the key securely: OPENAI_API_KEY

Creating an API key requires an OpenAI account, and using these models may incur additional costs. Be sure to monitor your usage carefully to avoid unexpected charges. We have not yet optimized the AI assistants for token usage.

OpenAI-compatible models via vLLMđź”—

As an alternative to using an official OpenAI account, HDevelopEVO also supports arbitrary models compatible with the OpenAI API and hosted via vLLM , for example. This enables you to connect to self-hosted models with ease. To add a custom model, click on the link in the settings section and add your configuration like the following:

OpenAI comptible models configuration 
{
  "ai-features.openAiCustom.customOpenAiModels": [
    {
      "model": "your-model-name",
      "url": "your-URL",
      "id": "your-unique-id",
      "apiKey": "your-api-key",
      "developerMessageSettings": "system"
    }
  ]
}

  • model, url: Indicate the end point and model to use (mandatory)

  • id: Used to refer to this configuration. If not provided, the model name is used as the ID.

  • apiKey: Key to access the API served at the given URL. Use true to apply the global OpenAI API key. If not given, no-key is used.

  • apiVersion: Either the API version to access the API served at the given URL in Azure or true (default) to use the global OpenAI API version.

  • developerMessageSettings: Controls the handling of system messages: user, system, and developer are used as a role, mergeWithFollowingUserMessage prefixes the following user message with the system message or converts the system message to user message if the next message is not a user message. skip removes the system message. Default: developer

  • enableStreaming: Flag indicating whether to use the streaming API; default: true.

Vercel AIđź”—

The Vercel AI provider offers a unified way of communicating with LLMs through the Vercel AI SDK framework. It serves as an alternative to other providers and currently supports OpenAI and Anthropic APIs.

If you already have your OpenAI or Anthropic API keys set as environment variables (OPENAI_API_KEY or ANTHROPIC_API_KEY), no additional configuration is required for the Vercel provider.

If you configure your API keys through the settings, you need to explicitly set the API keys for the Vercel provider under File > Preferences > Settings > AI Assistants > Vercel AI.

Vercel AI: Official models configurationđź”—

The Vercel provider includes the most common OpenAI and Anthropic models by default. To add new official models, configure them in your settings.json:

Vercel AI configuration 
{
  "ai-features.vercelAi.officialModels": [
    {
      "id": "vercel/openai/new-gpt",
      "model": "new-gpt",
      "provider": "openai"
    }
  ]
}

Vercel AI: Custom models configurationđź”—

The Vercel provider supports custom models compatible with the Vercel AI SDK. Configure custom endpoints in your settings.json:

Vercel AI custom models configuration 
{
  "ai-features.vercelAi.customModels": [
    {
      "model": "custom-model-name",
      "url": "https://api.example.com/v1",
      "id": "my-custom-model",
      "apiKey": "your-api-key",
      "provider": "openai",
      "supportsStructuredOutput": true,
      "enableStreaming": true
    },
    {
      "model": "local-llama",
      "url": "http://localhost:8000",
      "id": "local-llama-model",
      "apiKey": true,
      "provider": "openai",
      "supportsStructuredOutput": false,
      "enableStreaming": false
    }
  ]
}

Restriction

Keep in mind that the Vercel AI provider is currently experimental.

Configuring a proxyđź”—

All AI providers support HTTP proxy configuration. This is particularly useful in corporate environments where internet access is routed through a proxy. The proxy is resolved in the following order:

  1. http.proxy preference in the IDE settings (Application > HTTP > Proxy)
  2. Standard environment variables: HTTPS_PROXY (or https_proxy), HTTP_PROXY (or http_proxy)

To allow certain hosts to bypass the proxy and connect directly, add them to the NO_PROXY (or no_proxy) environment variable. The no-proxy list supports exact hostname matching, domain suffix matching (for example, .example.com), wildcards (*), IP addresses, and port-specific rules.

Custom request settingsđź”—

You can define custom request settings for specific language models to tailor how models handle requests, based on their provider.

Add the settings in your settings.json.

Custom request configuration 
"ai-features.modelSettings.requestSettings": 
[
    {
        "scope": {
            "providerId": "ollama",
            "modelId": "qwen3:14b"
        },
        "requestSettings": { "num_ctx": 40960 },
        "clientSettings": {
            "keepToolCalls": true,
            "keepThinking": false
        }
    },
    {
        "scope": {
            "providerId": "huggingface",
            "modelId": "Qwen/Qwen2.5-Coder-32B-Instruct",
        },
        {
            "requestSettings": { "max_new_tokens": 2048 },
        }
     }
]
  • scope: Any combination of providerId, agentId, and modelId. Describes the model(s) to which the settings should be applied. The models are matched based on specificity (agent: 100, model: 10, provider: 1 points). This way, settings which are to be applied to all or just one ollama model can be specified, depending on whether only the providerId is specified or also the modelId is given.
  • clientSettings: Controls retention of reasoning and/or toolcall messages in the chat context. For example, if keepThinking is set to true, the reasoning is kept in the context for follow-up chat messages. Else, earlier reasoning messages are removed (potentially saving input tokens).
  • modelId: Unique identifier of the model
  • requestSettings: Provider-specific options, such as token limits or stopping criteria
  • providerId: Optionally, this specifies the provider for the settings, for example, Huggingface, Ollama, OpenAi. If omitted, settings apply to all providers that match the modelId.

In addition to global custom request settings, HDevelopEVO supports an experimental feature that allows you to define custom request settings per individual chat session. This adds flexibility by enabling adjustments on-the-fly within a single conversation.
Click the icon in the top-right corner of a chat window to access this functionality. The settings must currently be entered manually in the settings.json file.

Example

To make the language model more or less creative for a particular session, adjust the temperature parameter:

{
"temperature": 1
}