一款智能检测工具，评估你的代码库在LLM上下文窗口中的适配程度，帮助开发者优化代码结构，提升大模型分析效率。

「10分钟实现」代码库上下文窗口适配检测器：LLM 智能分析工具

本教程教你如何快速实现一个代码库上下文窗口适配检测器，它能评估你的代码库在LLM上下文窗口中的适配程度，并提供优化建议。适用于大型代码库分析和LLM应用开发场景。前置条件：Python 3.8+，Git，OpenAI API密钥。

背景与痛点

在大型项目中，LLM分析代码时经常面临上下文窗口限制的问题。你的代码库可能太大，无法一次性全部放入LLM的上下文窗口，导致分析不完整或错误。

现有解决方案要么手动计算代码行数（不准确），要么使用复杂工具（配置繁琐），缺乏一个简单直接的检测工具。

核心概念速览

术语	定义	重要性
上下文窗口	LLM一次能处理的文本最大长度	直接影响代码分析能力
Token	LLM处理的基本文本单位	决定了上下文窗口的实际容量
代码树	代码库的目录结构	影响代码组织方式

环境准备

bash

创建虚拟环境

python -m venv llm_context_analyzer
source llm_context_analyzer/bin/activate

安装依赖

pip install openai tiktoken treeignore

确保你已获取OpenAI API密钥，并设置环境变量：

export OPENAI_API_KEY='your-api-key-here'

Step-by-step 实现

1. 初始化项目结构

import os
from typing import Dict, List, Optional
import tiktoken
from treeignore import TreeIgnore

class ContextAnalyzer:
    def __init__(self, api_key: str, model: str = 'gpt-4'):
        self.api_key = api_key
        self.model = model
        self.encoding = tiktoken.encoding_for_model(model)
        self.ignored_files = set()

2. 计算代码Token数

    def calculate_tokens(self, code: str) -> int:
        """计算代码的Token数量"""
        return len(self.encoding.encode(code))

    def analyze_file(self, file_path: str) -> Dict:
        """分析单个文件"""
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()
                tokens = self.calculate_tokens(content)
                return {
                    'file': file_path,
                    'tokens': tokens,
                    'lines': len(content.split('\n'))
                }
        except Exception as e:
            print(f"Error analyzing {file_path}: {str(e)}")
            return None

3. 扫描整个代码库

    def scan_directory(self, directory: str, max_depth: int = 3) -> List[Dict]:
"""扫描目录并分析所有文件"""
        results = []
        
        for root, dirs, files in os.walk(directory):
            # 控制扫描深度
            current_depth = root[len(directory):].count(os.sep)
            if current_depth >= max_depth:
                dirs[:] = []  # 不继续递归
                continue
                
            for file in files:
                file_path = os.path.join(root, file)
                # 跳过被忽略的文件
                if any(ign in file_path for ign in self.ignored_files):
                    continue
                    
                analysis = self.analyze_file(file_path)
                if analysis:
                    results.append(analysis)
        
        return results

4. 检测上下文适配情况

    def check_context_fit(self, directory: str, context_limit: int = 8192) -> Dict:
        """检查代码库是否适合上下文窗口"""
        files = self.scan_directory(directory)
        total_tokens = sum(f['tokens'] for f in files)

    # 按Token数量排序
    sorted_files = sorted(files, key=lambda x: x['tokens'], reverse=True)

    # 计算累积Token
    cumulative = 0
    cumulative_files = []

    for file in sorted_files:
        cumulative += file['tokens']
        cumulative_files.append({
            'file': file['file'],
            'tokens': file['tokens'],
            'cumulative': cumulative
        })

        if cumulative > context_limit:
            break

    return {
        'total_tokens': total_tokens,
        'context_limit': context_limit,
        'fit_ratio': min(100, (context_limit / total_tokens) * 100) if total_tokens > 0 else 100,
        'largest_files': sorted_files[:5],
        'cumulative_files': cumulative_files
    }

5. 使用LLM提供优化建议

    def get_optimization_suggestions(self, analysis: Dict) -> str:
        """使用LLM获取优化建议"""
        prompt = f"""
        你是一个代码架构优化专家。以下是一个代码库的上下文窗口分析结果：
        
        总T
oken数: {analysis['total_tokens']}
        上下文限制: {analysis['context_limit']}
        适配比例: {analysis['fit_ratio']:.2f}%
        
        最大的5个文件:
        {chr(10).join(f"- {f['file']}: {f['tokens']} tokens" for f in analysis['largest_files'])}
        
        请提供具体的优化建议，帮助改善代码库在LLM上下文窗口中的适配性。
        """

    # 实际应用中这里会调用OpenAI API
    # response = openai.ChatCompletion.create(
    #     model=self.model,
    #     messages=[{"role": "user", "content": prompt}]
    # )
    # return response.choices[0].message['content']

    # 模拟响应
    return f"""
    根据分析结果，你的代码库适配度为{analysis['fit_ratio']:.2f}%。

    建议优化方向：
    1. 考虑重构最大的文件：{analysis['largest_files'][0]['file']}
    2. 将代码模块化，减少单个文件大小
    3. 实现增量加载机制，只加载当前需要的代码
    4. 使用代码摘要技术提取关键部分
    """

6. 完整使用示例

if __name__ == '__main__':
    # 初始化分析器
    analyzer = ContextAnalyzer(os.getenv('OPENAI_API_KEY'))

# 设置要忽略的文件类型
analyzer.ignored_files = {'.git', '__pycache__', 'node_modules', '.venv'}

# 分析当前目录
analysis = analyzer.check_context_fit('.')

# 打印结果
print(f"总Token数: {analysis['total_tokens']}")
print(f"适配比例: {analysis['fit_ratio']:.2f}%")

# 获取优化建议
suggestions = analyzer.get_optimization_suggestions(analysis)
print("\n优化建议：")
print(suggestions)

常见错误与解决方案

错误1: 文件编码问题

问题: 分析文件时遇到编码错误

解决方案: 添加编码检测逻辑

import chardet

def detect_encoding(file_path: str) -> str:
    with open(file_path, 'rb') as f:
        result = chardet.detect(f.read())
    return result['encoding'] or 'utf-8'

def analyze_file(self, file_path: str) -> Dict:
    try:
        encoding = detect_encoding(file_path)
        with open(file_path, 'r', encoding=encoding) as f:
            content = f.read()
            tokens = self.calculate_tokens(content)
            return {
                'file': file_path,
                'tokens': tokens,
                'lines': len(cont
ent.split('\n'))
            }
    except Exception as e:
        print(f"Error analyzing {file_path}: {str(e)}")
        return None

错误2: 上下文窗口计算不准确

问题: 实际使用时发现Token计算与LLM实际处理能力不符

解决方案: 添加缓冲区计算

def check_context_fit(self, directory: str, context_limit: int = 8192, buffer_percent: float = 0.9) -> Dict:
    # ... 原有代码 ...

# 应用缓冲区
effective_limit = int(context_limit * buffer_percent)

return {
    'total_tokens': total_tokens,
    'context_limit': context_limit,
    'effective_limit': effective_limit,
    'fit_ratio': min(100, (effective_limit / total_tokens) * 100) if total_tokens > 0 else 100,
    'largest_files': sorted_files[:5],
    'cumulative_files': cumulative_files
}

错误3: 大型目录扫描性能问题

问题: 扫描大型代码库时速度缓慢

解决方案: 实现并行扫描

from concurrent.futures import ThreadPoolExecutor

def scan_directory_parallel(self, directory: str, max_workers: int = 4) -> List[Dict]:
    results = []
    file_paths = []

# 收集所有文件路径
for root, dirs, files in os.walk(directory):
    for file in files:
        file_path = os.path.join(root, file)
        if any(ign in file_path for ign in self.ignored_files):
            continue
        file_paths.append(file_path)

# 并行分析文件
with ThreadPoolExecutor(max_workers=max_workers) as executor:
    results = list(executor.map(self.analyze_file, file_paths))

# 过滤掉None结果
return [r for r in results if r is not None]

进阶优化/扩展方向

1. 添加可视化报告

import matplotlib.pyplot as plt

def generate_report(self, analysis: Dict, output_path: str = 'context_report.png'):
    plt.figure(figsize=(10, 6))

# 文件大小分布图
files = [f['file'].split('/')[-1] for f in analysis['largest_files']]
sizes = [f['tokens'] for f in analysis['largest_files']]

plt.bar(files, sizes)
plt.title('Largest Files by Token Count')
plt.xlabel('Files')
plt.ylabel('Tokens')
plt.xticks(rotation=45)

plt.tight_layout()
plt.savefig(output_path)
plt.close()

2. 实现增量分析

def incremental_analysis(self, directory: str, threshold: int = 1000) -> Dict:
    """增量分析代码库，只分析变化部分"""
    # 实现文件系统监控和增量分析逻辑
    # 可以使用watchdog库监控文件变化
    pass

3. 集成更多LLM提供商

class MultiLLMAnalyzer:
    def __init__(self):
        self.providers = {
            'openai': OpenAIProvider(),
            'anthropic': AnthropicProvider(),
            'local': LocalLLMProvider()
        }
    
    def analyze_with_provider(self, provider_name: str, **kwargs):
        provider = self.providers.get(provider_name)
        if provider:
            return provider.analyze(**kwargs)
        raise ValueError(f"Unknown provider: {provider_name}")

完整代码仓库

完整代码可在以下仓库获取：https://github.com/example/llm-context-analyzer

核心知识点总结

1. Token计算：使用tiktoken准确计算代码的Token数量
2. 上下文窗口适配：评估代码库大小与LLM上下文限制的匹配程度
3. 文件分析策略：递归扫描目录，忽略不相关文件
4. 优化建议生成：利用LLM提供针对性的代码结构优化建议

参考资料

1. OpenAI Tokenizer文档：https://github.com/openai/tiktoken
2. TreeIgnore库：https://pypi.org/project/treeignore/
3. LLM上下文窗口限制研究：https://arxiv.org/abs/2306.01343