Skip to content

Using AI Assistantsđź”—

Enabling the AI Assistantsđź”—

Before you can use the AI Assistants of HDevelopEVO, you need to enable the AI Assistants in your settings. Go to File > Preferences > Settings > AI Assistants and select Enable AI and accept the disclaimer.

LLM Set-Upđź”—

In order to be able to use the AI Assistants you need to provide access to at least one LLM, for example OpenAI or DeepSeek.

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.

Warning

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 a paid subscription, 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.

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-assistants.openAiCustom.customOpenAiModels": [
        {
            "model": "deepseek-chat",
            "url": "https://api.deepseek.com",
            "id": "deepseek-chat",
            "apiKey": "<yourApiKey>",
            "enableStreaming": true,
            "supportsDeveloperMessage": false,
            "developerMessageSettings": "system"
        }
    ],
    "ai-assistants.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.

Azuređź”—

All models hosted on Azure that are compatible with the OpenAI API are accessible via the Provider for OpenAI Compatible Models provider. Note that some models hosted on Azure may require different settings for the system message, which are detailed in the OpenAI Compatible Models section and the Readme.

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.

Warning

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.

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.

Warning

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. At the moment, the Hugging face provider only supports text generation 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.

Warning

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.

Hugging Face LlamaFile configuration

settings.json
{
   "ai-assistants.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.

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 API.

Ollama configuration 
"ai-assistants.modelSettings.requestSettings": [
    {
        "modelId": "Qwen/Qwen2.5-Coder-32B-Instruct",
        "requestSettings": { "max_new_tokens": 2048 },
        "providerId": "huggingface"
    },
    {
        "modelId": "gemma2",
        "requestSettings": { "stop": ["<file_sep>"] },
        "providerId": "ollama"
    }
]

The key fields are:

  • modelId: The 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.

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-assistants.modelSettings.requestSettings": 
[
    {
        "modelId": "Qwen/Qwen2.5-Coder-32B-Instruct",
        "requestSettings": { "max_new_tokens": 2048 },
        "providerId": "huggingface"
    },
    {
        "modelId": "gemma2",
        "requestSettings": { "stop": ["<file_sep>"] },
        "providerId": "ollama"
    }
]

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.

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
}

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 Restrictions

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

Code Completionđź”—

Code Completion can be used in manual and automatic mode.

By default, the automatic Code Completion is enabled, which executes continuous requests to the underlying LLM while coding, providing suggestions on the go as you’re typing. In manual mode, suggestions will be displayed when pressing Ctrl+Alt+Space. This gives you greater control over the appearance of AI suggestions. The requests are then canceled when moving the cursor.

The code completion can be enabled in your settings: File > Preferences > Settings > AI Assistants > Chat > Automatic Code Completion.

There are two prompt variants available for the code completion. You can select them in Code Completion > Prompt Templates, and the used prompt template to your personal preferences or to the LLM you want to use.

You can also specify Excluded File Extensions, for which the AI-powered code completion will be deactivated.

The setting Strip Backticks will remove surrounding backticks that some LLMs might produce, depending on the prompt.

The setting Max Context Lines allows you to configure the maximum number of lines used for AI code completion context. This setting can be adjusted to customize the size of the context provided to the model, which is especially useful when using smaller models with limited token capacity.

Chatđź”—

HDevelopEVO provides a global chat interface where users can interact with a chat agent.

To open the chat, go to View > Chat or press Ctrl+Alt+I. The chat panel opens on the right hand side. Use to send a request to a designated agent, and use to attach files that you have a question about for the chat.

Your chat query is sent to an chat agent which then provides the corresponding answer. By default, the Orchestrator Chat Agent is set and it chooses the best fitting agent. You can also send your query directly to a specific agent by typing @<name-of-agent>into your chat window. For example, type @coder for queries around coding, or type @command to find the right command according to all possible commands that can be executed at that stage.

Agentsđź”—

The following agents are available by default:

Orchestrator
This agent analyzes your request against the description of all available chat agents and selects the best fitting agent to answer the request. Your request will then be directly delegated to the selected agent without further confirmation. This is the default agent.
Architect
This agent can access your workspace, it can get a list of all available files and folders and retrieve their content, but it cannot modify files. It can therefore answer questions about the current project, project files and source code in the workspace, such as how to build the project, where to put source code, where to find specific code or configurations, etc.
Coder
This agent can access your workspace, it can get a list of all available files and folders and retrieve their content. Furthermore, it can suggest modifications of files. It can therefore assist with coding tasks or other tasks involving file changes.
Universal
This agent provides answers to general programming and software development questions. It is also the fall-back for any generic questions you might ask. The universal agent currently does not have any context by default, that is it cannot access the current user context or the workspace.
Command
This agent is aware of all commands that you can execute within HDevelopEVO. Based on the request, it can find the right command and then let you execute it.
Terminal Assistant
This agent provides assistance to write and execute arbitrary terminal commands. Based on request, it suggests commands and allows you to directly paste and execute them in the terminal. It accesses the current directory, environment, and the recent terminal output of the terminal session to provide context-aware assistance.

Custom Agentsđź”—

Custom agents enable you to define new chat agents with custom prompts on the fly. These agents are then immediately available in the default chat.

To define a new custom agent, navigate to the AI Configuration and click on Add Custom Agent. This opens the .yml file where all available custom agents are defined.

Custom Agent Configuration 
id: obfuscator
name: Obfuscator
description: This is an example agent. Please adapt the properties to fit your needs.
prompt: Obfuscate the following code so that no human can understand it anymore. Preserve the functionality.
defaultLLM: openai/gpt-4o

The key fields are:

  • id: Unique identifier for the agent
  • name: Display name of the agent
  • description: Brief explanation of what the agent does
  • prompt: Default prompt that the agent will use for processing requests
  • defaultLLM: Language model used by default

Agent Pinningđź”—

Agent pinning reduces the need for repeated agent references.
When you mention an agent in a prompt and no agent is pinned, the mentioned agent is automatically pinned. If an agent is already pinned, mentioning a different agent will not change the pinned agent. Instead, the newly mentioned agent will be used only for that specific prompt. You can manually unpin an agent through the chat interface if needed.

Context Variablesđź”—

You can augment your requests in the chat with context by using variables.

Do one of the following:

  • To refer to the currently selected text, use #selectedText in your request.
  • To further specify the scope of your request, pass context files into the chat. You can also drag and drop a file into the chat view.
  • To use the auto-completion, type #file or directly type #<file-name>.

Here are some of the most frequently used variables:

#file:src/my-code.ts
In the user message is replaced to the workspace-relative path, alongside attaching the file to the context. This allows adding the file content to the context and then referring to the file in the chat input text efficiently in one go.
#file:filePath
Inserts the path to the specified file relative to the workspace root. After typing #file:, auto-completed suggestions will help you to specify a file. The suggestions are based on the recently opened files and on the file name you’re typing. After typing # followed by the file name you can directly start your search for the file you want to add and reference in your message.
#filePath
Is the shortcut for #file:filePath.
#currentRelativeFilePath
Is used for the relative file path of the currently selected file in the editor or explorer.
#currentRelativeDirPath
Is used for the directory path of the currently selected file.
#selectedText
Use this for the currently highlighted text in the editor. This does not include the information from which file the selected text originates.

You can see the full list of available variables when typing # in the chat input field.

Prompt Template and Fragment Locationsđź”—

By default, custom prompts, prompt variants, and prompt fragments are created and read from user-wide local directories that can be configured in the settings AI Assistants > Prompt Templates. This setting is valid for all of your projects. In addition, you can configure workspace-specific directories and files that are available as prompts and prompt fragments to introduce project-specific adaptations and additions.

You can specify workspace-relative directories settings for individual files, relevant file extensions for prompt templates and fragments under AI Assistants > Prompt Templates. Workspace-specific prompts have priority, so you can override the prompts of the available agents in a workspace-specific way. Furthermore, these workspace-specific templates are accessible via the prompt fragment variable #prompt:filename in both the chat interface and agent prompt editors.

Prompt fragments enable you to define reusable parts of prompts for recurring instructions given to the AI. These fragments can be referenced both in the chat interface, for one-time usage, and within the prompt templates of agents, to customize agents with reusable fragments. For example, you can define a prompt fragment that specifies a task, provides workspace context or coding guidelines, and then reuse it across multiple AI requests without having to repeat the full text.

To support this functionality, HDevelopEVO includes a special variable #prompt:promptFragmentID that takes the ID of a prompt fragment as an argument.

MCP Integrationđź”—

HDevelopEVO integrates the Model Context Protocol (MCP), enabling you to configure and utilize external services in your AI workflows.

Preview Restrictions

While this integration does not yet include MCP servers in any standard prompts, it already allows you to explore the MCP ecosystem and discover interesting new use cases.

To learn more about MCP, see the official announcement from Anthropic. For a list of available MCP servers, visit the MCP Servers Repository.

Configuring MCP Serversđź”—

To configure MCP servers, open the Preferences and add entries to the MCP Servers Configuration section. Each server requires a unique identifier, for example, brave-search or filesystem, and configuration details such as the command, arguments, optional environment variables and autostart.

autostart, true by default, will automatically start the respective MCP server whenever you restart HDevelopEVO. In your current session, however, you’ll still need to manually start it using the MCP Start MCP Server command.

MCP example configuration 
{
  "brave-search": {
    "command": "npx",
    "args": [
      "-y",
      "@modelcontextprotocol/server-brave-search"
    ],
    "env": {
      "BRAVE_API_KEY": "YOUR_API_KEY"
    },
    "autostart": false
  },
  "filesystem": {
    "command": "npx",
    "args": [
      "-y",
      "@modelcontextprotocol/server-filesystem",
      "/Users/YOUR_USERNAME/Desktop"
    ],
    "env": {
      "CUSTOM_ENV_VAR": "custom-value"
    }
  },
  "git": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/repo",
        "run",
        "mcp-server-git"
      ]
    },
  "git2": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository",
        "/path/to/otherrepo"
      ]
  }
}

Note

uvx comes preinstalled with uv and does not need to be installed manually. Running pip install uvx installs a deprecated tool unrelated to uv.

The configuration options include:

  • command: Executable used to start the server (for example, npx)
  • args: Array of arguments passed to the command
  • env: Optional set of environment variables for the server

Windows users

On Windows, you need to start a command interpreter (for example, cmd.exe) as the server command in order for path lookups to work as expected. The effective command line is then passed as an argument.

For example:

"filesystem": {
    "command": "cmd",
    "args": ["/C", "npx -y @modelcontextprotocol/server-filesystem /Users/YOUR_USERNAME/Desktop"],
    "env": {
        "CUSTOM_ENV_VAR": "custom-value"
    }
  }

Starting and Stopping MCP Serversđź”—

HDevelopEVO provides commands to manage MCP servers:

Start MCP Server
Use the command MCP: Start MCP Server to start a server. The system displays a list of available servers to select from.
Stop MCP Server
Use the command MCP: Stop MCP Server to stop a running server.

When a server starts, a notification is displayed confirming the operation, and the functions made available. You can also set a MCP server to autostart in the settings, true by default.

Note

In a browser deployment MCP servers are scoped per connection, that is, if you manually start them, you need to start them once per browser tab.

Using MCP Server Functionsđź”—

Once a server is running, its functions can be invoked in prompts using the following syntax:

~{mcp_<server-name>_<function-name>}
  • mcp: Prefix for all MCP commands
  • <server-name>: Unique identifier of the server (for example, brave-search)
  • <function-name>: Specific function exposed by the server (for example, brave_web_search)

Example

To use the brave_web_search function of the brave-search server, you can write: 

~{mcp_brave-search_brave_web_search}

This allows you to seamlessly integrate external services into your AI workflows.

SCANOSSđź”—

SCANOSS is a code scanner powered by SCANOSS, enabling you to analyze generated code for open-source compliance and licensing. This helps to understand potential licensing implications when using generated code.

Note

This feature sends a hash of suggested code snippets to the SCANOSS service hosted by the Software Transparency Foundation for analysis. While the service is free to use, very high usage may trigger rate limiting. Additionally, neither MVTec nor SCANOSS can guarantee that no license implications exist, even if no issues are detected during the scan.

To configure SCANOSS open Settings > AI Assistants > SCANOSS Mode and select the desired mode

  • Off: Disables SCANOSS completely
  • Manual: Allows you to trigger scans manually via the SCANOSS button on generated code via the Coder Agent or directly in the Chat view
  • Automatic: Automatically scans generated code snippets in the Chat view

Manual Scanningđź”—

To manually scan a code snippet:

  1. Generate a code in the AI Chat view or via the Coder Agent.

  2. Click the SCANOSS button in the toolbar of the code renderer embedded in the Chat view or above the changeset.
    ⇒ A result icon will appear:

    • A warning icon if a match is found
    • A green check mark if no matches are found

If a warning icon is displayed, click the SCANOSS button again to view detailed scan results in a popup window.

Automatic Scanningđź”—

In Automatic mode, SCANOSS scans code in the background whenever it is generated in the Chat View or with the Coder Agent. Results are displayed immediately, indicating whether any matches are found.

Understanding SCANOSS Resultsđź”—

After a scan is completed, SCANOSS provides a detailed summary, including

  • Match Percentage: Degree of similarity between the scanned snippet and the code in the database
  • Matched File: File or project containing the matched code
  • Licenses: List of licenses associated with the matched code, including links to detailed license terms

AI Historyđź”—

The AI History view allows you to review all communications between agents and underlying LLMs. Select the corresponding agent at the top to see all its requests in the section below.