Building an AI Code Assistant: From Error Logs to Directly Applicable Patches

As an architect deeply dedicated to the implementation of AI applications, I have seen too many independent developers and small teams fall into the "model quagmire" when building AI applications. Everyone wants to build intelligent code assistants and implement "WYSIWYG" automatic bug fixing features, but they often get stuck on the last mile—from "model conversation" to "generating usable code patches."

Today, let's break down a typical scenario: how to build an AI code assistant that can automatically read error logs, locate code, and generate directly applicable patches. We will skip the vague concepts and dive straight into architecture design and implementation details.

1. Business Pain Points: Why Isn't a "Chatbot" a Qualified Code Assistant?

Many developers initially attempt to build a wrapper around a ChatGPT interface: paste the error log and ask the AI how to fix it. This approach feels great during the demo phase, but it faces three fatal pain points in actual engineering implementation:

1. Context Fragmentation: The Large Language Model (LLM) doesn't know your project structure or dependencies. Its suggestions are often "this code looks fine," or it provides an isolated function while forgetting that your project already has specific utility classes defined.
2. Uncontrollable Formatting: You want a standard .diff or .patch file that can be directly applied to a Git repository, but the model often returns a pile of Markdown-wrapped code blocks, mixed with fluff like "Okay, here is the modified code," causing automated scripts to fail parsing.
3. Exploding Maintenance Costs: Independent developers lack time the most. Today you feel GPT-4 is expensive and slow, so you want to switch to Claude 3.5 Sonnet or DeepSeek-V3, only to find that every model's API interface, authentication method, and error code handling differ slightly. Every time you switch models, you have to refactor the backend code.

2. Architecture Design: Building a Stable "Patch Factory"

To solve the above pain points, we need a standardized application architecture. In this architecture, our goal is not just "conversation," but "execution." We divide the architecture into three layers:

1. Perception Layer: Responsible for intelligence gathering. This includes IDE plugins (getting the file where the cursor is currently located, selected code snippets), CI/CD pipelines (getting build logs), and terminal monitoring (getting error stack traces).
2. Orchestration Layer: This is the core brain. Responsible for context assembly, combining error information + relevant code snippets + system prompts into a Prompt.
3. Model Access Layer: Responsible for communicating with the underlying large models.

In this architecture, the most critical strategy is "Isolating Change". Models are iterating rapidly, and Prompt engineering is constantly adjusting; our business logic cannot be held hostage by these two factors.

Why Can a Unified AI API Gateway Reduce Maintenance Costs?

Here, I must emphasize an architectural decision that independent developers often overlook: Introducing a Unified AI API Gateway.

In the early code of small teams, I often see hardcoding like this:

# 糟糕的实践
if model_name == "gpt-4":
    response = openai_client.chat.completions.create(...)
elif model_name == "claude":
    response = anthropic_client.messages.create(...)

Maintaining this kind of code is disastrous. Once a model API upgrades, or if you want to test DeepSeek's new model, you need to modify the core business logic and worry about the differences in sensitivity to System Prompts across different models.

The value of a Unified AI API Gateway lies in "Protocol Unification". It exposes a standard OpenAI-compatible interface externally while shielding the differences of upstream vendors internally.

• Reduced Switching Costs: You only need to change one model parameter name to switch from GPT-4 to DeepSeek without rewriting SDK call code.
• Unified Billing and Monitoring: For small teams, managing bills scattered across various cloud vendors is extremely painful. The gateway aggregates Token consumption, letting you clearly know which feature costs the most.
• High Availability and Disaster Recovery: When a specific model provider goes down (which is not rare), the gateway can be configured for automatic failover, forwarding requests to a backup model, ensuring your code assistant service remains uninterrupted.

3. Key Implementation Steps: From Error to Patch

Next, let's move to the practical part. Let's assume our goal is: a user submits a piece of code with a runtime error, and the system automatically generates a repair patch.

Step 1: Dynamic Context Assembly

Do not throw the entire repository at the model; that is too expensive and slow. We need to extract context precisely. We need to build a structured Prompt template.

def build_prompt(error_log, file_path, code_content):
    system_prompt = """
    你是一个资深的高级工程师。你的任务是根据错误日志修复代码。
    请严格遵循以下规则：
    1. 分析错误日志中的堆栈信息。
    2. 检查提供的代码内容。
    3. 输出格式必须严格遵守 Unified Diff 格式，不要输出任何解释性文字。
    """
    
    user_prompt = f"""
    ## 文件路径: {file_path}
    ## 当前代码内容:

{code_content}

    ## 错误日志:

{error_log}

    请生成修复该 Bug 的 Unified Diff 补丁。
    """
    return system_prompt, user_prompt

Step 2: Calling the Model via Gateway

Here we demonstrate how to call the model using a standardized client. Note that we use the OpenAI SDK, but point it to our unified gateway address, allowing us to switch the underlying model provider at any time.

from openai import OpenAI

# 关键实现：统一网关配置
# 这里的 base_url 指向网关，而非 OpenAI 官方地址
client = OpenAI(
    base_url="https://api.thistoken.ai/v1", # 统一入口
    api_key="YOUR_GATEWAY_API_KEY"          # 统一鉴权
)

def generate_patch(system_prompt, user_prompt):
    try:
        response = client.chat.completions.create(
            # 你可以在这里随意切换模型，例如 "gpt-4o", "claude-3-5-sonnet", "deepseek-coder"
            # 只要网关支持，业务代码无需改动
            model="deepseek-coder", 
            
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user