基于大模型 + 知识库的 Code Review 实践

抛砖引玉，作者对大模型 LLMs 认知有限，有不当之处望大家指正！

背景

痛点

• 信息安全合规问题：公司内代码直接调 ChatGPT / Claude 会有安全/合规问题，为了使用 ChatGPT / Claude 需要对代码脱敏，只提供抽象逻辑，这往往更花时间。
• 三星引入ChatGPT不到 20 天，被曝发生3次芯片机密泄露

• 低质量代码耗费时间：业务每天至少 10~20 个 MR 需要 CR，虽然提交时 MR 经过 单测 + Lint 过滤了一些低级错误，但还有些问题（代码合理性、经验、MR 相关业务逻辑等）需要花费大量时间，最后可以先经过自动化 CR，再进行人工 CR，可大大提升 CR 效率！

• 团队 Code Review 规范缺少执行：大部分团队的 Code Review 停留在文档纸面上，成员之间口口相传，并没有一个工具根据规范来严格执行。

介绍

特性

符合公司安全规范，所有代码数据不出内网，所有推理过程均在内网完成

• 🌈 开箱即用：基于 Gitlab CI，仅 10 几行配置完成接入，即可对 MR 进行 CR。

• 🔒 数据安全：基于开源大模型做私有化部署，隔离外网访问，确保代码 CR 过程仅在内网环境下完成。

• ♾ 无调用次数限制：部署在内部平台，只有 GPU 租用成本。

• 📚 自定义知识库：CR 助手基于提供的飞书文档进行学习，将匹配部分作为上下文，结合代码变更进行 CR，这将大大提升 CR 的准确度，也更符合团队自身的 CR 规范。

• 🎯 评论到变更行：CR 助手将结果评论到变更代码行上，通过 Gitlab CI 通知，更及时获取 CR 助手给出的评论。

名词解释

实现思路

流程图

系统架构

LLMs / 开源大模型选型

• 理解代码

• 对中文支持好

• 较强的上下文学习能力

模型后面的 -{n}b 指 n*10 亿参数量，比如 13b 就是 130 亿参数，个人试用下来参数量的多少并不能决定效果怎样，根据实际情况来判断。

• chatglm2-6b（默认）

• Llama2-Chinese-13b-Chat

• Baichuan2-13B-Chat

知识库设计

为什么需要知识库？

这里的『强化模式』会使用向量数据库，并将匹配的知识库片段和问题『什么是 Lynx？』生成 Prompt，发送到 LLM 执行。

怎样找到相关度高的知识？

1. Text Embeddings（文本向量化）

2. Vector Stores（向量存储）

3. Similarity Search（相似性搜索）

Text Embeddings（文本向量化）

1. 数据安全问题：需要调用 OpenAI 的 API 才能做向量化

2. 收费：大概 3000页/美元

Vector Stores（向量存储）

数据截止到2023年9月10号

Similarity Search（相似性搜索）

加载知识库

截取完整代码前半段作为 query 输入，是因为大部分语言前半段都声明了 modules、packages，通过这种方式提高知识库相似匹配度。

官方文档-知识库（内置）

自定义知识库-飞书文档（自定义）

飞书文档没有格式要求，能看懂正确代码是怎样就行

• chunk_size: 控制每个块的长度。例如设置为 1024，则每个块包含 1024 个字符。

• chunk_overlap: 控制相邻两个块之间的重叠长度。例如设置为 128，则每个块会与相邻块重叠 128 个字符。

Prompt 指令设计

代码 summary 总结指令

prefix = "user: " if model == "chatglm2" else "<s>Human: "
suffix = "assistant(用中文): let's think step by step." if model == "chatglm2" else "\\n</s><s>Assistant(用中文): let's think step by step."

return f"""{prefix}根据这段 {language} 代码，列出关于这段 {language} 代码用到的工具库、模块包。
{language} 代码:
```{language}
{source_code}
```
请注意：
- 知识列表中的每一项都不要有类似或者重复的内容
- 列出的内容要和代码密切相关
- 最少列出 3 个, 最多不要超过 6 个
- 知识列表中的每一项要具体
- 列出列表，不要对工具库、模块做解释
- 输出中文
{suffix}"""

• language：当前文件的代码语言（TypeScript、Python、Rust、Golang 等）

• source_code：是当前变更文件的完整代码

CR 指令

# llama2
f"""Human: please briefly review the {language}code changes by learning the provided context to do a brief code review feedback and suggestions. if any bug risk and improvement suggestion are welcome(no more than six)
<context>
{context}
</context>

<code_changes>
{diff_code}
</code_changes>\\n</s><s>Assistant: """

# chatglm2
f"""user: 【指令】请根据所提供的上下文信息来简要审查{language} 变更代码，进行简短的代码审查和建议，变更代码有任何 bug 缺陷和改进建议请指出（不超过 6 条）。
【已知信息】：{context}

【变更代码】：{diff_code}

assistant: """

• language：当前文件的代码语言（TypeScript、Python、Rust、Golang 等）

• context：根据知识库返回的上下文信息

• diff_code：是变更的代码（不使用完整代码主要是考虑 LLM max\_tokens 最大限制）

评论到变更代码行

import re


def parse_diff(input):
    if not input:
        return []
    if not isinstance(input, str) or re.match(r"^\s+$", input):
        return []

    lines = input.split("\n")
    if not lines:
        return []

    result = []
    current_file = None
    current_chunk = None
    deleted_line_counter = 0
    added_line_counter = 0
    current_file_changes = None

    def normal(line):
        nonlocal deleted_line_counter, added_line_counter
        current_chunk["changes"].append({
            "type": "normal",
            "normal": True,
            "ln1": deleted_line_counter,
            "ln2": added_line_counter,
            "content": line
        })
        deleted_line_counter += 1
        added_line_counter += 1
        current_file_changes["old_lines"] -= 1
        current_file_changes["new_lines"] -= 1

    def start(line):
        nonlocal current_file, result
        current_file = {
            "chunks": [],
            "deletions": 0,
            "additions": 0
        }
        result.append(current_file)

    def to_num_of_lines(number):
        return int(number) if number else 1

    def chunk(line, match):
        nonlocal current_file, current_chunk, deleted_line_counter, added_line_counter, current_file_changes
        if not current_file:
            start(line)
        old_start, old_num_lines, new_start, new_num_lines = match.group(1), match.group(2), match.group(
            3), match.group(4)

        deleted_line_counter = int(old_start)
        added_line_counter = int(new_start)
        current_chunk = {
            "content": line,
            "changes": [],
            "old_start": int(old_start),
            "old_lines": to_num_of_lines(old_num_lines),
            "new_start": int(new_start),
            "new_lines": to_num_of_lines(new_num_lines),
        }
        current_file_changes = {
            "old_lines": to_num_of_lines(old_num_lines),
            "new_lines": to_num_of_lines(new_num_lines),
        }
        current_file["chunks"].append(current_chunk)

    def delete(line):
        nonlocal deleted_line_counter
        if not current_chunk:
            return

        current_chunk["changes"].append({
            "type": "del",
            "del": True,
            "ln": deleted_line_counter,
            "content": line
        })
        deleted_line_counter += 1
        current_file["deletions"] += 1
        current_file_changes["old_lines"] -= 1

    def add(line):
        nonlocal added_line_counter
        if not current_chunk:
            return
        current_chunk["changes"].append({
            "type": "add",
            "add": True,
            "ln": added_line_counter,
            "content": line
        })
        added_line_counter += 1
        current_file["additions"] += 1
        current_file_changes["new_lines"] -= 1

    def eof(line):
        if not current_chunk:
            return
        most_recent_change = current_chunk["changes"][-1]
        current_chunk["changes"].append({
            "type": most_recent_change["type"],
            most_recent_change["type"]: True,
            "ln1": most_recent_change["ln1"],
            "ln2": most_recent_change["ln2"],
            "ln": most_recent_change["ln"],
            "content": line
        })

    header_patterns = [
        (re.compile(r"^@@\s+-(\d+),?(\d+)?\s+\+(\d+),?(\d+)?\s@@"), chunk)
    ]

    content_patterns = [
        (re.compile(r"^\\ No newline at end of file$"), eof),
        (re.compile(r"^-"), delete),
        (re.compile(r"^\+"), add),
        (re.compile(r"^\s+"), normal)
    ]

    def parse_content_line(line):
        nonlocal current_file_changes
        for pattern, handler in content_patterns:
            match = re.search(pattern, line)
            if match:
                handler(line)
                break
        if current_file_changes["old_lines"] == 0 and current_file_changes["new_lines"] == 0:
            current_file_changes = None

    def parse_header_line(line):
        for pattern, handler in header_patterns:
            match = re.search(pattern, line)
            if match:
                handler(line, match)
                break

    def parse_line(line):
        if current_file_changes:
            parse_content_line(line)
        else:
            parse_header_line(line)

    for line in lines:
        parse_line(line)

    return result

这里机器人账号调用 Gitlab API 进行的评论，会默认被 Resolved，这样可以避免 CR Copilot 评论过多造成每个评论要手动点下 Resolved

一点感想

• 一切皆概率：基于 LLM 的应用最大特点在于『输出不确定性』，在候选词中选概率最高的进行输出，即使像 1+1=? 这样看起来有确定性输出的，LLM 也是基于概率给出的！

• 开源 LLMs + 领域知识库 + 私有化部署是企业级应用的一种实践方式：
• 这里 LLMs 指多个大模型组合使用；大模型再强大也必须结合内部的知识库才能发挥作用；
• 私有化部署好处是打消各行各业对数据安全的担忧！
• 大模型在 Chat 聊天的产品形态更多是秀肌肉💪，让各行各业能被触达到；最终的产品形态需要具体场景具体分析！

• AI+ 刚刚开始：CR Copilot 只是 LLMs + 研发工程化其中一个应用场景，还有一些应用/工具等团队打磨好后再和大家一起分享！