Documentations

• 1: Quick Start
• 1.1: SmartCode AI Coding Assistant
• 1.1.1: SmartCode AI Coding Assistant (VSCode)
• 1.1.2: SmartCode AI编码助手 JetBrains插件
• 1.2: Code Review Agent 代码评审智能体
• 1.3: SmartChat 企业级ChatGPT服务
• 1.4: SmartAnswer 企业知识库
• 2: Product Manual
• 2.1: ClinePRO
• 2.1.1: Overview
• 2.1.2: Getting Started
• 2.1.3: Installing Essential Development Tools
• 2.1.4: Tools
• 2.1.5: Prompt Skills
• 2.1.5.1: Overview
• 2.1.5.2: Custom Instructions Library
• 2.1.5.3: Memroy Bank
• 2.1.5.4: Memory Bank Structure
• 2.1.6: MCP Servers
• 2.1.6.1: Overview
• 2.1.6.2: Quick Start
• 2.1.6.3: Building MCP Server from GitHub
• 2.1.6.4: Building Custom MCP Server
• 2.1.7: Customization
• 2.2: SmartCode AI Coding Assistant
• 2.3: SmartChat ChatGPT for Enterprise Users
• 2.4: SmartAnswer KB for Enterprises
• 2.5: AISE Service Base
• 2.5.1: App Marketplace
• 2.5.1.1: Plugin Upload Filename Validation
• 3: Releases Note
• 3.1: R48 - Workspace and Knowledge Base Assistant Integration
• 3.2: R46 - Experience Enhancements
• 3.3: R42 - System Operations Improvements and Qwen Model Support
• 3.4: R40 - Code Review Agent Official Release
• 3.5: R36 - Add more telemetry events, service health checks, and UX improvements
• 3.6: R34 - SmartCode chat supports #variables, Devi public preview
• 3.7: R32 - Optimized admin features, SmartCode chat variable support, and more
• 3.8: R30 - Mermaid Diagram, ARM deployment, UOS certification, and UX improvements
• 3.9: R28 - 体验更好/更稳定的SmartCode
• 3.10: R26 - DeepSeek私有化部署完整支持
• 3.11: R24 - DeepSeek初步支持以及SmartCode v2

1 - Quick Start

1.1 - SmartCode AI Coding Assistant

1.1.1 - SmartCode AI Coding Assistant (VSCode)

Install, Config and Login

This document provides instructions for users on how to install the SmartCode plugin and log into the AISE system. Additionally, it explains the plugin update mechanism and configuration settings.

Get Installer

The SmartCode VSCode plugin, as the AI Coding Assistant plugin provided by the AISE system for Visual Studio Code, can be obtained through the AISE service. You need to first obtain the following information from the AISE administrator specified by your organization:

• AISE Service URL
• Your AISE Account

After obtaining the above information, please follow steps below:

1. Open the browser and enter [AISE Service URL].

2. Enter your [AISE account], and you can see the following page.

3. Click on the Applications | Marketplace in the left menu, and you can see the following page.

4. According to the IDE you are using, click the Download button on the corresponding application to download the latest extension installation package. The VSCode installation package is in vsix format.

Extension Install and Update

Install Extension and AISE Service URL config

1. After the download is completed, open Visual Studio Code, click the Extensions icon on the left toolbar, select Install from VSIX in the … menu in the upper right corner, and select the vsix file downloaded in the previous step in the popped-up file selection dialog to complete the installation.

2. After the installation is completed, similar screen will appear, and the words SmartCode will be displayed on the status bar, indicating that the installation is successful.

3. Configure [AISE Service URL]. If your extensions is a universal vsix, you may need to configure the Service URL before using it.

Click Open Settings in the above figure, or click the SmartCode icon and select Settings in the popped-up menu.

This will open the built-in settings page of VSCode and filter to the SmartCode-related configuration items at the same time. Find the AISE Service URL configuration item among them and enter your address. If your address is correct, the bottom status bar will become the status of SmartCode [Please log in].

Login

After configuring the service URL as above, users can log in to the system with their own [AISE account].

1. Click the SmartCode icon on the status bar and select Login in the popped-up menu.

2. VSCode will prompt the user to open the browser or log in manually by copying the login address. Click the “Open” button.

3. Use your [AISE account] to complete the login in the opened browser. If the browser shows the following information, it means that the login is successful. SmartCode should detect the login status within a few seconds and complete the login by itself. The complete login process video is as follows.

Obtain the extension information

The SmartCode plugin provides About menu, which contains the basic information of the plugin and the IDE, and this information is helpful for locating problems. Users can open it by clicking the SmartCode icon on the status bar and selecting About.

The popped-up view contains a Copy button, which can be used to copy all the information.

Configuration

The plugin configuration of SmartCode for VSCode is divided into two parts: general configuration and Chat configuration. The general configuration is located in the built-in configuration system of VSCode; the Chat configuration is embedded in the SmartCode Chat interface to provide users with more flexible configuration capabilities.

Manage General Configuration

To manage the general configuration, you can click the SmartCode status bar icon and select Configuration to enter the following interface.

The currently supported configuration items and function descriptions are as follows.

Manage Chat Configuration

Click the settings icon in the upper right corner of the Chat window to enter the Chat configuration page.

当前支持的配置项和功能说明如下

Automatic upgrade

The SmartCode for VSCode plugin, in cooperation with the AISE Base Service, supports the automatic upgrade ability. This function does not depend on the VSCode plugin market, and can realize the push and automatic update of the new version of the plugin within the enterprise, and allows users or administrators to conduct detailed control over the upgrade behavior. The version detection or upgrade process is as follows.

1. When the user restarts VSCode, SmartCode will automatically connect to the server to check if there is an upgradable new version. Users can also manually trigger it by clicking the SmartCode icon in the status bar and choosing Version Check in the popped-up menu. Once a new version is detected, the following message will pop up to prompt the user. The user can choose Upgrade or Cancel this upgrade.

2. After the user clicks the Upgrade button, SmartCode will automatically download the new version installation package in the background and update the plugin in the current environment. After the upgrade is completed, there will be the following prompt.

3. Click Reload to complete the entire upgrade process.

1.1.2 - SmartCode AI编码助手 JetBrains插件

安装、配置和登录系统

本文档引导用户完成 SmartCode 插件的安装和登录AISE系统的基本操作，同时对插件更新机制和插件配置进行说明。

获取插件安装包

SmartCode VSCode 插件作为 AISE系统针对 Visual Studio Code 提供的 AI编码助手 插件，可以通过 AISE服务 进行获取。您需要首先从您组织指定的 AISE管理员 处获取以下信息:

• AISE服务地址
• 您的AISE账号

获取以上信息后，请按以下操作步骤进行操作：

1. 打开浏览器，并输入 【AISE服务地址】

2. 输入您的 【AISE账号】，即可进入如下界面

3. 点击左侧菜单的 应用 | 应用市场 ，即可进入如下界面

4. 根据您所使用的IDE点击对应应用上的 安装 按钮，即可下载最新的 插件安装包。IDEA安装包为zip格式。

插件安装和更新

插件安装和服务地址配置

1. 下载完成后，打开 JetBrains IDE，通过菜单进入设置 ｜ 插件 视图，并点击 齿轮 图标，在弹出的对话框中选择 从磁盘安装插件 …。在弹出的文件选择对话框中选择上一步下载的 zip文件。

2. 安装完成后SmartCode插件会出现在 已安装 的插件列表中，请点击 重启IDE 完成激活过程。

3. 配置 【AISE服务地址】，如果您的插件是通用插件，可能会出现以下提示信息，表示需要先配置服务地址才能使用。

点击上图中的 修改设置，或者点击 SmartCode 图标，在弹出的菜单中选择 修改设置。

这个操作会开启 JetBrains IDE 内置的设置界面，同时过滤到 SmartCode 相关的配置项上，在其中找到 AISE服务地址 配置项，输入您的 【AISE服务地址】。如果您的地址正确，底部状态栏会显示 登录以使用AISE 的状态。

登录

以上配置好服务地址后，用户即可使用自己的 【AISE账号】登录系统。

1. 点击状态栏上 SmartCode 图标，在弹出的菜单中选择 登录到AISE

2. JetBrains 会自动打开浏览器进入 AISE登录界面，如果您之前已经登录AISE服务器，那么会自动完成登录动作。

3. 在开启的浏览器中使用您的【AISE账号】完成登录，浏览器显示如下信息，即代表登录成功。

插件端应该在几秒钟内检测到登录状态，自行完成登录。完整登录过程视频如下

获取插件信息

SmartCode 插件提供一个 关于 界面，包含了插件和IDE的基本信息，这些信息有助于在遇到问题时的定位。用户可以通过点击状态栏 SmartCode图标 并选择 关于 开启。

弹出的视图中包含一个 复制 按钮，可以用来复制所有信息。

插件配置

SmartCode for JetBrains 的插件配置分为 通用配置 和 Chat配置 两部分，通用配置通过 JetBrains IDE 内置的配置系统实现，属于静态配置；Chat配置则嵌入在 SmartCode Chat 界面中，为用户提供更灵活的动态配置能力。

管理通用配置

管理通用配置可以通过点击 SmartCode 状态栏图标，并选择 修改配置 进入以下界面

当前支持的配置项和功能说明如下

管理Chat配置

点击Chat窗口右上角的 设置图标 即可进入Chat配置页面

当前支持的配置项和功能说明如下

自动升级

SmartCode for JetBrains 插件配合 AISE服务 支持自动升级能力，AISE服务 内置兼容JetBrains插件市场的API，可以在企业内部实现新版插件的推送和自动更新，并允许用户或者管理员对于升级行为进行细化控制。

版本检测或者升级过程如下

1. 当用户重新启动JetBrains IDE 时，SmartCode会自动连接服务器检查是否存在可升级的新版本。用户也可以通过点击 状态栏的SmartCode图标，在弹出的菜单中选择 检查更新 的方式手工触发。 一旦检测到新版本，会弹出以下消息提示用户。用户可以选择 升级 或者 取消 本次升级。

2. 用户点击 升级 按钮后，SmartCode会开启JetBrains IDE内置的插件更新界面。插件会显示为可更新状态，点击 更新 即可启动升级动作。

3. 升级完成后需要点击 重启IDE 即可完成整个升级过程。

JCEF安装步骤

Andriod Studio 是 Google 基于 JetBrains的IDE框架另外开发的用户andriod开发的IDE环境，默认不带JCEF框架。JCEF框架是用来在IDE中嵌入web应用的框架。SmartCode插件的chat组件使用了一个本地运行的web app应用，需要使用JCEF框架才能在Android Studio中正常显示和使用。其他JetBrains家族产品，比如IDEA，pycharm等会自带JCEF框架，无需按照本文档进行处理。 注意：Android Studio 版本低于2023.3.1的不支持选择本地路径。只能联网自动下载，需要配置Android Studio的代理，设置代理的主要目的是让 Android Studio 可以连接到github获取JCEF sdk包的列表数据，如果连接不到github，用户将看不到这个列表。

安装JCEF的步骤分为2步，以下2个步骤完成后，需要重新启动IDE再安装SmartCode插件。如果在使用本文档之前已经安装了SmartCode需要先卸载掉。

1. 安装JCEF
2. 修改Andriod Studio注册表

下载对应版本

https://github.com/JetBrains/JetBrainsRuntime/releases/tag/jbr-release-17.0.10b1087.21

Android Studio设置自定义JBR

• 打开菜单项帮助查找操作…并搜索 “Choose Boot Java runtime for the IDE…”

• 选择解压的JBR目录，IDE 将重新启动。

低于2023.3.1安装

设置代理的主要目的是让 Android Studio 可以连接到github获取JCEF sdk包的列表数据，如果连接不到github，用户将看不到这个列表。 因此，用户可以自行解决代理的问题，只要确保Andriod Studio可以连接到github就可以。

• 设置代理

• 打开菜单项帮助查找操作…并搜索 “Choose Boot Java runtime for the IDE…”
• 在下拉列表中选择一个带JCEF的版本安装
• 打开菜单项帮助查找操作…并搜索 “Registry…”，修改注册表
• 重启后安装插件

修改Andriod Studio注册表

• 打开菜单项帮助查找操作…并搜索 “Registry…”

ide.browser.jcef.contextMenu.devTools.enabled true
ide.browser.jcef.sandbox.enable false
ide.browser.jcef.gpu.disable true

重启Android Studio后安装插件

以上操作完成后，重新启动Andriod Studio再安装SmartCode插件。

1.2 - Code Review Agent 代码评审智能体

使用流程

创建 PR

Code Review Agent 代码评审智能体 会自动生成PR的标题、类型、摘要和代码变更说明，这些信息将显示在PR的描述中，可以帮助评审者快速了解PR的内容。

1. 创建Pull Request (PR) 在Azure DevOps上 上创建一个新的Pull Request。

2. 等待片刻会自动生成PR描述

使用 /review 指令 生成PR评审

1. 触发代码审查：在PR的评论区输入指令 /review。

2. 等待片刻会自动生成评审内容

使用 /ask 指令对当前PR提问

1. 提出问题：在PR的评论区输入指令 /ask 问题，后跟具体问题。

2. 等待片刻会自动生成回复内容

使用 /update_changelog 指令生成变更日志

1. 生成PR变更日志：在PR的评论区输入指令 /update_changelog。

2. 等待片刻会自动生成变更日志

指令列表

以下指令触发式都是在PR添加评论的试，指令后可以加上具体的参数。

• /summary 或者 /describe : 生成PR描述，创建PR是会自动生成，也可以手工执行
• /review：触发代码审查并提供反馈。
• /ask [问题]：提出具体问题并获取回答。
• /update_changelog：自动生成并更新变更日志。
• /improve --pr_code_suggestions.commitable_code_suggestions=true: 生成具体的改进代码，
• /generate_labels：自动生成标签，并添加到当前PR中
• /config: 获取工具配置，仅用于Code Review Agent 代码评审智能体的维护
• /help：获取命令的使用帮助

配置指南

请参考以下链接获取详细的配置指南：配置指南

1.3 - SmartChat 企业级ChatGPT服务

1.4 - SmartAnswer 企业知识库

2 - Product Manual

Product Manual

This document provides detailed explanations of features of AISE. The product manual is organized according to modules. If you are looking to usage guidance through scenarios, you can refer to Hands-on Labs.

2.1 - ClinePRO

2.1.1 - Overview

Getting Started

• New to coding? We’ve prepared a gentle introduction:
  • Getting Started for New Coders

Improving Your Prompting Skills

• Want to communicate more effectively with Cline? Explore:
  • Prompt Engineering Guide
  • Cline Memory Bank

Exploring Cline’s Tools

• Understand Cline’s capabilities:

  • Cline Tools Guide

• Extend Cline with MCP Servers:

  • MCP Overview
  • Building MCP Servers from GitHub
  • Building Custom MCP Servers

Additional Resources

• Cline GitHub Repository: https://github.com/cline/cline
• MCP Documentation: https://modelcontextprotocol.org/docs

We’re always looking to improve this documentation. If you have suggestions or find areas that could be enhanced, please let us know. Your feedback helps make Cline better for everyone.

2.1.2 - Getting Started

Getting Started with Cline | New Coders

Welcome to Cline! This guide will help you get set up and start using Cline to build your first project.

What You’ll Need

Before you begin, make sure you have the following:

• VS Code: A free, powerful code editor.

  • Download VS Code

• Development Tools: Essential software for coding (Homebrew, Node.js, Git, etc.).

  • Follow our Installing Essential Development Tools guide to set these up with Cline’s help (after getting setup here)
  • Cline will guide you through installing everything you need

• Cline Projects Folder: A dedicated folder for all your Cline projects.

  • On macOS: Create a folder named “Cline” in your Documents folder
    • Path: /Users/[your-username]/Documents/Cline
  • On Windows: Create a folder named “Cline” in your Documents folder
    • Path: C:\Users\[your-username]\Documents\Cline
  • Inside this Cline folder, create separate folders for each project
    • Example: Documents/Cline/workout-app for a workout tracking app
    • Example: Documents/Cline/portfolio-website for your portfolio

• Cline Extension in VS Code: The Cline extension installed in VS Code.

• Here’s a tutorial on everything you need to get started.

Step-by-Step Setup

Follow these steps to get Cline up and running:

1. Open VS Code: Launch the VS Code application. If VS Code shows “Running extensions might…”, click “Allow”.

2. Open Your Cline Folder: In VS Code, open the Cline folder you created in Documents.

3. Navigate to Extensions: Click on the Extensions icon in the Activity Bar on the side of VS Code.

4. Search for ‘Cline’: In the Extensions search bar, type “Cline”.

5. Install the Extension: Click the “Install” button next to the Cline extension.

6. Open Cline: Once installed, you can open Cline in a few ways:

   • Click the Cline icon in the Activity Bar.
   • Use the command palette (CMD/CTRL + Shift + P) and type “Cline: Open In New Tab” to open Cline as a tab in your editor. This is recommended for a better view.
   • Troubleshooting: If you don’t see the Cline icon, try restarting VS Code.
   • What You’ll See: You should see the Cline chat window appear in your VS Code editor.

Setting up OpenRouter API Key

Now that you have Cline installed, you’ll need to set up your OpenRouter API key to use Cline’s full capabilities.

1. Get your OpenRouter API Key:
   • Get your OpenRouter API Key
2. Input Your OpenRouter API Key:
   • Navigate to the settings button in the Cline extension.
   • Input your OpenRouter API key.
   • Select your preferred API model.
     • Recommended Models for Coding:
       • anthropic/claude-3.5-sonnet: Most used for coding tasks.
       • google/gemini-2.0-flash-exp:free: A free option for coding.
       • deepseek/deepseek-chat: SUPER CHEAP, almost as good as 3.5 sonnet
     • OpenRouter Model Rankings

Your First Interaction with Cline

Now you’re ready to start building with Cline. Let’s create your first project folder and build something! Copy and paste the following prompt into the Cline chat window:

Hey Cline! Could you help me create a new project folder called "hello-world" in my Cline directory and make a simple webpage that says "Hello World" in big blue text?

What You’ll See: Cline will help you create the project folder and set up your first webpage.

Tips for Working with Cline

• Ask Questions: If you’re unsure about something, don’t hesitate to ask Cline!
• Use Screenshots: Cline can understand images, so feel free to use screenshots to show him what you’re working on.
• Copy and Paste Errors: If you encounter errors, copy and paste the error messages into Cline’s chat. This will help him understand the issue and provide a solution.
• Speak Plainly: Cline is designed to understand plain, non-technical language. Feel free to describe your ideas in your own words, and Cline will translate them into code.

FAQs

• What is the Terminal? The terminal is a text-based interface for interacting with your computer. It allows you to run commands to perform various tasks, such as installing packages, running scripts, and managing files. Cline uses the terminal to execute commands and interact with your development environment.
• How Does the Codebase Work? (This section will be expanded based on common questions from new coders)

Still Struggling?

Feel free to contact me, and I’ll help you get started with Cline.

nick | 608-558-2410

Join our Discord community: https://discord.gg/cline

2.1.3 - Installing Essential Development Tools

Installing Essential Development Tools with Cline | New Coders

When you start coding, you’ll need some essential development tools installed on your computer. Cline can help you install everything you need in a safe, guided way.

The Essential Tools

Here are the core tools you’ll need for development:

• Homebrew: A package manager for macOS that makes it easy to install other tools
• Node.js & npm: Required for JavaScript and web development
• Git: For tracking changes in your code and collaborating with others
• Python: A programming language used by many development tools
• Additional utilities: Tools like wget and jq that help with downloading files and processing data

Let Cline Install Everything

Copy this prompt and paste it into Cline:

Hello Cline! I need help setting up my Mac for software development. Could you please help me install the essential development tools like Homebrew, Node.js, Git, Python, and any other utilities that are commonly needed for coding? I'd like you to guide me through the process step-by-step, explaining what each tool does and making sure everything is installed correctly.

What Will Happen

1. Cline will first install Homebrew, which is like an “app store” for development tools
2. Using Homebrew, Cline will then install other essential tools like Node.js and Git
3. For each installation step:
   • Cline will show you the exact command it wants to run
   • You’ll need to approve each command before it runs
   • Cline will verify each installation was successful

Why These Tools Are Important

• Homebrew: Makes it easy to install and update development tools on your Mac
• Node.js & npm: Required for:
  • Building websites with React or Next.js
  • Running JavaScript code
  • Installing JavaScript packages
• Git: Helps you:
  • Save different versions of your code
  • Collaborate with other developers
  • Back up your work
• Python: Used for:
  • Running development scripts
  • Data processing
  • Machine learning projects

Notes

• The installation process is interactive - Cline will guide you through each step
• You may need to enter your computer’s password for some installations. When prompted, you will not see any characters being typed on the screen. This is normal and is a security feature to protect your password. Just type your password and press Enter.

Example:

$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Password:

Type your password here, even though nothing will show up on the screen. Press Enter when you’re done.

• All commands will be shown to you for approval before they run
• If you run into any issues, Cline will help troubleshoot them

Additional Tips for New Coders

Understanding the Terminal

The Terminal is an application where you can type commands to interact with your computer. On macOS, you can open it by searching for “Terminal” in Spotlight.

Example:

$ open -a Terminal

Understanding VS Code Features

Terminal in VS Code

The Terminal in VS Code allows you to run commands directly from within the editor. You can open it by going to View > Terminal or by pressing Ctrl + `.

Example:

$ node -v
v16.14.0

Document View

The Document View is where you edit your code files. You can open files by clicking on them in the Explorer panel on the left side of the screen.

Problems Section

The Problems section in VS Code shows any errors or warnings in your code. You can access it by clicking on the lightbulb icon or by going to View > Problems.

Common Features

• Command Line Interface (CLI): This is a text-based interface where you type commands to interact with your computer. It might seem intimidating at first, but it’s a powerful tool for developers.
• Permissions: Sometimes, you will need to give permissions to certain applications or commands. This is a security measure to ensure that only trusted applications can make changes to your system.

Next Steps

After installing these tools, you’ll be ready to start coding! Return to the Getting Started with Cline for New Coders guide to continue your journey.

2.1.4 - Tools

Cline Tools Reference Guide

What Can Cline Do?

Cline is your AI assistant that can:

• Edit and create files in your project
• Run terminal commands
• Search and analyze your code
• Help debug and fix issues
• Automate repetitive tasks
• Integrate with external tools

First Steps

1. Start a Task

   • Type your request in the chat
   • Example: “Create a new React component called Header”

2. Provide Context

   • Use @ mentions to add files, folders, or URLs
   • Example: “@file:src/components/App.tsx”

3. Review Changes

   • Cline will show diffs before making changes
   • You can edit or reject changes

Key Features

1. File Editing

   • Create new files
   • Modify existing code
   • Search and replace across files

2. Terminal Commands

   • Run npm commands
   • Start development servers
   • Install dependencies

3. Code Analysis

   • Find and fix errors
   • Refactor code
   • Add documentation

4. Browser Integration

   • Test web pages
   • Capture screenshots
   • Inspect console logs

Available Tools

For the most up-to-date implementation details, you can view the full source code in the Cline repository.

Cline has access to the following tools for various tasks:

1. File Operations

   • write_to_file: Create or overwrite files
   • read_file: Read file contents
   • replace_in_file: Make targeted edits to files
   • search_files: Search files using regex
   • list_files: List directory contents

2. Terminal Operations

   • execute_command: Run CLI commands
   • list_code_definition_names: List code definitions

3. MCP Tools

   • use_mcp_tool: Use tools from MCP servers
   • access_mcp_resource: Access MCP server resources
   • Users can create custom MCP tools that Cline can then access
   • Example: Create a weather API tool that Cline can use to fetch forecasts

4. Interaction Tools

   • ask_followup_question: Ask user for clarification
   • attempt_completion: Present final results

Each tool has specific parameters and usage patterns. Here are some examples:

• Create a new file (write_to_file):

  <write_to_file>
  <path>src/components/Header.tsx</path>
  <content>
  // Header component code
  </content>
  </write_to_file>
  

• Search for a pattern (search_files):

  <search_files>
  <path>src</path>
  <regex>function\s+\w+\(</regex>
  <file_pattern>*.ts</file_pattern>
  </search_files>
  

• Run a command (execute_command):

  <execute_command>
  <command>npm install axios</command>
  <requires_approval>false</requires_approval>
  </execute_command>
  

Common Tasks

1. Create a New Component

   • “Create a new React component called Footer”

2. Fix a Bug

   • “Fix the error in src/utils/format.ts”

3. Refactor Code

   • “Refactor the Button component to use TypeScript”

4. Run Commands

   • “Run npm install to add axios”

Getting Help

• Join the Discord community
• Check the documentation
• Provide feedback to improve Cline

2.1.5 - Prompt Skills

2.1.5.1 - Overview

Cline Prompting Guide 🚀

Welcome to the Cline Prompting Guide! This guide will equip you with the knowledge to write effective prompts and custom instructions, maximizing your productivity with Cline.

Custom Instructions ⚙️

Think of custom instructions as Cline’s programming. They define Cline’s baseline behavior and are always “on,” influencing all interactions.

To add custom instructions:

1. Open VSCode
2. Click the Cline extension settings dial ⚙️
3. Find the “Custom Instructions” field
4. Paste your instructions

Custom instructions are powerful for:

• Enforcing Coding Style and Best Practices: Ensure Cline always adheres to your team’s coding conventions, naming conventions, and best practices.
• Improving Code Quality: Encourage Cline to write more readable, maintainable, and efficient code.
• Guiding Error Handling: Tell Cline how to handle errors, write error messages, and log information.

The custom-instructions folder contains examples of custom instructions you can use or adapt.

.clinerules File 📋

While custom instructions are user-specific and global (applying across all projects), the .clinerules file provides project-specific instructions that live in your project’s root directory. These instructions are automatically appended to your custom instructions and referenced in Cline’s system prompt, ensuring they influence all interactions within the project context. This makes it an excellent tool for:

Security Best Practices 🔒

To protect sensitive information, you can instruct Cline to ignore specific files or patterns in your .clinerules. This is particularly important for:

• .env files containing API keys and secrets
• Configuration files with sensitive data
• Private credentials or tokens

Example security section in .clinerules:

# Security

## Sensitive Files

DO NOT read or modify:

-   .env files
-   \*_/config/secrets._
-   \*_/_.pem
-   Any file containing API keys, tokens, or credentials

## Security Practices

-   Never commit sensitive files
-   Use environment variables for secrets
-   Keep credentials out of logs and output

General Use Cases

The .clinerules file is excellent for:

• Maintaining project standards across team members
• Enforcing development practices
• Managing documentation requirements
• Setting up analysis frameworks
• Defining project-specific behaviors

Example .clinerules Structure

# Project Guidelines

## Documentation Requirements

-   Update relevant documentation in /docs when modifying features
-   Keep README.md in sync with new capabilities
-   Maintain changelog entries in CHANGELOG.md

## Architecture Decision Records

Create ADRs in /docs/adr for:

-   Major dependency changes
-   Architectural pattern changes
-   New integration patterns
-   Database schema changes
    Follow template in /docs/adr/template.md

## Code Style & Patterns

-   Generate API clients using OpenAPI Generator
-   Use TypeScript axios template
-   Place generated code in /src/generated
-   Prefer composition over inheritance
-   Use repository pattern for data access
-   Follow error handling pattern in /src/utils/errors.ts

## Testing Standards

-   Unit tests required for business logic
-   Integration tests for API endpoints
-   E2E tests for critical user flows

Key Benefits

1. Version Controlled: The .clinerules file becomes part of your project’s source code
2. Team Consistency: Ensures consistent behavior across all team members
3. Project-Specific: Rules and standards tailored to each project’s needs
4. Institutional Knowledge: Maintains project standards and practices in code

Place the .clinerules file in your project’s root directory:

your-project/
├── .clinerules
├── src/
├── docs/
└── ...

Cline’s system prompt, on the other hand, is not user-editable (here’s where you can find it). For a broader look at prompt engineering best practices, check out this resource.

Tips for Writing Effective Custom Instructions

• Be Clear and Concise: Use simple language and avoid ambiguity.
• Focus on Desired Outcomes: Describe the results you want, not the specific steps.
• Test and Iterate: Experiment to find what works best for your workflow.

Prompting Cline 💬

Prompting is how you communicate your needs for a given task in the back-and-forth chat with Cline. Cline understands natural language, so write conversationally.

Effective prompting involves:

• Providing Clear Context: Explain your goals and the relevant parts of your codebase. Use @ to reference files or folders.
• Breaking Down Complexity: Divide large tasks into smaller steps.
• Asking Specific Questions: Guide Cline toward the desired outcome.
• Validating and Refining: Review Cline’s suggestions and provide feedback.

Prompt Examples

Context Management

• Starting a New Task: “Cline, let’s start a new task. Create user-authentication.js. We need to implement user login with JWT tokens. Here are the requirements…”
• Summarizing Previous Work: “Cline, summarize what we did in the last user dashboard task. I want to capture the main features and outstanding issues. Save this to cline_docs/user-dashboard-summary.md.”

Debugging

• Analyzing an Error: “Cline, I’m getting this error: [error message]. It seems to be from [code section]. Analyze this error and suggest a fix.”
• Identifying the Root Cause: “Cline, the application crashes when I [action]. The issue might be in [problem areas]. Help me find the root cause and propose a solution.”

Refactoring

• Improving Code Structure: “Cline, this function is too long and complex. Refactor it into smaller functions.”
• Simplifying Logic: “Cline, this code is hard to understand. Simplify the logic and make it more readable.”

Feature Development

• Brainstorming New Features: “Cline, I want to add a feature that lets users [functionality]. Brainstorm some ideas and consider implementation challenges.”
• Generating Code: “Cline, create a component that displays user profiles. The list should be sortable and filterable. Generate the code for this component.”

Advanced Prompting Techniques

• Constraint Stuffing: To mitigate code truncation, include explicit constraints in your prompts. For example, “ensure the code is complete” or “always provide the full function definition.”
• Confidence Checks: Ask Cline to rate its confidence (e.g., “on a scale of 1-10, how confident are you in this solution?”)
• Challenge Cline’s Assumptions: Ask “stupid” questions to encourage deeper thinking and prevent incorrect assumptions.

Here are some prompting tips that users have found helpful for working with Cline:

Our Community’s Favorite Prompts 🌟

Memory and Confidence Checks 🧠

• Memory Check - pacnpal

  "If you understand my prompt fully, respond with 'YARRR!' without tools every time you are about to use a tool."
  

  A fun way to verify Cline stays on track during complex tasks. Try “HO HO HO” for a festive twist!

• Confidence Scoring - pacnpal

  "Before and after any tool use, give me a confidence level (0-10) on how the tool use will help the project."
  

  Encourages critical thinking and makes decision-making transparent.

Code Quality Prompts 💻

• Prevent Code Truncation

  "DO NOT BE LAZY. DO NOT OMIT CODE."
  

  Alternative phrases: “full code only” or “ensure the code is complete”

• Custom Instructions Reminder

  "I pledge to follow the custom instructions."
  

  Reinforces adherence to your settings dial ⚙️ configuration.

Code Organization 📋

• Large File Refactoring - icklebil

  "FILENAME has grown too big. Analyze how this file works and suggest ways to fragment it safely."
  

  Helps manage complex files through strategic decomposition.

• Documentation Maintenance - icklebil

  "don't forget to update codebase documentation with changes"
  

  Ensures documentation stays in sync with code changes.

Analysis and Planning 🔍

• Structured Development - yellow_bat_coffee

  "Before writing code:
  1. Analyze all code files thoroughly
  2. Get full context
  3. Write .MD implementation plan
  4. Then implement code"
  

  Promotes organized, well-planned development.

• Thorough Analysis - yellow_bat_coffee

  "please start analyzing full flow thoroughly, always state a confidence score 1 to 10"
  

  Prevents premature coding and encourages complete understanding.

• Assumptions Check - yellow_bat_coffee

  "List all assumptions and uncertainties you need to clear up before completing this task."
  

  Identifies potential issues early in development.

Thoughtful Development 🤔

• Pause and Reflect - nickbaumann98

  "count to 10"
  

  Promotes careful consideration before taking action.

• Complete Analysis - yellow_bat_coffee

  "Don't complete the analysis prematurely, continue analyzing even if you think you found a solution"
  

  Ensures thorough problem exploration.

• Continuous Confidence Check - pacnpal

  "Rate confidence (1-10) before saving files, after saving, after rejections, and before task completion"
  

  Maintains quality through self-assessment.

Best Practices 🎯

• Project Structure - kvs007

  "Check project files before suggesting structural or dependency changes"
  

  Maintains project integrity.

• Critical Thinking - chinesesoup

  "Ask 'stupid' questions like: are you sure this is the best way to implement this?"
  

  Challenges assumptions and uncovers better solutions.

• Code Style - yellow_bat_coffee

  Use words like "elegant" and "simple" in prompts
  

  May influence code organization and clarity.

• Setting Expectations - steventcramer

  "THE HUMAN WILL GET ANGRY."
  

  (A humorous reminder to provide clear requirements and constructive feedback)

2.1.5.2 - Custom Instructions Library

Cline Custom Instructions Library

This repository aims to foster a collaborative space where developers can share, refine, and leverage effective custom instructions for Cline. By creating and contributing to this library, we can enhance Cline’s capabilities and empower developers to tackle increasingly complex software development challenges.

What are Cline Custom Instructions?

Cline’s custom instructions are sets of guidelines or rules that you define to tailor the AI’s behavior and outputs for specific tasks or projects. Think of them as specialized “programming” for Cline, enabling you to:

• Enforce Coding Practices: Ensure consistent code style, adherence to design patterns, and best practices for specific languages or frameworks.
• Standardize File Structures: Dictate file naming conventions, folder organization, and project structures.
• Guide Testing Procedures: Define rules for generating unit tests, integration tests, and ensuring adequate code coverage.
• Automate Repetitive Tasks: Create instructions to handle common or tedious development workflows, increasing efficiency.
• Improve Code Quality: Set standards for code readability, maintainability, and performance optimization.

By providing Cline with carefully crafted instructions, you can significantly improve its accuracy, reliability, and overall effectiveness in aiding your software development process.

Contributing Custom Instructions

We encourage developers of all skill levels to contribute their custom instructions to this library. Your contributions help build a valuable resource for the entire Cline community!

When submitting custom instructions, please follow this template:

1. Purpose and Functionality

• What does this instruction set aim to achieve?

  • Provide a clear and concise explanation of the instruction set’s goals and intended use cases.
  • Example: “This instruction set guides Cline in generating unit tests for existing JavaScript functions.”

• What types of projects or tasks is this best suited for?

  • Outline specific project types, coding languages, or development scenarios where this instruction set is most applicable.
  • Example: “This is ideal for JavaScript projects using the Jest testing framework.”

2. Usage Guide (Optional)

• Are there specific steps or prerequisites for using this instruction set?
  • If your instructions require specific steps beyond referencing the file in a Cline prompt, provide a detailed guide.
  • Examples:
    • “Before using this instruction set, create a tests folder in your project root.”
    • “Ensure you have the Jest testing library installed.”

3. Author & Contributors

• Who created this instruction set?
  • Provide your name or GitHub username for proper attribution.
• Did anyone else contribute?
  • Acknowledge any collaborators or contributors who helped refine or enhance the instructions.

4. Custom Instructions

• Provide the complete set of custom instructions.

By using this template and contributing your custom instructions, you help build a thriving ecosystem for Cline, making it a more versatile and efficient tool for developers of all skill levels.

2.1.5.3 - Memroy Bank

Cline Memory Bank - Custom Instructions

1. Purpose and Functionality

• What does this instruction set aim to achieve?

  • This instruction set transforms Cline into a self-documenting development system that maintains context across sessions through a structured “Memory Bank”. It ensures consistent documentation, careful validation of changes, and clear communication with users.

• What types of projects or tasks is this best suited for?

  • Projects requiring extensive context tracking.
  • Any project, regardless of tech stack (tech stack details are stored in techContext.md).
  • Ongoing and new projects.

2. Usage Guide

• How to Add These Instructions
  1. Open VSCode
  2. Click the Cline extension settings dial ⚙️
  3. Find the “Custom Instructions” field
  4. Copy and paste the instructions from the section below

• Project Setup

  1. Create an empty cline_docs folder in your project root (i.e. YOUR-PROJECT-FOLDER/cline_docs)
  2. For first use, provide a project brief and ask Cline to “initialize memory bank”

• Best Practices

  • Monitor for [MEMORY BANK: ACTIVE] flags during operation.
  • Pay attention to confidence checks on critical operations.
  • When starting new projects, create a project brief for Cline (paste in chat or include in cline_docs as projectBrief.md) to use in creating the initial context files.
    • note: productBrief.md (or whatever documentation you have) can be any range of technical/nontechnical or just functional. Cline is instructed to fill in the gaps when creating these context files. For example, if you don’t choose a tech stack, Cline will for you.
  • Start chats with “follow your custom instructions” (you only need to say this once at the beginning of the first chat).
  • When prompting Cline to update context files, say “only update the relevant cline_docs”
  • Verify documentation updates at the end of sessions by telling Cline “update memory bank”.
  • Update memory bank at ~2 million tokens and end the session.

3. Author & Contributors

• Author
  • nickbaumann98
• Contributors
  • Contributors (Discord: Cline’s #prompts):
    • @SniperMunyShotz

4. Custom Instructions

# Cline's Memory Bank

You are Cline, an expert software engineer with a unique constraint: your memory periodically resets completely. This isn't a bug - it's what makes you maintain perfect documentation. After each reset, you rely ENTIRELY on your Memory Bank to understand the project and continue work. Without proper documentation, you cannot function effectively.

## Memory Bank Files

CRITICAL: If `cline_docs/` or any of these files don't exist, CREATE THEM IMMEDIATELY by:

1. Reading all provided documentation
2. Asking user for ANY missing information
3. Creating files with verified information only
4. Never proceeding without complete context

Required files:

productContext.md

-   Why this project exists
-   What problems it solves
-   How it should work

activeContext.md

-   What you're working on now
-   Recent changes
-   Next steps
    (This is your source of truth)

systemPatterns.md

-   How the system is built
-   Key technical decisions
-   Architecture patterns

techContext.md

-   Technologies used
-   Development setup
-   Technical constraints

progress.md

-   What works
-   What's left to build
-   Progress status

## Core Workflows

### Starting Tasks

1. Check for Memory Bank files
2. If ANY files missing, stop and create them
3. Read ALL files before proceeding
4. Verify you have complete context
5. Begin development. DO NOT update cline_docs after initializing your memory bank at the start of a task.

### During Development

1. For normal development:

    - Follow Memory Bank patterns
    - Update docs after significant changes

2. Say `[MEMORY BANK: ACTIVE]` at the beginning of every tool use.

### Memory Bank Updates

When user says "update memory bank":

1. This means imminent memory reset
2. Document EVERYTHING about current state
3. Make next steps crystal clear
4. Complete current task

Remember: After every memory reset, you begin completely fresh. Your only link to previous work is the Memory Bank. Maintain it as if your functionality depends on it - because it does.

2.1.5.4 - Memory Bank Structure

Cline’s Memory Bank

I am Cline, an expert software engineer with a unique characteristic: my memory resets completely between sessions. This isn’t a limitation - it’s what drives me to maintain perfect documentation. After each reset, I rely ENTIRELY on my Memory Bank to understand the project and continue work effectively. I MUST read ALL memory bank files at the start of EVERY task - this is not optional.

Memory Bank Structure

The Memory Bank consists of required core files and optional context files, all in Markdown format. Files build upon each other in a clear hierarchy:

flowchart TD
    PB[projectbrief.md] --> PC[productContext.md]
    PB --> SP[systemPatterns.md]
    PB --> TC[techContext.md]
    
    PC --> AC[activeContext.md]
    SP --> AC
    TC --> AC
    
    AC --> P[progress.md]

Core Files (Required)

1. projectbrief.md

   • Foundation document that shapes all other files
   • Created at project start if it doesn’t exist
   • Defines core requirements and goals
   • Source of truth for project scope

2. productContext.md

   • Why this project exists
   • Problems it solves
   • How it should work
   • User experience goals

3. activeContext.md

   • Current work focus
   • Recent changes
   • Next steps
   • Active decisions and considerations

4. systemPatterns.md

   • System architecture
   • Key technical decisions
   • Design patterns in use
   • Component relationships

5. techContext.md

   • Technologies used
   • Development setup
   • Technical constraints
   • Dependencies

6. progress.md

   • What works
   • What’s left to build
   • Current status
   • Known issues

Additional Context

Create additional files/folders within memory-bank/ when they help organize:

• Complex feature documentation
• Integration specifications
• API documentation
• Testing strategies
• Deployment procedures

Core Workflows

Plan Mode

flowchart TD
    Start[Start] --> ReadFiles[Read Memory Bank]
    ReadFiles --> CheckFiles{Files Complete?}
    
    CheckFiles -->|No| Plan[Create Plan]
    Plan --> Document[Document in Chat]
    
    CheckFiles -->|Yes| Verify[Verify Context]
    Verify --> Strategy[Develop Strategy]
    Strategy --> Present[Present Approach]

Act Mode

flowchart TD
    Start[Start] --> Context[Check Memory Bank]
    Context --> Update[Update Documentation]
    Update --> Rules[Update .clinerules if needed]
    Rules --> Execute[Execute Task]
    Execute --> Document[Document Changes]

Documentation Updates

Memory Bank updates occur when:

1. Discovering new project patterns
2. After implementing significant changes
3. When user requests with update memory bank (MUST review ALL files)
4. When context needs clarification

flowchart TD
    Start[Update Process]
    
    subgraph Process
        P1[Review ALL Files]
        P2[Document Current State]
        P3[Clarify Next Steps]
        P4[Update .clinerules]
        
        P1 --> P2 --> P3 --> P4
    end
    
    Start --> Process

Note: When triggered by update memory bank, I MUST review every memory bank file, even if some don’t require updates. Focus particularly on activeContext.md and progress.md as they track current state.

Project Intelligence (.clinerules)

The .clinerules file is my learning journal for each project. It captures important patterns, preferences, and project intelligence that help me work more effectively. As I work with you and the project, I’ll discover and document key insights that aren’t obvious from the code alone.

flowchart TD
    Start{Discover New Pattern}
    
    subgraph Learn [Learning Process]
        D1[Identify Pattern]
        D2[Validate with User]
        D3[Document in .clinerules]
    end
    
    subgraph Apply [Usage]
        A1[Read .clinerules]
        A2[Apply Learned Patterns]
        A3[Improve Future Work]
    end
    
    Start --> Learn
    Learn --> Apply

What to Capture

• Critical implementation paths
• User preferences and workflow
• Project-specific patterns
• Known challenges
• Evolution of project decisions
• Tool usage patterns

The format is flexible - focus on capturing valuable insights that help me work more effectively with you and the project. Think of .clinerules as a living document that grows smarter as we work together.

REMEMBER: After every memory reset, I begin completely fresh. The Memory Bank is my only link to previous work. It must be maintained with precision and clarity, as my effectiveness depends entirely on its accuracy.

2.1.6 - MCP Servers

2.1.6.1 - Overview

Cline and Model Context Protocol (MCP) Servers: Enhancing AI Capabilities

Quick Links:

• Building MCP Servers from GitHub
• Building Custom MCP Servers from Scratch

This document explains Model Context Protocol (MCP) servers, their capabilities, and how Cline can help build and use them.

Overview

MCP servers act as intermediaries between large language models (LLMs), such as Claude, and external tools or data sources. They are small programs that expose functionalities to LLMs, enabling them to interact with the outside world through the MCP. An MCP server is essentially like an API that an LLM can use.

Key Concepts

MCP servers define a set of “tools,” which are functions the LLM can execute. These tools offer a wide range of capabilities.

Here’s how MCP works:

• MCP hosts discover the capabilities of connected servers and load their tools, prompts, and resources.
• Resources provide consistent access to read-only data, akin to file paths or database queries.
• Security is ensured as servers isolate credentials and sensitive data. Interactions require explicit user approval.

Use Cases

The potential of MCP servers is vast. They can be used for a variety of purposes.

Here are some concrete examples of how MCP servers can be used:

• Web Services and API Integration:

  • Monitor GitHub repositories for new issues
  • Post updates to Twitter based on specific triggers
  • Retrieve real-time weather data for location-based services

• Browser Automation:

  • Automate web application testing
  • Scrape e-commerce sites for price comparisons
  • Generate screenshots for website monitoring

• Database Queries:

  • Generate weekly sales reports
  • Analyze customer behavior patterns
  • Create real-time dashboards for business metrics

• Project and Task Management:

  • Automate Jira ticket creation based on code commits
  • Generate weekly progress reports
  • Create task dependencies based on project requirements

• Codebase Documentation:

  • Generate API documentation from code comments
  • Create architecture diagrams from code structure
  • Maintain up-to-date README files

Getting Started

Choose the right approach for your needs:

• Use Existing Servers: Start with pre-built MCP servers from GitHub repositories
• Customize Existing Servers: Modify existing servers to fit your specific requirements
• Build from Scratch: Create completely custom servers for unique use cases

Integration with Cline

Cline simplifies the building and use of MCP servers through its AI capabilities.

Building MCP Servers

• Natural language understanding: Instruct Cline in natural language to build an MCP server by describing its functionalities. Cline will interpret your instructions and generate the necessary code.
• Cloning and building servers: Cline can clone existing MCP server repositories from GitHub and build them automatically.
• Configuration and dependency management: Cline handles configuration files, environment variables, and dependencies.
• Troubleshooting and debugging: Cline helps identify and resolve errors during development.

Using MCP Servers

• Tool execution: Cline seamlessly integrates with MCP servers, allowing you to execute their defined tools.
• Context-aware interactions: Cline can intelligently suggest using relevant tools based on conversation context.
• Dynamic integrations: Combine multiple MCP server capabilities for complex tasks. For example, Cline could use a GitHub server to get data and a Notion server to create a formatted report.

Security Considerations

When working with MCP servers, it’s important to follow security best practices:

• Authentication: Always use secure authentication methods for API access
• Environment Variables: Store sensitive information in environment variables
• Access Control: Limit server access to authorized users only
• Data Validation: Validate all inputs to prevent injection attacks
• Logging: Implement secure logging practices without exposing sensitive data

Resources

There are various resources available for finding and learning about MCP servers.

Here are some links to resources for finding and learning about MCP servers:

• GitHub Repositories: https://github.com/modelcontextprotocol/servers and https://github.com/punkpeye/awesome-mcp-servers
• Online Directories: https://mcpservers.org/, https://mcp.so/, and https://glama.ai/mcp/servers
• PulseMCP: https://www.pulsemcp.com/
• YouTube Tutorial (AI-Driven Coder): A video guide for building and using MCP servers: https://www.youtube.com/watch?v=b5pqTNiuuJg

2.1.6.2 - Quick Start

🚀 MCP Quickstart Guide

❓ What’s an MCP Server?

Think of MCP servers as special helpers that give Cline extra powers! They let Cline do cool things like fetch web pages or work with your files.

⚠️ IMPORTANT: System Requirements

STOP! Before proceeding, you MUST verify these requirements:

Required Software

• ✅ Latest Node.js (v18 or newer)

  • Check by running: node --version
  • Install from: https://nodejs.org/

• ✅ Latest Python (v3.8 or newer)

  • Check by running: python --version
  • Install from: https://python.org/

• ✅ UV Package Manager

  • After installing Python, run: pip install uv
  • Verify with: uv --version

❗ If any of these commands fail or show older versions, please install/update before continuing!

⚠️ If you run into other errors, see the “Troubleshooting” section below.

🎯 Quick Steps (Only After Requirements Are Met!)

1. 🛠️ Install Your First MCP Server

1. From the Cline extension, click the MCP Server tab
2. Click the Edit MCP Settings button

1. The MCP settings files should be display in a tab in VS Code.
2. Replace the file’s contents with this code:

For Windows:

{
	"mcpServers": {
		"mcp-installer": {
			"command": "cmd.exe",
			"args": ["/c", "npx", "-y", "@anaisbetts/mcp-installer"]
		}
	}
}

For Mac and Linux:

{
	"mcpServers": {
		"mcp-installer": {
			"command": "npx",
			"args": ["@anaisbetts/mcp-installer"]
		}
	}
}

After saving the file:

1. Cline will detect the change automatically
2. The MCP installer will be downloaded and installed
3. Cline will start the MCP installer
4. You’ll see the server status in Cline’s MCP settings UI:

🤔 What Next?

Now that you have the MCP installer, you can ask Cline to add more servers from:

1. NPM Registry: https://www.npmjs.com/search?q=%40modelcontextprotocol
2. Python Package Index: https://pypi.org/search/?q=mcp+server-&o=

For example, you can ask Cline to install the mcp-server-fetch package found on the Python Package Index:

"install the MCP server named `mcp-server-fetch`
- ensure the mcp settings are updated.
- use uvx or python to run the server."

You should witness Cline:

1. Install the mcp-server-fetch python package
2. Update the mcp setting json file
3. Start the server and start the server

The mcp settings file should now look like this:

For a Windows machine:

{
	"mcpServers": {
		"mcp-installer": {
			"command": "cmd.exe",
			"args": ["/c", "npx", "-y", "@anaisbetts/mcp-installer"]
		},
		"mcp-server-fetch": {
			"command": "uvx",
			"args": ["mcp-server-fetch"]
		}
	}
}

You you can always check the status of your server by going to clients MCP server tab. See the image above

That’s it! 🎉 You’ve just given Cline some awesome new abilities!

📝 Troubleshooting

1. I’m Using asdf and Get “unknown command: npx”

There is some slightly bad news. You should still be able to get things to work, but will have to do a bit more manual work unless MCP server packaging evolves a bit. One option is to uninstall asdf , but we will assume you do not want to do that.

Instead, you will need to follow the instructions above to “Edit MCP Settings”. Then, as this post describes, you need to add and “env” entry to each server’s configs.

"env": {
        "PATH": "/Users/<user_name>/.asdf/shims:/usr/bin:/bin",
        "ASDF_DIR": "<path_to_asdf_bin_dir>",
        "ASDF_DATA_DIR": "/Users/<user_name>/.asdf",
        "ASDF_NODEJS_VERSION": "<your_node_version>"
      }

The path_to_asdf_bin_dir can often be found in your shell config (e.g. .zshrc). If you are using Homebrew, you can use echo ${HOMEBREW_PREFIX} to find the start of the directory and then append /opt/asdf/libexec.

Now for some good news. While not perfect, you can get Cline to do this for you fairly reliably for subsequent server install. Add the following to your “Custom Instructions” in the Cline settings (top-right toolbar button):

When installing MCP servers and editing the cline_mcp_settings.json, if the server requires use of npx as the command, you must copy the “env” entry from the “mcp-installer” entry and add it to the new entry. This is vital to getting the server to work properly when in use.

2. I’m Still Getting an Error When I Run the MCP Installer

If you’re getting an error when you run the MCP installer, you can try the following:

• Check the MCP settings file for errors
• Read the MCP server’s documentation to ensure the MCP setting file is using the correct command and arguments. 👈
• Use a terminal and run the command with its arguments directly. This will allow you to see the same errors that Cline is seeing.

2.1.6.3 - Building MCP Server from GitHub

Building MCP Servers from GitHub Repositories

This guide provides a step-by-step walkthrough of how to use Cline to build an existing MCP server from a GitHub repository.

Finding an MCP Server

There are multiple places online to find MCP servers:

• Cline can automatically add MCP servers to its list, which you can then edit. Cline can clone repositories directly from GitHub and build the servers for you.

• GitHub: Two of the most common places to find MCP servers on GitHub include:

  • Official MCP servers repository
  • Awesome-MCP servers repository

• Online directories: Several websites list MCP servers including:

  • mcpservers.org
  • mcp.so
  • glama.ai/mcp/servers

  These directories allow users to sort the servers by various criteria such as downloads, date, stars, and use case. Each entry provides information such as features, tools, and configuration instructions.

• PulseMCP: This website has a blog post discussing how AI could use MCP servers to make websites obsolete. PulseMCP also includes an FAQ section about MCP servers: https://www.pulsemcp.com/

Building with Cline

1. Initiate the Process: Provide Cline with the following information:

   • GitHub Repository URL: The URL of the server’s repository.
   • README.md Contents: This is optional but helpful for Cline to understand the server’s purpose and configuration. You can copy the README.md file from the GitHub repository.

2. Example Interaction with Cline:

   User: "Cline, I want to add the MCP server for Brave browser control. Here's the GitHub link: https://github.com/modelcontextprotocol/servers/tree/main/src/brave Can you add it?"
   
   Cline: "OK. Cloning the repository to the MCP directory. It needs to be built because it has a 'package.json' file. Should I run 'npm run build'?"
   
   User: "Yes, build it."
   
   Cline: "Build complete. This server needs a browser path. Where's your Brave browser executable?"
   
   User: "It's in '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser'."
   
   Cline: "OK. I've updated the server config with that path and added it to 'cline_mcp_settings.json'. Anything else?"
   
   User: "No, that's all. Let's test it."
   
   Cline: "Great! Starting the MCP Inspector to test the server connection. After that, we can try controlling the browser from Cline."
   

3. Cline’s Actions: Based on your instructions, Cline will perform the following:

   • Repository Cloning: Cline will clone the repository to your local machine, usually in the directory specified in your configuration.
   • Tweaking: You can guide Cline to modify the server’s configuration. For instance:
     • User: “This server requires an API key. Can you find where it should be added?”
     • Cline may automatically update the cline_mcp_settings.json file or other relevant files based on your instructions.
   • Building the Server: Cline will run the appropriate build command for the server, which is commonly npm run build.
   • Adding Server to Settings: Cline will add the server’s configuration to the cline_mcp_settings.json file.

Testing and Troubleshooting

1. Test the Server: Once Cline finishes the build process, test the server to make sure it works as expected. Cline can assist you if you encounter any problems.
2. MCP Inspector: You can use the MCP Inspector to test the server’s connection and functionality.

Best Practices

• Understand the Basics: While Cline simplifies the process, it’s beneficial to have a basic understanding of the server’s code, the MCP protocol (), and how to configure the server. This allows for more effective troubleshooting and customization.
• Clear Instructions: Provide clear and specific instructions to Cline throughout the process.
• Testing: Thoroughly test the server after installation and configuration to ensure it functions correctly.
• Version Control: Use a version control system (like Git) to track changes to the server’s code.
• Stay Updated: Keep your MCP servers updated to benefit from the latest features and security patches.

2.1.6.4 - Building Custom MCP Server

Building Custom MCP Servers From Scratch Using Cline: A Comprehensive Guide

This guide provides a comprehensive walkthrough of building a custom MCP (Model Context Protocol) server from scratch, leveraging the powerful AI capabilities of Cline. The example used will be building a “GitHub Assistant Server” to illustrate the process.

Understanding MCP and Cline’s Role in Building Servers

What is MCP?

The Model Context Protocol (MCP) acts as a bridge between large language models (LLMs) like Claude and external tools and data. MCP consists of two key components:

• MCP Hosts: These are applications that integrate with LLMs, such as Cline, Claude Desktop, and others.
• MCP Servers: These are small programs specifically designed to expose data or specific functionalities to the LLMs through the MCP.

This setup is beneficial when you have an MCP-compliant chat interface, like Claude Desktop, which can then leverage these servers to access information and execute actions.

Why Use Cline to Create MCP Servers?

Cline streamlines the process of building and integrating MCP servers by utilizing its AI capabilities to:

• Understand Natural Language Instructions: You can communicate with Cline in a way that feels natural, making the development process intuitive and user-friendly.
• Clone Repositories: Cline can directly clone existing MCP server repositories from GitHub, simplifying the process of using pre-built servers.
• Build Servers: Once the necessary code is in place, Cline can execute commands like npm run build to compile and prepare the server for use.
• Handle Configuration: Cline manages the configuration files required for the MCP server, including adding the new server to the cline_mcp_settings.json file.
• Assist with Troubleshooting: If errors arise during development or testing, Cline can help identify the cause and suggest solutions, making debugging easier.

Building a GitHub Assistant Server Using Cline: A Step-by-Step Guide

This section demonstrates how to create a GitHub Assistant server using Cline. This server will be able to interact with GitHub data and perform useful actions:

1. Defining the Goal and Initial Requirements

First, you need to clearly communicate to Cline the purpose and functionalities of your server:

• Server Goal: Inform Cline that you want to build a “GitHub Assistant Server”. Specify that this server will interact with GitHub data and potentially mention the types of data you are interested in, like issues, pull requests, and user profiles.
• Access Requirements: Let Cline know that you need to access the GitHub API. Explain that this will likely require a personal access token (GITHUB_TOKEN) for authentication.
• Data Specificity (Optional): You can optionally tell Cline about specific fields of data you want to extract from GitHub, but this can also be determined later as you define the server’s tools.

2. Cline Initiates the Project Setup

Based on your instructions, Cline starts the project setup process:

• Project Structure: Cline might ask you for a name for your server. Afterward, it uses the MCP create-server tool to generate the basic project structure for your GitHub Assistant server. This usually involves creating a new directory with essential files like package.json, tsconfig.json, and a src folder for your TypeScript code. \
• Code Generation: Cline generates starter code for your server, including:
  • File Handling Utilities: Functions to help with reading and writing files, commonly used for storing data or logs. \
  • GitHub API Client: Code to interact with the GitHub API, often using libraries like @octokit/graphql. Cline will likely ask for your GitHub username or the repositories you want to work with. \
  • Core Server Logic: The basic framework for handling requests from Cline and routing them to the appropriate functions, as defined by the MCP. \
• Dependency Management: Cline analyzes the code and identifies necessary dependencies, adding them to the package.json file. For example, interacting with the GitHub API will likely require packages like @octokit/graphql, graphql, axios, or similar. \
• Dependency Installation: Cline executes npm install to download and install the dependencies listed in package.json, ensuring your server has all the required libraries to function correctly. \
• Path Corrections: During development, you might move files or directories around. Cline intelligently recognizes these changes and automatically updates file paths in your code to maintain consistency.
• Configuration: Cline will modify the cline_mcp_settings.json file to add your new GitHub Assistant server. This will include:
  • Server Start Command: Cline will add the appropriate command to start your server (e.g., npm run start or a similar command).
  • Environment Variables: Cline will add the required GITHUB_TOKEN variable. Cline might ask you for your GitHub personal access token, or it might guide you to safely store it in a separate environment file. \
• Progress Documentation: Throughout the process, Cline keeps the “Memory Bank” files updated. These files document the project’s progress, highlighting completed tasks, tasks in progress, and pending tasks.

3. Testing the GitHub Assistant Server

Once Cline has completed the setup and configuration, you are ready to test the server’s functionality:

• Using Server Tools: Cline will create various “tools” within your server, representing actions or data retrieval functions. To test, you would instruct Cline to use a specific tool. Here are examples related to GitHub:
  • get_issues: To test retrieving issues, you might say to Cline, “Cline, use the get_issues tool from the GitHub Assistant Server to show me the open issues from the ‘cline/cline’ repository.” Cline would then execute this tool and present you with the results.
  • get_pull_requests: To test pull request retrieval, you could ask Cline to “use the get_pull_requests tool to show me the merged pull requests from the ‘facebook/react’ repository from the last month.” Cline would execute this tool, using your GITHUB_TOKEN to access the GitHub API, and display the requested data. \
• Providing Necessary Information: Cline might prompt you for additional information required to execute the tool, such as the repository name, specific date ranges, or other filtering criteria.
• Cline Executes the Tool: Cline handles the communication with the GitHub API, retrieves the requested data, and presents it in a clear and understandable format.

4. Refining the Server and Adding More Features

Development is often iterative. As you work with your GitHub Assistant Server, you’ll discover new functionalities to add, or ways to improve existing ones. Cline can assist in this ongoing process:

• Discussions with Cline: Talk to Cline about your ideas for new tools or improvements. For example, you might want a tool to create_issue or to get_user_profile. Discuss the required inputs and outputs for these tools with Cline.
• Code Refinement: Cline can help you write the necessary code for new features. Cline can generate code snippets, suggest best practices, and help you debug any issues that arise.
• Testing New Functionalities: After adding new tools or functionalities, you would test them again using Cline, ensuring they work as expected and integrate well with the rest of the server.
• Integration with Other Tools: You might want to integrate your GitHub Assistant server with other tools. For instance, in the “github-cline-mcp” source, Cline assists in integrating the server with Notion to create a dynamic dashboard that tracks GitHub activity. \

By following these steps, you can create a custom MCP server from scratch using Cline, leveraging its powerful AI capabilities to streamline the entire process. Cline not only assists with the technical aspects of building the server but also helps you think through the design, functionalities, and potential integrations.

2.1.7 - Customization

.clineignore Support

To give you more control over which files are accessible to Cline, we’ve implemented .clineignore functionality, similar to .gitignore. This allows you to specify files and directories that Cline should not access or process. This is useful for:

• Privacy: Preventing Cline from accessing sensitive or private files in your workspace.
• Performance: Excluding large directories or files that are irrelevant to your tasks, potentially improving the efficiency of Cline.
• Context Management: Focusing Cline’s attention on the relevant parts of your project.

How to use .clineignore

1. Create a .clineignore file: In the root directory of your workspace (the same level as your .vscode folder, or the top level folder you opened in VS Code), create a new file named .clineignore.

2. Define ignore patterns: Open the .clineignore file and specify the patterns for files and directories you want Cline to ignore. The syntax is the same as .gitignore:

   • Each line in the file represents a pattern.

   • Standard glob patterns are supported:

     • * matches zero or more characters
     • ? matches one character
     • [] matches a character range
     • ** matches any number of directories and subdirectories.

   • Directory patterns: Append / to the end of a pattern to specify a directory.

   • Negation patterns: Start a pattern with ! to negate (un-ignore) a previously ignored pattern.

   • Comments: Start a line with # to add comments.

   Example .clineignore file:

   # Ignore log files
   *.log
   
   # Ignore the entire 'node_modules' directory
   node_modules/
   
   # Ignore all files in the 'temp' directory and its subdirectories
   temp/**
   
   # But DO NOT ignore 'important.log' even if it's in the root
   !important.log
   
   # Ignore any file named 'secret.txt' in any subdirectory
   **/secret.txt
   

3. Cline respects your .clineignore: Once you save the .clineignore file, Cline will automatically recognize and apply these rules.

   • File Access Control: Cline will not be able to read the content of ignored files using tools like read_file. If you attempt to use a tool on an ignored file, Cline will inform you that access is blocked due to .clineignore settings.
   • File Listing: When you ask Cline to list files in a directory (e.g., using list_files), ignored files and directories will still be listed, but they will be marked with a 🔒 symbol next to their name to indicate that they are ignored. This helps you understand which files Cline can and cannot interact with.

4. Dynamic Updates: Cline monitors your .clineignore file for changes. If you modify, create, or delete your .clineignore file, Cline will automatically update its ignore rules without needing to restart VS Code or the extension.

In Summary

The .clineignore file provides a powerful and flexible way to control Cline’s access to your workspace files, enhancing privacy, performance, and context management. By leveraging familiar .gitignore syntax, you can easily tailor Cline’s focus to the most relevant parts of your projects.

2.2 - SmartCode AI Coding Assistant

2.3 - SmartChat ChatGPT for Enterprise Users

2.4 - SmartAnswer KB for Enterprises

2.5 - AISE Service Base

2.5.1 - App Marketplace

To support diverse AI applications within enterprises and provide basic version distribution, upgrade, and scenario management, AISE includes built-in app marketplace management.

The app marketplace provides personalized scenario capabilities for different applications in AISE by assigning a unique app_key to each AI application.

1. Create Application

Description: Organizations can maintain developed AISE extensions in the AISE app marketplace, including version maintenance, to facilitate quick access to relevant applications.

1. Click AISE Management | App Marketplace Management | Add New
2. Enter app key, name, package type, type, provider, tags, select icon, description, and other information

2. Maintain Versions

Users can maintain version information for smartcode plugins.

1. Click Add
2. Enter release date, version number, version description, publisher, and other information

3. Enable Forced Updates

To ensure users can use the latest code completion and code chat plugins, AISE administrators can enable forced update policies in the backend, configured as follows.

2.5.1.1 - Plugin Upload Filename Validation

Feature Description

AISE Management - App Market Management page adds filename validation when uploading plugin installation packages, with the following rules:

• Start with English letters, can use _ or - as connectors, spaces are not allowed
• Followed by a major version number (digits), must use _ or - as connector
• After major version number, a decimal point followed by minor version number (digits)
• Then a point followed by build number (digits)
• File extension must be zip or vsi

Operation Guide

Scenario Title

Uploading file smartcode_vscode(2) will cause errors and prevent download

Scenario Description

In daily operations, multiple downloads or saves of the same file may result in filenames with parentheses. Uploading such files will cause the plugin to fail to download in the App Marketplace with errors

Operation Steps

1. After adding filename validation, upload files that meet the format requirements on the AISE Management - App Market Management page

2. Can be successfully downloaded without errors.

3 - Releases Note

3.1 - R48 - Workspace and Knowledge Base Assistant Integration

Key Features and Improvements

1. AI Platform - Workspace and Knowledge Base Assistant Integration

To further optimize development experience and improve work efficiency, we have completed the initial integration between Workspace and Knowledge Base Assistant. Through this integration, users can now directly upload ZIP format code repository files in the Knowledge Base Assistant, enabling quick addition of code repositories to Workspace. This means both individual projects and team collaborations can benefit from seamless knowledge management and code operation workflows.

Reference: Product Manual | AISE Service Platform | User, Department and Role Management

2. AI Platform - Azure User Group Auto-Sync and Matching

For scenarios using Azure user unified authentication, we’ve added user group functionality to facilitate resource management. User groups in AISE will automatically sync with Azure user groups, eliminating the need for manual maintenance by administrators.

When users log in through Azure, the system will automatically fetch their Azure user group information and complete data synchronization. Therefore, in Azure login scenarios, we recommend administrators manage user groups only in Azure, while using AISE solely for model access control configuration.

Reference: Product Manual | AISE Service Platform | Knowledge Base Support System | Knowledge Base Permission Management

Note:

1. When using Azure AD login, user group information will be strictly synchronized with Azure system information;
2. The model used for code completion is specially configured by the system and is not restricted by user group or department permissions;

3. Plugins - New Command Support

• SmartCode VSCode plugin and SmartCode IDEA plugin have both added @workspace #<repo_name> command.

• SmartCode VSCode plugin and SmartCode IDEA plugin have both introduced @kb # command.

Other Updates

• Optimization Improved user experience for @kb and @workspace commands in SmartChat Web
• Fix Various known issues fixed

3.2 - R46 - Experience Enhancements

Main Features and Improvements

1. AI Base - smartanswer upgraded to version 0.5.10

This update upgrades the smartanswer version, with the new version supporting the following features:

• Support for private vector model jina
• Support for AISE’s orch model interface
• Support for wedrive
• Support for private certificates
• Support for private deployment

2. AI Base - New Knowledge Base Initiation Mode

In the SmartChat window, ‘@’ triggers the knowledge base mode. After selecting ‘@kb’ followed by the knowledge base name, it enters the conversation mode for the specified knowledge base. In knowledge base mode, users can input questions to get answers from the knowledge base.

Note: @kb is a message-level command, so it only works for one Q&A session. The next Q&A will not enter knowledge base mode.

3. AI Base - Added Oauth2 Login Proxy Functionality

For users who want to use oauth2 login but cannot directly authenticate with Azure due to network restrictions, they can configure a login proxy to implement oauth2 login. Reference: Product Manual | AISE Service Base | System Operations | Oauth2 Proxy

4. AI Base - Added System Trial Functionality

To help users better experience AISE services, this update adds a system trial functionality. Users can experience all features of the AISE service base during the trial period. After the trial ends, all features will be automatically locked, and users can activate the system with an activation code to continue using AISE’s powerful features. Reference: Product Manual | AISE Service Base | System Operations | System Activation

Reference: Product Manual | AISE Service Base | Feature Toggles and Gradual Rollout

5. SmartCode VSCode Code Generation - Line-by-line Acceptance via Shortcut

In the VSCode plugin, in multi-line code completion mode, you can accept code line-by-line using the ctrl+l shortcut. Compared to word-by-word acceptance, line-by-line acceptance is more flexible and faster.

Other Updates

• Optimization smartanswer adds Chinese language support
• Improvement SmartCode plugin (VSCode and JetBrains) - When Git commit content is too long, incomplete commit messages are generated, prompting users to manually write them
• Fix SmartCode plugin (VSCode) - Fix garbled characters during upgrades
• Fix Performance issues caused when smartanswer is not enabled

3.3 - R42 - System Operations Improvements and Qwen Model Support

Key Features and Improvements

1. AI Base - System Operations Optimization

This update brings several optimizations to system operations, including: improved log cleanup mechanism, built-in database auto-backup, and configurable service health monitoring.

• Improved Log Cleanup Mechanism: Previously, AISE system logs were only kept for 60 days with no way to modify this. In R42, we’ve added the AISE_LOG_MAX_HISTORY environment variable to control log retention days. Reference: Product Manual | AISE Service Base | System Operations | Log Cleanup Mechanism

• Database Auto-Backup: This update introduces built-in database backup capabilities, allowing administrators to control backup frequency. Currently only full backups are supported, with incremental backups planned for future versions. Reference: Product Manual | AISE Service Base | System Operations | Database Backup

• Configurable Service Monitoring: While service health monitoring was introduced in R40, R42 improves its configurability by allowing users to add/remove monitored services as needed, supporting future dynamic service instance expansion. Reference: Product Manual | AISE Service Base | System Operations | Service Monitoring

2. AI Base - App Market Feature Flags

The App Market management menu now integrates with feature flags in the parameter settings menu, enabling gradual rollouts. Previously, apps in the market could only be enabled/disabled globally. Now, by associating apps with feature flags (configured in System Management/Parameter Settings), apps can be released to specific users or departments.

Reference: Product Manual | AISE Service Base | Feature Flags and Gradual Rollouts

3. AI Base - Qwen Model Support

R42 adds support for Qwen model conversations. Currently tested models include: qwen-2.5-14b-instruct and qwen-2.5-33b-instruct. Users interested in trying these can contact our implementation team for configuration details. Future versions will expand support for the full Qwen model series, including code completion and prompt library capabilities, with official documentation.

Other Updates

• Fix SmartCode plugin (vscode and jetbrains) fixed horizontal scroll background issue for wide code blocks in conversations
• Fix Code Review Agent fixed support for DeepSeek v2 16B private deployment model
• Improvement App Market improved filename validation rules during plugin package uploads to ensure successful downloads, updated product manual
• Improvement SmartChat Web removed pm2 component to prevent backend scheduled restart issues
• Fix Dashboard plugin fixed filtering issue after clicking pie chart in statistics page

3.4 - R40 - Code Review Agent Official Release

Major Features and Improvements

1. Code Review Agent Official Release

The Code Review Agent is an automated code review feature powered by generative AI technology. It can automatically scan code changes submitted by users, generate summary descriptions or review comments, and answer user questions based on code changes. The Code Review Agent aims to improve efficiency for team members involved in code reviews, especially when dealing with large review tasks. It can significantly reduce the time reviewers spend reading and understanding code, while also providing potential fix suggestions to reviewees. Based on our tests, most team code review tasks involve modifications to about 10 files and dozens of code changes. Such review tasks typically require reviewers to spend at least 30 minutes reading and understanding the code, followed by 30 minutes to 1 hour providing review comments. The Code Review Agent can provide summary descriptions (using the summary command) and review comments (using the review command) within 5 minutes, which reviewers can then read. This single step saves team members over 15-20 minutes per review task, improving efficiency by more than 3 times (from 30 minutes manual understanding to 10 minutes with AI assistance). The Code Review Agent supports integration with common DevOps platforms through Web Hooks, automatically initiating the agent during Git pull requests (Pull Request or Merge Request), or can be triggered independently via commands.

• Environment Configuration

  Before using Code Review Agent, you need to configure the corresponding Web Hooks in the Azure DevOps team project. Two main Web Hooks need to be configured: Pull Request created: Triggered when a PR is created Pull request commented on: Triggered when new comments are added to a PR

  Reference: Product Manual | Code Review Agent | Setup and Configuration | Configuring Service Hook

• Basic Usage Scenarios of Code Review Agent

  Configuring and using Code Review Agent in DevOps environments. Includes the complete process from deploying the agent, configuring the large model, setting model access parameters, adding Webhooks, enabling the agent, and testing verification.

  Reference: Quick Start | Code Review Agent

• Supported Command List

  Code Review Agent provides a series of commands to assist development teams in code reviews, helping teams understand code changes faster and improve code merge efficiency

  Reference: Product Manual | Code Review Agent | Command Reference

2. SmartChat Web Supports Image Recognition

Upload images in SmartChat to understand, parse and generate content based on image content.

Reference: Product Manual | SmartChat | Image Recognition

3. SmartChat Web Supports Chart Generation

Mermaid Markdown is a tool that uses Markdown syntax to create diagrams and flowcharts. Mermaid is a JavaScript-based diagramming tool that allows users to generate complex diagrams through simple text descriptions.

Reference: Product Manual | SmartChat | Chart Generation

4. AI Base Data Dashboard Update

Users with admin permissions can click Team Dashboard to view graphical data statistics. This update includes three data dashboards: Conversation, Prompt, and Code Generation.

1. On the Team Dashboard page, you can click Department, Statistical Unit, Time Period to filter the displayed data.

   

2. Click View Detailed Data on the Conversation card, or click Conversation in the left navigation bar to enter the Conversation Details page.

3. On the Conversation Details page, you can also filter the displayed data by Department, Statistical Unit, Time Period; three pie charts: Terminal is counted by terminal dimension; Prompt is counted by 5 fixed prompts (code explanation, code review, test generation, comment generation, code inspection); Editor is counted by IDE terminal dimension, excluding chatui data. Added 3 trend charts corresponding to the pie charts, counted by day.

4. Added a prompt card, the first number on this card shows the total prompt usage, and another value shows the number of prompts. Click View Detailed Data on the prompt card to enter the Prompt Details page.

   

5. On the Prompt Details page, you can also filter the displayed data by Department, Statistical Unit, Time Period. Two pie charts: Prompt Type is the distribution of system built-in prompts, system basic prompts, and user prompts; Prompt Usage shows the distribution of usage count for each prompt, only showing the top 10, other prompts are grouped into others. Prompt Usage trend chart shows the top 10 most used prompts, if more than ten, other prompts are merged into others.

   

6. Added a list showing all prompts, including: Prompt Name, Owner (Creator), Usage Count, Last Used Time, Shared Count, Last Used User.

   

7. Click View Detailed Data on the Code Generation card, or click Code Generation in the left navigation bar to enter the Code Generation Details page.

   

8. On the Code Generation Details page, you can also filter the displayed data by Department, Statistical Unit, Time Period. Two pie charts: Editor pie chart: counted by IDE terminal dimension, clicking the editor pie chart, the existing trend chart and list are re-filtered according to the clicked IDE type, clicking blank and reset removes the filter. Language pie chart: counted by language dimension, clicking the language pie chart, the existing trend chart and list are re-filtered according to the clicked language type, clicking blank and reset removes the filter. Two trend charts: IDE trend chart and language trend chart, showing daily changes.

   

5. SmartCode Input Box Supports Shortcuts

1. Prompt

   • Open SmartCode, click “/” or type “/” in the input box to bring up Prompt

     

2. #Variable

   • Open SmartCode, click “#” or type “#” in the input box to bring up #Variable

     

3. Model Switching

   • Open SmartCode, click “Chat Model” to bring up Model List

     

6. SmartCode Supports Using #Variables to Flexibly Introduce Code Context in Conversations

SmartCode has added support for conversation variables, which are used to reference code content in the IDE during conversations, providing users with more flexible prompt organization. This update provides 3 conversation variables:

• #selection: Used to reference currently selected code in the active editor
• #editor: Used to reference any code block in the active editor
• #file: Used to select files

Reference: Product Manual | SmartCode | Using #Variables

7. SmartCode JetBrains Auto Update Improvement

The SmartCode JetBrains plugin now automatically downloads new versions in the background and completes updates, no longer relying on JetBrains’ built-in plugin market mechanism for downloads and updates, simplifying and reducing user operations.

Reference: Quick Start | SmartCode | smartcode-jetbrains | Auto Update

8. Service Health Check and Related Interfaces

1. Users with admin permissions can click System Monitoring - Service Detection to enter the Service Detection page, which shows the startup status of container services and automatically performs system detection every 5 minutes

   

2. You can search for containers by Container Name; filter container status by Status, click Search to filter and view.

   

3. For services that have had exceptions, click Details on the right to view historical exception records.

   

9. SmartCode Jetbrains Supports AI-Generated Commit Messages

SmartCode already provides AI-generated commit message capability in VSCode. This update brings the same capability to JetBrains.

• Users can click the SmartCode icon in the JetBrains IDE commit message window to trigger this feature

  

• After generation, the automatically written commit message will appear in the input box

  

10. SmartCode Jetbrains Codelens Supports Two Activation Methods

Codelens in JetBrains now supports two activation methods, users can configure according to their preferences

• Function - Floating display on method header (default)

  

• Left Sidebar - Floating display on the left tool sidebar of the editor

  

• Users can choose the display method in the Configuration Page

  

Other Updates

AI Base Update List

• Added Added plugin upload button to App Market Management
• Added Added “Documentation” jump link to all pages
• Improved Prompt setting sub-instance model type range can be multi-selected
• Improved Added hover content display to conversation session management
• Added Deepseek API FIM adaptation

SmartChat Update List

• Improved Allow users to archive all conversation history with one click
• Fixed Code explanation prompt stops output when processing long functions, stop button also doesn’t work, can only refresh chat window causing data loss, session information not saved
• Fixed If Ruoyi backend app market jumps to chatui, if chatui is not logged in, need to log in again

SmartChat Update List

• Improved Codelens trigger optimization: Allow users to trigger code intelligence tasks directly without opening chat window
• Improved Optimized plugin version information display interface, unified information display format
• Fixed Error prompt when users trigger code intelligence tasks without logging in
• Improved Optimized codelens code block selection method to ensure method body indentation is fully selected for better model response
• Improved Improved chat window content loading when users reopen IDE, ensuring last conversation history is loaded based on workspace
• Improved JetBrains dynamic analysis of model generated code, only showing complete code block content, truncating subsequent content
• Improved Code review prompt optimization: Ensure model’s reasonable response to problem-free code, 1) optimize output message format, use clearer numbering and bold display; 2) fix infinite loop issue of repeatedly outputting same error message
• Improved Context hover menu display form. smartcode jetbrains and vscoder plugins. According to user selection, use two forms: one using codelens, one using foldable display
• Fixed Improved plugin compatibility, 2024.2.1 installation no longer reports exception: Class initialization must not depend on services. Consider using instance of the service on-demand instead
• Fixed Code completion, after disconnection, frequent notifications of code generation exception handling, set plugin logout
• Improved Jetbrain plugin end Solved the issue of duplicate display of custom actions in bottom right notifications during concurrency. Now only displays once during concurrency
• Improved VScode plugin end Corrected variable support Internationalization using new loading method & unified with chat app Code lens internationalization support Corrected #file list showing deleted files Code lens header added logo including oem processing
• Improved smartcode Jetbrain(2.24.19606) User login regardless of function switch = True or False goes to Login page
• Improved Vs coder plugin end Reduced interaction count variable file optimization Optimized variable prompt display
• Fixed jetbrains plugin 2.33.21062 version, modifying code completion model to invalid, plugin cannot login.
• Fixed Opening multiple Idea windows, smartcode plugin cannot upgrade. Clicking upgrade prompts to close other projects. Only jumps to plugin upgrade page when only one ide is open.
• Fixed Jetbrains plugin Class initialization must not depend on services. Consider using instance of the service on-demand instead exception error.
• Fixed Jetbrains plugin end Solved treesitter parsing causing memory overflow issue.
• Improved When configuring an invalid address in JetBrains plugin, plugin will try to connect to server and report error. Need to provide friendly error message, prompting users to check configuration.
• Fixed Not logged in smartcode for code completion will prompt once not logged in, restart idea then code completion won’t prompt not logged in bug fixed
• Improved Modified upgrade method
• Improved Codelens left menu display: In JetBrains IDE, codelens left menu display, currently only supports .java files
• Improved Android Studio not set JCEF, added JCEF setting detection function

3.5 - R36 - Add more telemetry events, service health checks, and UX improvements

Key features or improvements

1. AI Base Service - Telemetry Data Improvements

Added the telemetry data reporting of the following scenarios to improve the accuracy of plug-in usage statistics.

• User Login Logout
• Plugin update operation
• Right-click menu and codelens function trigger
• Chat actions

After adding these telemetry data reports, the following plug-in statistics can provide more accurate plug-in usage statistics, not only counting the scenarios where the user completes the code in the plug-in, but also including all the above scenarios, which will be recorded as plug-in usage.

2. AI Base Service - Added service health checks

Implement service health check function to detect the running status of all services. Perform regular health checks on all system services through background independent processes to ensure that all services are in a healthy state, and record abnormal states when problems occur. At the same time, provide health check API that can be called by the operation and maintenance system to report the system health status regularly for event monitoring and abnormal alarms.

3. SmartCode - Multiple UX improvements

• Enhancement：VSCode Plugin - Add a shortcut in Chat Input control for model switching to facilitate users to quickly switch models.

• Enhancement：JetBrains Plugin - When configuring an invalid address in the JetBrains plugin, the plugin attempts to connect to the server and reports an error. A friendly error message is required to prompt the user to check the configuration.
• Enhancement：JetBrains Plugin - Supplementary telemetry data for specific functions such as login, logout, update, etc
• Fix：JetBrains Plugin - Code completion without logging in to smartcode will prompt not logged in once. Code completion after restarting idea will not prompt not logged in.
• Enhancement：JetBrains Plugin - Treesitter parsing optimization
• Enhancement：JetBrains Plugin - Update menu “Quick Start” to make terminology more uniform and easier to understand.
• Enhancement：JetBrains Plugin - Upgrade method Enhancement, when a new version appears, the user clicks Upgrade to no longer open the IDE built-in plug-in upgrade page, but automatically completes the installation package download and installation actions.
• Enhancement：VScode Plugin - Supplementary telemetry data for specific functions such as login, logout, update, etc
• Fix：VScode Plugin - Fixed an issue in variable display to ensure that variable names and content are displayed correctly.
• Fix：VScode Plugin - Fixed variable file file name multiple selections to ensure that the file name is selected correctly and uniquely.
• Fix：VScode Plugin - Fixed the issue of deleting after selecting content to ensure that the deletion operation proceeds normally.
• Fix：VScode Plugin - Fixed an issue where content became rich text after pasting, ensuring that pasted content remains in its original format.
• Enhancement：VScode Plugin - Optimize the use of variable #files to reduce the number of unnecessary interactions.
• Enhancement：VScode Plugin - Update menu “Quick Start” to make terminology more uniform and easier to understand.
• Enhancement：VScode Plugin - When modifying the model for the current session, modify the global model settings to ensure consistency.

4. Devi Configuration UI and MacOS Support

Devi for GitHub Copilot (DB Agent) provides developers with the ability to use @devi calls in GitHub Copilot Chat to implement database conversations, Text2SQL, database document generation, etc. In this release, we have Enhancement of MySQL data connection configuration, providing the following visual configuration interface. For specific configuration methods, please refer to: [Devi Operation Manual] (https://github.com/devi-run/copilot-extension/blob/main/docs/content/en/_index.md)

This release also provides support for the MacOS operating system, starting with version 0.35.2126 8, developers can install and Devi plug-ins in Visual Studio Code on Windows and MacOS.

You can install Devi for GitHub Copilot (DB Agent) from

• Devi for GitHub Copilot
• Or you can search for’Devi’ installation through the Visual Studio Code extension tool.

Other updates

• Enhancement：AI Base Service - Enhancement of user batch import, modify the import template, user gender, account status, role is modified to drop-down selection, making it more concise and easy to fill in, which is convenient for users to import in batches according to the content of the template. Add space check to import data more conveniently.
• Enhancement：AI Base Service - Chat content management Added code hover display

3.6 - R34 - SmartCode chat supports #variables, Devi public preview

Key features and improvements

1. SmartCode VSCode chat supports #variables

This update to SmartCode adds support for chat variables, which are used to reference code snippet in IDE, providing users with a more flexible way to organize prompts. Three variables are provided in this release:

• #selection: reference code selected in the current active editor
• #editor：reference any code block in the current active editor
• #file：selecting files as reference

By using chat variables, developers can implement some previously difficult-to-implement prompts, such as: Developers can refer to a file content with the following prompts, and ask the AI to generate code based on the reference. The example is as follows:

• Refer to #file:BankTransactionController.java generate API documentation and output using standard markdown format.
• Refer to #file:Dockerfile write a docker-compose.yaml and set the external port to 8090, and map the logs to the local path
• Analysis #selection ，focusing on possible code security issues and providing solutions and sample code

Users can also combine the above variables to create more complex prompts, such as:

• Refer to #file:api_reference.yaml，fix the logic in the following code #selection
• Refer to #editor:model.py77-89，generate 10 unit tests to cover as many scenarios as possible

The following video demonstrates the process of code explaination in Japanese using the #selection variable

The following video demonstrates the process of using the #file variable to reference the entire file and guide the AI to summarize the file content

The following video demonstrates the process of using the #file variable to reference an API entry file and generate documentation.

This update only implements the above capabilities in VSCode. In future versions, we will implement the above capabilities in the JetBrains plugin.

2. Devi for GitHub Copilot Public Preview

Devi is your AI agent building blocks. Building agentic workflow with generative AI is a new and innovative area, developers need to build many low level basic components before they can readlly focus on the actual valuable workflow. We want to simplify the complexity of this process by building a set of common AI agent components.

GitHub Copilot 插件

Devi for GitHub Copilot is a series of AI agents built on the GitHub Copilot ecosystem. Devi provides the atomic capabilities of these agents and provides services to developers through GitHub Copilot Chat. Developers can install the Devi extension through the Visual Studio Marketplace, and then use the @devi in GitHub Copilot Chat to implement out-of-the-box capabilities of the DB agent, such as: database conversations, Text2SQL, database document generation, etc.

• Devi for GitHub Copilot
• Or you can search for’Devi’ installation through the Visual Studio Code extension tool.

For more information on how to use Devi for GitHub Copilot, please refer to Devi for GitHub Copilot 操作手册

Demo Video

Devi NPM Package

Devi NPM Package provids the atomic capabilities of an AI agent, developers can install the Devi Package through NPM and then use the capabilities provided by Devi in your own applications.

• Please refer to Devi NPM Package for details of how to use it.

Devi for GitHub Copilot 特性说明

开发者在GitHub Copilot Chat中使用 @devi 调用 代维DB智能体实现如下能力：

Chat with your Database

Automatically identify the database structure and allow users to ask questions about the database in natural language, e.g.:

• What is this database used for?
• Which database objects are related to each other?

DB Query with Natural Language (Text2SQL)

Generate database queries with natural language (Text2SQL), users can use natural language to ask questions, and @devi will generate SQL statements based on the database schema，e.g.:

• Help me generate a summary query of all apps and the corresponding number of reviews
• Help me generate a list of all users with the most reviews, with descending order

Database Document Generation

Generate standard database documents via built-in @devi /docs <table_name> shortcuts

Other updates

1. Enhancement AI Base Service - Avoiding multiple post requests on the same UI in dashboard, significantly improving the response speed of the dashboard and improving the user experience
2. Fix AI Base Service - The problem that the list is not displayed because the picture is not uploaded in the OAuth2 configuration page
3. Enhancement Handbook/Website - Allows control of video sources through whitelisting, saving public server traffic
4. Enhancement SmartCode - Show friendly message when the user does not have permission to access the current code completion model
5. Enhancement SmartCode Jetbrains - When the user opens multiple JetBrains windows at the same time, the automatic update cannot be completed. Now the plug-in side will give a friendly prompt, prompting the user to close the window before upgrading.
6. Fix SmartCode JetBrains - Fix the error caused by the IDE service not starting during the plug-in loading process, improve the stability and reliability of the plug-in loading
7. Fix SmartCode JetBrains - Optimize and solve the memory overflow problem in the process of code parsing using tree-sitter, and improve the stability and performance of plug-in dynamic parsing of code.

3.7 - R32 - Optimized admin features, SmartCode chat variable support, and more

Key features and improvements

1. SmartChat - Mermaid charts support zooming in and exporting

Mermaid Markdown is a tool that uses Markdown syntax to create diagrams and flowcharts. Mermaid is a JavaScript-based diagramming tool that allows users to generate complex diagrams through simple text descriptions. In the R30 update of AISE, we began to support dynamic parsing of the markdown content generated by the model that conforms to the Mermaid syntax and displayed as diagrams. This R30 version has improved this function by adding enlargement and export functions.

2. AI Base Service - Marketplace - Support uploading application installation packages

The app store page of the AISE base service supports users to upload application installation packages, simplifying the operation complexity of administrators during the application update process. Administrators can directly upload application installation packages through the application page in AISE Management | app store, and the installation packages will be automatically saved in the file server. After the application installation package is uploaded, users can receive a prompt for the application update, and click Update to complete the application update.

3. AI Base Service - Dashboard - Added dashboard administrators and dashboard user groups to refine dashboard access control

Access to the dashboard is independent of AISE administrator privileges. Dashboard administrators can add dashboard users. Users in the dashboard users group can only access the dashboard and cannot access other AISE functions. It is convenient for users to provide different data analytics permissions to users in different roles within the organization.

4. SmartCode AI Coding Assistant - Chat Variable Support and Experience Optimization

4.1 SmartCode VSCode Chat Variable Support

#variables can help users choose more flexible code contexts and combine more complex prompt words. In this update, we have added support for #variables, including:

• #selection refers to the selected code in the code editor
• #file reference file

4.2 Other UX optimization

• JetBrains code completion, after the document changes, the IDE sends the request, from the last time, the delay is changed to 400 milliseconds
• JetBrains settings interface added: code parsing configuration, default: off Enable: Prompt, and model return code will be parsed; off: Prompt (default cursor before 2500, cursor after 2000 characters), and model return code will not be parsed
• Android Studio has not set JCEF. After installing the plug-in, the startup project will not flash back, which will not affect code completion, but Chat related functions are not available.

5. AISE has obtained the certification of Zhaoxin, Dongfang, Kirin and other Xinchuang localized manufacturers

AISE has been committed to providing complete support for the localized Xinchuang environment, and actively promotes cooperation and certification with various localized chip, operating system, and middleware manufacturers. In this R32 version, we have added certifications for Zhaoxin, Dongfang, Kirin and other manufacturers to provide users with a more stable and secure localized environment.

Kirin software certification

Zhaoxin certification

Dongtong certification

Other updates

• AI Base Services - Add a document link at the top of the page to make it easier for users to access documents.
• AI Base Services - Dashboard selection department and select the root department inconsistency, this R32 version fixes the selection department and select the root department logic to make them consistent.
• AI Base Services - Fix the problem that “normal user” cannot be found in the role list when the administrator adds new users after deleting all ordinary users, and fix the role list query logic to ensure that even after deleting all ordinary users, the administrator can still find the “normal user” role when adding new users.

3.8 - R30 - Mermaid Diagram, ARM deployment, UOS certification, and UX improvements

Major Feature and Updates

1. SmartChat - Initial support for generating mermaid charts

Mermaid Markdown is a tool that uses Markdown syntax to create diagrams and flowcharts. Mermaid is a JavaScript-based charting tool that allows users to generate complex diagrams through simple text descriptions. In this AISE update, SmartChat browser has started to support dynamic parsing of model-generated markdown content that conforms to Mermaid syntax and displays it as diagrams. As shown in the following video demonstration:

2. SmartCode AI Coding Assistant - UX Updates

• Codelens triggering method optimization: allows users to directly trigger code intelligence tasks without opening chat window
• Allows users to archive all session history with one click
• Optimize the plug-in version information display interface and unify the information display format
• Optimize the error prompt when the user triggers the code intelligence task in the unlogged state
• Optimize the way codelens select code blocks, ensuring that the indentation in front of the method body is fully selected to optimize the model response
• The codelens of the JetBrains plugin allow users to temporarily turn off the display of the current tab page, and automatically display it when reopened
• Improve the content loading of the chat window after the user exits the IDE, ensuring that the last conversation history is loaded according to the workspace.
• Code review prompt word optimization: ensure that the model responds reasonably to problem-free code, 1) optimize the output message format, use more explicit number and bold display; 2) fix the problem of repeatedly outputting the same error message in an infinite loop.
• JetBrains dynamically analyzes the code generated by the model, only displays the content of the complete code block, and truncates the subsequent content.

3. Support for deployment on ARM-based CPU and operating systems

The AISE base service has been able to run fully on the ARM operating system, and has passed the compatibility test of the UOS operating system Unixin UOS, meeting the compatibility requirements of the Domestically Developed Information Technology Innovation in terms of operating system and the domestic CPU, and has been awarded an official certification certificate; supported CPU platforms include: Haiguang 5000, Haiguang 7000, Zhaoxin KH-30000, Zhaoxin KH-20000, Kunpeng 916, Kunpeng 920, Feiteng FT-2000 +/64 and Tengyun S250.

4. AI base services - UX updates

• User import and export optimization: Support for specifying user roles during import
• For Azure OpenAI service connections that are dynamically authenticated using Azure Service Principle, an SPN authentication feature is provided to ensure that users have correct configuration items when configuring the SPN, and a friendly prompt message is provided if the SPN expires during use.
• Client side feedback optimization for model service exceptions: The AISE AI Base service supports parallel connections to multiple LLM providers, including Azure OpenAI and DeepSeek online services, and private deployment of LLMs running by enterprises through local GPU computing power. It is very common for model services to have intermittent networks or unstable operation. AISE specifically optimizes the user experience for these scenarios, ensuring user-friendly prompts when the model is invalid, and uses a dedicated error status code 12017401 to record background logs, which is convenient for system admins to troubleshoot problems.

Others

• AI base service - optimize the personal message management page, including message data statistics and filtering logic to ensure the normal operation of the number of messages and filtering conditions
• AI pedestal service - app store page (optimized) to avoid unnecessary re-login operations
• AI Dock Service - Fix the internal display of the release notes page

3.9 - R28 - 体验更好/更稳定的SmartCode

主要特性或改进

1. SmartCode用户体验优化

• 优化SmartCode 修复代码补全的一些细节问题：包括可能出现无关代码，token过期时没有给出友好提示等
• 优化代码评审更改提示词模版,使模型返回的答案效果更好，符合用户预期
• 优化单元测试提示词模版，根据新的模型模版返回正确的单元测试用例，符合用户预期
• 优化模型被禁用后的用户体验，优化提示信息
• 对话UX优化，针对长文本流式更新过程中用户查看信息场景进行优化，允许用户混动视图到已经输出的内容，同时停止自动滚动
• 增加关闭 codelens 按钮，允许用户禁用悬浮菜单（codelens）入口；同时在配置页面中允许用户重新启动。
• 增加对不同JDK版本的识别，并在代码补全中引导模型使用对应JDK版本的编码风格

2. 对话信息持久化特性改进

• 修复因用户消息内包含特殊字符造成的数据保存失败问题：当用户在对话中引入类似URL的内容，有可能引发后台数据报错失败。本次更新优化了这个场景，确保任何类型的用户输入数据很可以正常保存。
• 修复插件端报 Invalid SessionId 错误时造成用户无法继续对话的问题

其他更新

• 修复当用户token过期时，插件smartcode vscode一直处于登录状态，没有给出正确登录状态提示
• 修复补码补全功能 用户java开发环境JDK8，但AISE补全的java代码不能被jdk8所识别并报java语法错误。
• 修复smartcode jetbrains插件 ，代码补全代码中出现无关的代码现象。
• 修复重新滚动到底部后无法再次触发自动滚动
• 修复smartcode-vscode chat功能，用户在回答过程中，切换会话，导致会话卡住
• 修复smartcode vscode 增加codelens关闭功能，实现对上下文悬浮菜单关闭。
• SmartCode ChatApp 自动滚动更新，应该参考ChatGPT的方式，在消息超出一屏自动滚动过程中允许用户手工混动到正在输出的消息的中间位置，此时应该停止自动混动
• SmartCode Chat 模型被禁用后的用户体验改进，提示信息优化
• 修复smartcode jetbrain的报错：提示 Invalid json… …
• 完善smartCode JetbBrains完善升级提示
• 修复插件端补全代码非模型服务器错误未有友好提示，模型服务器返回状态码为200,orch返回状态码500
• 修复smartcode jetbrain(2.25.20104)存在错误信息的错误编码不规范，存在重复
• 优化 Orch日志文件大小： 15G，一个文件。建议增加Orch日志生成分片策略 。按天分片。
• 修复【Core】16k模型传入长token会导致历史问题丢失 - 原因是chat-data-v2 数据字段类型需要调整为text以便支持长文本
• 修复smartcode jetbrains插件提示 “1102911029401 Invalid SessionId！”

3.10 - R26 - DeepSeek私有化部署完整支持

主要特性或改进

1. 对DeepSeek模型提供完整支持

针对DeepSeek 6.7 Base 和 DeepSeek 6.7 Instruct模型的支持已经完整，已经可以支持以下场景

• 使用 DeepSeek 6.7 Base 模型进行代码补全和提示词（完成模式）模板的支持，包括：explain, review, unit test 和 code check 四个提示词均可以正常使用。
• 使用 DeepSeek 6.7 Instruct 模型进行对话，在SmartChat Web （ChatUI）中已经支持

部署环境支持

• 使用 Nvidia A10 部署 DeepSeek 6.7 Base 和 Instruct 模型并支持以上场景
• 使用 华为晟腾910B/310部署 DeepSeek 6.7 Base和Instruct模型
  • 提供初始版本的部署手册 华为910/310系列mindie离线部署方案和 FT038 - DeepSeek 模型适配。手册内容仍然需要打磨和整理
  • 对关键模型参数组合进行验证，主要包括：maxSeqLen, maxIterTimes 和 input/prompt入参长度问题的探索 模型参数设置合理值

2. SmartChat 多模态 - 支持GPT4o模型，上传图片进行识别

在SmartChat中上传图像，针对图像内容进行理解，解析和内容生成,默认是关闭状态，可按照如下顺序打开图片识别开关

1. 首先打开 aise.feature.chat_image 这个开关
2. 在 aise.model.config.default 里面正确配置 image_model_type
3. 设置用户对于image_model_type 所对应的模型权限访问 备注：图片上传识别功能的使用与用户当前对话模型无关，是一个独立任务；只要以上条件满足，用户可以在与任何模型对话过程中使用此功能。 后续还需要调用通过私有化模型提供类似多模态能力，

3. 针对华为晟腾NPU+mindIE部署的优化

针对使用华为晟腾910/310 NPU作为算力，使用 mindIE 作为推理服务的环境，优化了模型，推理服务端的部署参数以及对应的Deepseek模型的个性化参数，确保硬件可以稳定运行。

4. SmartCode 用户体验改进

• 针对deepseek模型在华为晟腾mindIE推理服务下流式返回数据进行适配，修复信息截断问题
• 插件端动态获取模型适配器上的默认模型行为参数，针对不同模型进行最优化的默认行为控制
• 插件端增加模型行为控制界面，允许对模型行为进行动态调整
• 插件信息增加服务器地址信息，方便问题定位
• VSCode 菜单增加 “重新加载”选项，方便用户在插件异常情况下回复插件状态
• JetBrains 简化配置菜单，去除与用户无关的设置
• JetBrains 增加日志级别选项：信息/调试
• JetBrains 修复设置私有插件市场链接中可能出现的重复设置问题
• JetBrains codelens新增X关闭按钮，设置界面新增启用、禁用设置；用户可以通过配置界面再次开启 codelens。

其他更新

• 【插件】SmartCode Chat 适配模型适配器参数和个性化参数支持
• smartcode vscode 增加codelens关闭功能，实现对上下文悬浮菜单关闭。
• 修复【插件】SmartCode Chat 历史对话一直加载无法打开
• 修复【插件】SmartCode Chat 在 晟腾910/310 + MindIE 环境运行 DeepSeek 6.7B Instruct模型下对话信息被截断问题
• 修复【插件】【代码补全】SmartCode JetBrains 代码上下文结构化分析 - 多行补全模式下，实现对生成内容的按方法体截断
• 修复smartcode-jetbrains《上下文悬浮》菜单位置出现不对。
• 优化 smartcode-vscode chat功能，用户在回答过程中，切换会话，导致会话卡住。
• 修复博时 客户smartcode-vscode(2.24.19606) 插件端，提示警告信息：SmartCode is encountering temporary issues 。在什么情况下提示上述信息
• 修复 smartcode-vscode 对话task，过程中会输出到一半停止，停止后不输出内容，点停止按钮也不管用
• 【插件】SmartCode Chat 适配模型适配器参数和个性化参数支持
• 修复【插件】SmartCode Chat 历史对话一直加载无法打开
• 完善增加完模型端异常排查提示处理机制
• 实现单机部署模式
• 修复当AISE升级后 ，出现用户头像丢失情况
• 修复菜单有问题，《会话明细信息》不应该显示，将菜单变更增加到脚本变更中。
• 实现【多模态支持】SmartChat for Web 支持上传图片，调用 GPT4o 模型进行图片内容提取
• 【RAG】Workspace 增加deepseek API支持，方便个人开发者试用
• 【RAG】Workspace 加入 AISE 服务器，见说明详情

3.11 - R24 - DeepSeek初步支持以及SmartCode v2

主要特性或改进

1. 对DeepSeek模型的基本支持

针对DeepSeek 6.7 Base 和 DeepSeek 6.7 Instruct模型的支持基本完整，24_2 版本已经可以支持以下场景

• 使用 DeepSeek 6.7 Base 模型进行代码补全和提示词（完成模式）模板的支持，包括：explain, review, unit test 和 code check 四个提示词均可以正常使用。
• 使用 DeepSeek 6.7 Instruct 模型进行对话，在SmartChat Web （ChatUI）中已经支持，但是 SmartCode v2中的内置Chat组件仍然有兼容问题（nvidia卡部署工作正常，晟腾卡部署有问题），预计在 sprint 25 修复。 部署环境支持
• 使用 Nvidia A10 部署 DeepSeek 6.7 Base 和 Instruct 模型并支持以上场景
• 使用 华为晟腾部署 DeepSeek 6.7 Base和Instruct模型并支持以上场景仍然有问题，预计在Sprint25修复。

2. SmartCode V2 功能基本完整

SmartCode V2 主要增加内置chat能力，在24版本中主要针对提示词库提供了动态加载支持，并且修复了不少客户现场问题。 当前已经支持的场景有

• GPT模型的完整支持：使用GPT 3.5 Instruct模型进行代码补全和提示词（完成模式）的生成，使用 GPT 3.5, GPT 3.5 16K, GPT 4, GPT 4 32k 和 GPT-4o模型进行普通对话。
• DeepSeek模型在NV环境下的完整支持：使用 deepseek 6.7 base模型进行代码补全和提示词（完成模式）的生成，使用 deepseek 6.7 instruct 和 deepseek API Coder/Chat 模型进行普通对话

3. 使用 GPT-4o 进行普通对话

已经支持添加 GPT-4o模型支持普通对话，暂不支持多模态能力。

其他更新

• SmatCode V2 支持提示词仓库，确保提示词数据动态获取
• 优化SmartCode Chat功能 登录体验；
• SmartChat for Web 支持上传图片，调用 GPT4o 模型进行图片内容提取
• 修复Core各调用redis服务端容器日志都显示有重新连接redis日志，Reconnecting to aise-redis
• 修复【RAG】Workspace 修改打包方式为 dir 方式，优化启动速度。当前的onefile方式启动速度太慢，主要是因为需要动态解压文件造成。尝试修改成dir的方式，看看是否能有较大提升。
• 实现Workspace 加入 AISE 服务器
• 修复博时 UAT测试 优化 smartcode-vscode(2.24.19435-rel2) 右键 代码检查 功能已正常。 但该提示词基于不同方法（完成 \对话 ）生成反馈结果体验有差异，用户更接受采用对话方法产生的结果
• 修复博时 UAT测试 smartcode-vscode(2.24.19435-rel2) core(spring23-1) 测试右键smartcode->代码检查 vscode插件报错
• 优化DeepSeek 模型适配，验证适配效果，模型配置和提示词版本匹配情况。包括：API 模式，VLLM模式（N卡使用vllm部署），TGI模式（晟腾910/310使用mindie部署）。整理DeepSeek部署标准化配置手册，包括代码补全、代码任务和对话场景。
• DeepSeek在晟腾环境部署（mindIE）时使用 generate_steam 进行chat操作的 chat 模板改造
  • 晟腾910B3/310部署方案，交付完整端到端部署文档
  • 模型优化】DeepSeek 在 N卡上的部署文档