大模型返回超出截断解决方案

前提约定

• 所有方案均保证「字段 / 数据 100% 保留，不删减、不修改」；
• 代码统一使用 Python，需提前安装依赖：pip install requests；
• API 配置统一：替换 API_KEY 为你的 DeepSeek 密钥，MODEL 可根据实际切换（优先 8k/32k 上下文模型）。

一、方案 1：JSON 基础压缩（删除冗余字符）

核心逻辑

删除 JSON 中的空格、换行、制表符，用 “紧凑格式” 减少 Token 占用，无需修改字段 / 数据。

提示词模板

plaintext

请返回所有必需的[用户列表/订单数据/你的内容类型]，JSON格式要求：
1. 包含所有字段和数据，不删减、不精简任何内容；
2. 采用最紧凑格式：删除所有空格、换行、制表符，字段名和值不缩写；
3. 仅输出JSON字符串，无任何多余文字、解释、备注；
4. 确保JSON语法完整（括号匹配、逗号无遗漏），可直接解析。

示例输出：
{"user_list":[{"id":1,"name":"张三","age":25,"info":"完整信息内容"},{"id":2,"name":"李四","age":30,"info":"完整信息内容"}]}

代码块

python

运行

import json
import requests

# 配置
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat"

# 提示词（替换[你的内容类型]）
PROMPT = """
请返回所有必需的用户列表，JSON格式要求：
1. 包含所有字段和数据，不删减、不精简任何内容；
2. 采用最紧凑格式：删除所有空格、换行、制表符，字段名和值不缩写；
3. 仅输出JSON字符串，无任何多余文字、解释、备注；
4. 确保JSON语法完整（括号匹配、逗号无遗漏），可直接解析。

示例输出：
{"user_list":[{"id":1,"name":"张三","age":25,"info":"完整信息内容"},{"id":2,"name":"李四","age":30,"info":"完整信息内容"}]}
"""

# 发起请求
response = requests.post(
    API_URL,
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={
        "model": MODEL,
        "messages": [{"role": "user", "content": PROMPT}],
        "max_tokens": 2000,  # 根据预期JSON大小调整（紧凑格式已省Token）
        "temperature": 0.0
    },
    timeout=30
)

# 解析结果（直接得到完整紧凑JSON）
res_content = response.json()["choices"][0]["message"]["content"].strip()
complete_json = json.loads(res_content)

# 保存结果
with open("紧凑JSON_基础压缩.json", "w", encoding="utf-8") as f:
    json.dump(complete_json, f, ensure_ascii=False, indent=2)
print("✅ 基础压缩JSON保存成功，无内容丢失！")

适用场景

• JSON 总 Token 接近模型限制，但未超太多；
• 不想复杂开发，追求简单高效。

二、方案 2：JSON 字段名缩写压缩（结构化数据专用）

核心逻辑

用 “短缩写” 替代长字段名（如user_registration_time→urt），提前定义映射字典，代码自动还原，不丢任何数据。

提示词模板

plaintext

请返回所有必需的[用户数据/订单详情/你的内容类型]，按以下两步输出（仅输出这两步，无多余文字）：
第一步：输出字段缩写映射表（JSON格式，key=原字段名，value=1-2个字母的缩写，需覆盖所有字段，表意清晰）；
第二步：输出压缩JSON（字段名用第一步的缩写，数据内容完整保留，紧凑格式无空格换行）。

要求：
1. 所有字段和数据不删减、不修改；
2. 缩写映射表必须唯一，无重复缩写；
3. 压缩JSON语法完整，可通过映射表还原。

示例输出：
{"user_registration_time":"urt","product_detailed_description":"pdd","order_amount":"oa"}
{"user_list":[{"id":1,"urt":"2025-11-21","pdd":"完整商品描述","oa":999},{"id":2,"urt":"2025-11-22","pdd":"完整商品描述","oa":1999}]}

代码块

python

运行

import json
import requests

# 配置
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat"

# 提示词（替换[你的内容类型]）
PROMPT = """
请返回所有必需的订单详情，按以下两步输出（仅输出这两步，无多余文字）：
第一步：输出字段缩写映射表（JSON格式，key=原字段名，value=1-2个字母的缩写，需覆盖所有字段，表意清晰）；
第二步：输出压缩JSON（字段名用第一步的缩写，数据内容完整保留，紧凑格式无空格换行）。

要求：
1. 所有字段和数据不删减、不修改；
2. 缩写映射表必须唯一，无重复缩写；
3. 压缩JSON语法完整，可通过映射表还原。

示例输出：
{"user_registration_time":"urt","product_detailed_description":"pdd","order_amount":"oa"}
{"user_list":[{"id":1,"urt":"2025-11-21","pdd":"完整商品描述","oa":999},{"id":2,"urt":"2025-11-22","pdd":"完整商品描述","oa":1999}]}
"""

# 发起请求
response = requests.post(
    API_URL,
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={
        "model": MODEL,
        "messages": [{"role": "user", "content": PROMPT}],
        "max_tokens": 2000,
        "temperature": 0.0
    },
    timeout=30
)

# 解析结果（拆分映射表和压缩JSON）
res_content = response.json()["choices"][0]["message"]["content"].strip()
map_str, compressed_json_str = res_content.split("\n", 1)

# 还原字段名
abbrev_map = json.loads(map_str)  # 缩写→原字段名（反转字典）
reverse_map = {v: k for k, v in abbrev_map.items()}
compressed_json = json.loads(compressed_json_str)

# 递归还原JSON中的字段名
def restore_fields(data):
    if isinstance(data, dict):
        return {reverse_map.get(k, k): restore_fields(v) for k, v in data.items()}
    elif isinstance(data, list):
        return [restore_fields(item) for item in data]
    else:
        return data

complete_json = restore_fields(compressed_json)

# 保存结果
with open("字段缩写压缩_完整JSON.json", "w", encoding="utf-8") as f:
    json.dump(complete_json, f, ensure_ascii=False, indent=2)
print("✅ 字段缩写压缩JSON还原成功，无内容丢失！")

适用场景

• 字段名较长（如user_registration_time）、重复度高的结构化数据；
• 想进一步减少 Token 占用，且能接受 “定义映射表” 的开发成本。

三、方案 3：Base64 编码传输（大文本 / 大数组专用）

核心逻辑

模型将完整 JSON 转为 Base64 编码字符串（减少文本 Token 占用～33%），代码解码后还原完整 JSON，不丢任何内容。

提示词模板

plaintext

请返回所有必需的[长文本数据/商品列表/你的内容类型]，按以下步骤处理后输出（仅输出最终Base64字符串，无任何多余文字）：
1. 生成包含所有字段和数据的完整JSON（不删减、不修改，紧凑格式）；
2. 将JSON字符串按UTF-8编码转为二进制数据；
3. 对二进制数据进行Base64编码（输出字符串格式）；
4. 确保编码完整，无遗漏任何字符，可直接解码还原。

代码块

python

运行

import json
import base64
import requests

# 配置
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat"

# 提示词（替换[你的内容类型]）
PROMPT = """
请返回所有必需的长文本数据，按以下步骤处理后输出（仅输出最终Base64字符串，无任何多余文字）：
1. 生成包含所有字段和数据的完整JSON（不删减、不修改，紧凑格式）；
2. 将JSON字符串按UTF-8编码转为二进制数据；
3. 对二进制数据进行Base64编码（输出字符串格式）；
4. 确保编码完整，无遗漏任何字符，可直接解码还原。
"""

# 发起请求
response = requests.post(
    API_URL,
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={
        "model": MODEL,
        "messages": [{"role": "user", "content": PROMPT}],
        "max_tokens": 2000,  # Base64编码后长度略长，需预留冗余
        "temperature": 0.0
    },
    timeout=30
)

# 解码还原
base64_str = response.json()["choices"][0]["message"]["content"].strip()
binary_data = base64.b64decode(base64_str)  # Base64→二进制
json_str = binary_data.decode("utf-8")      # 二进制→UTF-8字符串
complete_json = json.loads(json_str)        # 字符串→JSON

# 保存结果
with open("Base64编码_完整JSON.json", "w", encoding="utf-8") as f:
    json.dump(complete_json, f, ensure_ascii=False, indent=2)
print("✅ Base64解码还原成功，无内容丢失！")

适用场景

• JSON 包含大量长文本（如文章、描述）、大数组（100 + 元素）；
• 文本 Token 占用极高，想通过二进制编码压缩传输。

四、方案 4：循环调用 + 轻量进度（核心方案，适配所有大 JSON）

核心逻辑

模型自动计算总块数，循环调用时仅带 “块号 + 总块数”（不带历史块内容，输入不超 Token），本地拼接完整 JSON。

提示词模板（数组场景，对象场景见代码注释）

plaintext

请返回所有必需的[用户列表/订单数组/你的内容类型]，JSON格式，字段和数据都不能少、不精简任何内容！
由于内容较多，按以下规则自动分块输出（模型需主动计算总块数）：
1. 你先扫描所有要返回的内容，自动拆分成N个块（每块控制在400 Token内，紧凑格式无空格/换行）；
2. 输出格式固定为2行（仅这2行，无任何多余文字）：
   第一行：分块信息 → {"total_chunks": N, "current_chunk": M} （N是总块数，M是当前块号，第1块M=1）
   第二行：当前块JSON → 必须是完整数组片段（如{"user_list": [元素1, 元素2]}），不拆单条数据；
3. 后续续传时，你按「总块数=N」返回对应块，不重复已返回内容。

示例（第1块输出）：
{"total_chunks":3,"current_chunk":1}
{"user_list":[{"id":1,"name":"张三","info":"完整内容"},{"id":2,"name":"李四","info":"完整内容"}]}

代码块

python

运行

import json
import requests
import time

# 配置
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat"  # 优先用8k上下文模型

# 提示词（数组场景，替换[你的内容类型]；对象场景见下方拼接逻辑注释）
INIT_PROMPT = """
请返回所有必需的用户列表，JSON格式，字段和数据都不能少、不精简任何内容！
由于内容较多，按以下规则自动分块输出（模型需主动计算总块数）：
1. 你先扫描所有要返回的内容，自动拆分成N个块（每块控制在400 Token内，紧凑格式无空格/换行）；
2. 输出格式固定为2行（仅这2行，无任何多余文字）：
   第一行：分块信息 → {"total_chunks": N, "current_chunk": M} （N是总块数，M是当前块号，第1块M=1）
   第二行：当前块JSON → 必须是完整数组片段（如{"user_list": [元素1, 元素2]}），不拆单条数据；
3. 后续续传时，你按「总块数=N」返回对应块，不重复已返回内容。

示例（第1块输出）：
{"total_chunks":3,"current_chunk":1}
{"user_list":[{"id":1,"name":"张三","info":"完整内容"},{"id":2,"name":"李四","info":"完整内容"}]}
"""

def collect_all_chunks_auto():
    chunks = {}  # 存储块：{块号: JSON片段}
    total_chunks = None  # 模型自动计算的总块数
    current_chunk_num = 1
    max_retries = 3

    while True:
        # 构造请求提示词
        if current_chunk_num == 1:
            current_prompt = INIT_PROMPT
        else:
            current_prompt = f"""
            续传JSON分块：总块数={total_chunks}，已返回第1-{current_chunk_num-1}块，现在返回第{current_chunk_num}块。
            规则：仅输出2行（无多余文字），第一行{{"total_chunks":{total_chunks},"current_chunk":{current_chunk_num}}}，第二行是完整数组片段（紧凑格式，不重复）。
            """

        # 发起请求（带重试）
        retry_count = 0
        while retry_count < max_retries:
            try:
                response = requests.post(
                    API_URL,
                    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
                    json={
                        "model": MODEL,
                        "messages": [{"role": "user", "content": current_prompt}],
                        "max_tokens": 700,
                        "temperature": 0.0
                    },
                    timeout=30
                )
                response.raise_for_status()
                res_content = response.json()["choices"][0]["message"]["content"].strip()
                break
            except Exception as e:
                retry_count += 1
                print(f"第{current_chunk_num}块请求失败（重试{retry_count}/{max_retries}）：{str(e)}")
                time.sleep(2)
                if retry_count == max_retries:
                    raise

        # 解析分块信息和JSON片段
        if "\n" not in res_content:
            raise ValueError(f"格式错误：{res_content}")
        chunk_info_line, json_chunk_line = res_content.split("\n", 1)
        chunk_info = json.loads(chunk_info_line.strip())
        current_json = json.loads(json_chunk_line.strip())

        # 校验块号和总块数
        M = chunk_info["current_chunk"]
        N = chunk_info["total_chunks"]
        if total_chunks is None:
            total_chunks = N
            print(f"模型自动计算总块数：{total_chunks}")
        if M != current_chunk_num or N != total_chunks:
            raise ValueError(f"块号/总块数不一致：请求第{current_chunk_num}块，返回{M}/{N}块")

        # 保存当前块
        chunks[M] = current_json
        print(f"已收集第{M}/{total_chunks}块")

        # 终止条件
        if len(chunks) == total_chunks:
            print("所有块收集完毕，开始拼接...")
            break
        current_chunk_num += 1

    # -------------------------- 拼接逻辑 --------------------------
    # 数组场景（所有块都是{"user_list": [部分元素]}）
    complete_data = {"user_list": []}
    for chunk_num in range(1, total_chunks + 1):
        complete_data["user_list"].extend(chunks[chunk_num]["user_list"])

    # 对象场景（所有块是{"子字段": 值}，如{"basic_info": {...}}）
    # complete_data = {}
    # for chunk_num in range(1, total_chunks + 1):
    #     complete_data.update(chunks[chunk_num])

    return complete_data

# 执行
if __name__ == "__main__":
    try:
        complete_json = collect_all_chunks_auto()
        with open("循环分块_完整JSON.json", "w", encoding="utf-8") as f:
            json.dump(complete_json, f, ensure_ascii=False, indent=2)
        print("✅ 循环分块拼接成功，无内容丢失！")
    except Exception as e:
        print(f"❌ 执行失败：{str(e)}")

适用场景

• JSON 体积过大（超模型单次输出 Token 限制）；
• 不想删减内容，且需要稳定、通用的解决方案（核心推荐）。

五、方案 5：循环调用 + 增量锚点（续传更稳，避免重复 / 遗漏）

核心逻辑

在方案 4 的基础上，每次续传时带上 “上一块末尾的唯一标识”（如最后一条数据的 ID），给模型 “锚点”，避免续传偏差。

提示词模板（数组场景）

plaintext

请返回所有必需的[订单列表/用户数组/你的内容类型]，JSON格式，字段和数据都不能少、不精简任何内容！
按以下规则自动分块输出（模型需主动计算总块数）：
1. 先扫描所有内容，拆分成N个块（每块400 Token内，紧凑格式，不拆单条数据）；
2. 输出格式固定2行（仅这2行）：
   第一行：{"total_chunks": N, "current_chunk": M, "last_id": "当前块最后一条数据的ID"}
   第二行：当前块JSON（如{"order_list": [元素1, 元素2]}）；
3. 后续续传时，从"last_id"之后的数据开始返回，不重复、不遗漏。

示例（第1块输出）：
{"total_chunks":3,"current_chunk":1,"last_id":"order_102"}
{"order_list":[{"id":"order_100","amount":999},{"id":"order_101","amount":1999},{"id":"order_102","amount":2999}]}

代码块

python

运行

import json
import requests
import time

# 配置
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat"

# 提示词（替换[你的内容类型]，确保ID字段存在）
INIT_PROMPT = """
请返回所有必需的订单列表，JSON格式，字段和数据都不能少、不精简任何内容！
按以下规则自动分块输出（模型需主动计算总块数）：
1. 先扫描所有内容，拆分成N个块（每块400 Token内，紧凑格式，不拆单条数据）；
2. 输出格式固定2行（仅这2行）：
   第一行：{"total_chunks": N, "current_chunk": M, "last_id": "当前块最后一条数据的id"}
   第二行：当前块JSON（如{"order_list": [元素1, 元素2]}）；
3. 后续续传时，从"last_id"之后的数据开始返回，不重复、不遗漏。

示例（第1块输出）：
{"total_chunks":3,"current_chunk":1,"last_id":"order_102"}
{"order_list":[{"id":"order_100","amount":999},{"id":"order_101","amount":1999},{"id":"order_102","amount":2999}]}
"""

def collect_all_chunks_with_anchor():
    chunks = {}
    total_chunks = None
    current_chunk_num = 1
    last_id = None  # 上一块末尾的ID锚点
    max_retries = 3

    while True:
        # 构造请求提示词
        if current_chunk_num == 1:
            current_prompt = INIT_PROMPT
        else:
            current_prompt = f"""
            续传JSON分块：总块数={total_chunks}，已返回第1-{current_chunk_num-1}块，上一块最后一条数据ID为"{last_id}"。
            现在返回第{current_chunk_num}块，规则：
            1. 输出2行：第一行{{"total_chunks":{total_chunks},"current_chunk":{current_chunk_num},"last_id":"当前块最后一条ID"}}，第二行是JSON片段；
            2. 从ID>"{last_id}"的数据开始返回，不重复已返回内容，紧凑格式。
            """

        # 发起请求
        retry_count = 0
        while retry_count < max_retries:
            try:
                response = requests.post(
                    API_URL,
                    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
                    json={
                        "model": MODEL,
                        "messages": [{"role": "user", "content": current_prompt}],
                        "max_tokens": 700,
                        "temperature": 0.0
                    },
                    timeout=30
                )
                response.raise_for_status()
                res_content = response.json()["choices"][0]["message"]["content"].strip()
                break
            except Exception as e:
                retry_count += 1
                print(f"第{current_chunk_num}块请求失败（重试{retry_count}/{max_retries}）：{str(e)}")
                time.sleep(2)
                if retry_count == max_retries:
                    raise

        # 解析结果
        chunk_info_line, json_chunk_line = res_content.split("\n", 1)
        chunk_info = json.loads(chunk_info_line.strip())
        current_json = json.loads(json_chunk_line.strip())

        # 校验并更新信息
        M = chunk_info["current_chunk"]
        N = chunk_info["total_chunks"]
        last_id = chunk_info["last_id"]  # 更新锚点
        if total_chunks is None:
            total_chunks = N
            print(f"总块数：{total_chunks}")
        if M != current_chunk_num or N != total_chunks:
            raise ValueError(f"块号/总块数不一致：{M}/{N}")

        # 保存块
        chunks[M] = current_json
        print(f"已收集第{M}/{total_chunks}块（最后ID：{last_id}）")

        # 终止条件
        if len(chunks) == total_chunks:
            break
        current_chunk_num += 1

    # 拼接数组
    complete_data = {"order_list": []}
    for chunk_num in range(1, total_chunks + 1):
        complete_data["order_list"].extend(chunks[chunk_num]["order_list"])
    return complete_data

# 执行
if __name__ == "__main__":
    try:
        complete_json = collect_all_chunks_with_anchor()
        with open("增量锚点_完整JSON.json", "w", encoding="utf-8") as f:
            json.dump(complete_json, f, ensure_ascii=False, indent=2)
        print("✅ 增量锚点续传拼接成功，无内容丢失！")
    except Exception as e:
        print(f"❌ 执行失败：{str(e)}")

适用场景

• 长列表数据（如 100 + 条订单 / 用户）；
• 担心模型续传时重复或遗漏数据，需要更高稳定性。

六、方案 6：切换大上下文模型 / 申请配额（最省心方案）

核心逻辑

直接使用 DeepSeek 大上下文模型（如 8k/32k Token）或申请更高 max_tokens 配额，一次性返回完整大 JSON，无需分块 / 压缩。

提示词模板

plaintext

请返回所有必需的[你的内容类型]，JSON格式要求：
1. 包含所有字段和数据，不删减、不修改任何内容；
2. 格式清晰（可带缩进，方便解析）；
3. 仅输出JSON字符串，无任何多余文字、解释。

代码块

python

运行

import json
import requests

# 配置（切换为大上下文模型，如deepseek-chat-8k）
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat-8k"  # 大上下文模型（4k→8k→32k，根据官网支持选择）

# 提示词（替换[你的内容类型]）
PROMPT = """
请返回所有必需的用户完整数据，JSON格式要求：
1. 包含所有字段和数据，不删减、不修改任何内容；
2. 格式清晰（可带缩进，方便解析）；
3. 仅输出JSON字符串，无任何多余文字、解释。
"""

# 发起请求（设置足够大的max_tokens）
response = requests.post(
    API_URL,
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json={
        "model": MODEL,
        "messages": [{"role": "user", "content": PROMPT}],
        "max_tokens": 4000,  # 大模型支持更高max_tokens，按需调整
        "temperature": 0.0
    },
    timeout=30
)

# 解析结果
res_content = response.json()["choices"][0]["message"]["content"].strip()
complete_json = json.loads(res_content)

# 保存结果
with open("大模型_完整JSON.json", "w", encoding="utf-8") as f:
    json.dump(complete_json, f, ensure_ascii=False, indent=2)
print("✅ 大模型一次性返回成功，无内容丢失！")

适用场景

• DeepSeek 支持大上下文模型（如 8k/32k）；
• 不想开发分块 / 压缩逻辑，追求极简落地。

七、方案 7：分块 + 完整性校验（兜底保障，100% 不丢内容）

核心逻辑

在方案 4/5 的基础上，增加 “单块校验 + 漏块检测 + 最终 JSON 校验”，应对模型拆块失误、单块截断等极端情况。

提示词模板（复用方案 4/5 的提示词，无需额外修改）

代码块（在方案 4 基础上增加校验逻辑）

python

运行

import json
import requests
import time

# 配置（同方案4）
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat"

# 初始提示词（同方案4的INIT_PROMPT）
INIT_PROMPT = """
请返回所有必需的用户列表，JSON格式，字段和数据都不能少、不精简任何内容！
由于内容较多，按以下规则自动分块输出（模型需主动计算总块数）：
1. 你先扫描所有要返回的内容，自动拆分成N个块（每块控制在400 Token内，紧凑格式无空格/换行）；
2. 输出格式固定为2行（仅这2行，无任何多余文字）：
   第一行：分块信息 → {"total_chunks": N, "current_chunk": M} （N是总块数，M是当前块号，第1块M=1）
   第二行：当前块JSON → 必须是完整数组片段（如{"user_list": [元素1, 元素2]}），不拆单条数据；
3. 后续续传时，你按「总块数=N」返回对应块，不重复已返回内容。

示例（第1块输出）：
{"total_chunks":3,"current_chunk":1}
{"user_list":[{"id":1,"name":"张三","info":"完整内容"},{"id":2,"name":"李四","info":"完整内容"}]}
"""

# -------------------------- 新增：完整性校验函数 --------------------------
def validate_chunk(chunk_json, required_fields=["id", "name", "info"]):
    """校验单块是否包含所有必需字段，无截断"""
    if "user_list" not in chunk_json:
        return False
    for item in chunk_json["user_list"]:
        if not all(field in item for field in required_fields):
            return False
    return True

def validate_complete_json(complete_json, required_top_fields=["user_list"]):
    """校验最终JSON是否包含所有顶级字段"""
    return all(field in complete_json for field in required_top_fields)

# -------------------------- 核心循环逻辑（同方案4，增加校验） --------------------------
def collect_all_chunks_with_validation():
    chunks = {}
    total_chunks = None
    current_chunk_num = 1
    max_retries = 3
    required_fields = ["id", "name", "info"]  # 你的JSON必需字段，按需修改

    while True:
        # 构造提示词（同方案4）
        if current_chunk_num == 1:
            current_prompt = INIT_PROMPT
        else:
            current_prompt = f"""
            续传JSON分块：总块数={total_chunks}，已返回第1-{current_chunk_num-1}块，现在返回第{current_chunk_num}块。
            规则：仅输出2行（无多余文字），第一行{{"total_chunks":{total_chunks},"current_chunk":{current_chunk_num}}}，第二行是完整数组片段（紧凑格式，不重复）。
            """

        # 发起请求（同方案4）
        retry_count = 0
        while retry_count < max_retries:
            try:
                response = requests.post(
                    API_URL,
                    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
                    json={
                        "model": MODEL,
                        "messages": [{"role": "user", "content": current_prompt}],
                        "max_tokens": 700,
                        "temperature": 0.0
                    },
                    timeout=30
                )
                response.raise_for_status()
                res_content = response.json()["choices"][0]["message"]["content"].strip()
                break
            except Exception as e:
                retry_count += 1
                print(f"第{current_chunk_num}块请求失败（重试{retry_count}/{max_retries}）：{str(e)}")
                time.sleep(2)
                if retry_count == max_retries:
                    raise

        # 解析并校验单块
        chunk_info_line, json_chunk_line = res_content.split("\n", 1)
        chunk_info = json.loads(chunk_info_line.strip())
        current_json = json.loads(json_chunk_line.strip())
        
        # 单块校验：必需字段是否完整
        if not validate_chunk(current_json, required_fields):
            raise ValueError(f"第{current_chunk_num}块数据不完整（缺少必需字段）：{json_chunk_line}")

        # 后续逻辑（同方案4：校验块号、保存块）
        M = chunk_info["current_chunk"]
        N = chunk_info["total_chunks"]
        if total_chunks is None:
            total_chunks = N
            print(f"总块数：{total_chunks}")
        if M != current_chunk_num or N != total_chunks:
            raise ValueError(f"块号/总块数不一致：{M}/{N}")

        chunks[M] = current_json
        print(f"已收集第{M}/{total_chunks}块（校验通过）")

        # 终止条件
        if len(chunks) == total_chunks:
            break
        current_chunk_num += 1

    # -------------------------- 漏块检测 --------------------------
    missing_chunks = [i for i in range(1, total_chunks + 1) if i not in chunks]
    if missing_chunks:
        raise ValueError(f"缺少块号：{missing_chunks}，请重新请求这些块")

    # -------------------------- 拼接并校验最终JSON --------------------------
    complete_data = {"user_list": []}
    for chunk_num in range(1, total_chunks + 1):
        complete_data["user_list"].extend(chunks[chunk_num]["user_list"])
    
    if not validate_complete_json(complete_data):
        raise ValueError("最终JSON缺少顶级必需字段，拼接失败")

    return complete_data

# 执行
if __name__ == "__main__":
    try:
        complete_json = collect_all_chunks_with_validation()
        with open("分块校验_完整JSON.json", "w", encoding="utf-8") as f:
            json.dump(complete_json, f, ensure_ascii=False, indent=2)
        print("✅ 分块+完整性校验成功，100%无内容丢失！")
    except Exception as e:
        print(f"❌ 执行失败：{str(e)}")

适用场景

• 对数据完整性要求极高（不允许任何遗漏 / 截断）；
• 极端场景（模型拆块失误、网络波动导致单块损坏）。

八、方案 8：分层分块（按数据类型拆分，减少拆块失误）

核心逻辑

让模型优先按 “数据类型 / 语义单元” 拆分（如basic_info、order_list、address_list分别为一块），而非单纯按 Token 数拆，降低拼接风险。

提示词模板（对象场景）

plaintext

请返回所有必需的[用户完整信息/商品详情/你的内容类型]，JSON格式，字段和数据都不能少、不精简任何内容！
按以下规则分层分块输出（模型自动计算总块数）：
1. 优先按「完整子字段」拆分（如basic_info、order_list、address_list各为一块，不拆子字段内部）；
2. 每块控制在500 Token内，若单个子字段过大，再按数组片段拆分（不拆单条数据）；
3. 输出格式固定2行（仅这2行）：
   第一行：{"total_chunks": N, "current_chunk": M, "chunk_type": "子字段名"}（如chunk_type="basic_info"）
   第二行：当前块JSON（如{"basic_info": {...}}）；
4. 仅输出上述2行，无多余文字，续传时不重复已返回内容。

示例（第1块输出）：
{"total_chunks":3,"current_chunk":1,"chunk_type":"basic_info"}
{"basic_info":{"id":1,"name":"张三","phone":"138XXXX1234","email":"xxx@xxx.com"}}

代码块

python

运行

import json
import requests
import time

# 配置
API_KEY = "你的DeepSeek API密钥"
API_URL = "https://api.deepseek.com/v1/chat/completions"
MODEL = "deepseek-chat"

# 提示词（对象场景，替换[你的内容类型]）
INIT_PROMPT = """
请返回所有必需的用户完整信息，JSON格式，字段和数据都不能少、不精简任何内容！
按以下规则分层分块输出（模型自动计算总块数）：
1. 优先按「完整子字段」拆分（如basic_info、order_list、address_list各为一块，不拆子字段内部）；
2. 每块控制在500 Token内，若单个子字段过大，再按数组片段拆分（不拆单条数据）；
3. 输出格式固定2行（仅这2行）：
   第一行：{"total_chunks": N, "current_chunk": M, "chunk_type": "子字段名"}（如chunk_type="basic_info"）
   第二行：当前块JSON（如{"basic_info": {...}}）；
4. 仅输出上述2行，无多余文字，续传时不重复已返回内容。

示例（第1块输出）：
{"total_chunks":3,"current_chunk":1,"chunk_type":"basic_info"}
{"basic_info":{"id":1,"name":"张三","phone":"138XXXX1234","email":"xxx@xxx.com"}}
"""

def collect_all_chunks_layered():
    chunks = {}
    total_chunks = None
    current_chunk_num = 1
    max_retries = 3

    while True:
        # 构造提示词
        if current_chunk_num == 1:
            current_prompt = INIT_PROMPT
        else:
            current_prompt = f"""
            续传JSON分块：总块数={total_chunks}，已返回第1-{current_chunk_num-1}块，现在返回第{current_chunk_num}块。
            规则：仅输出2行，第一行{{"total_chunks":{total_chunks},"current_chunk":{current_chunk_num},"chunk_type":"子字段名"}}，第二行是完整子字段JSON（紧凑格式）。
            """

        # 发起请求
        retry_count = 0
        while retry_count < max_retries:
            try:
                response = requests.post(
                    API_URL,
                    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
                    json={
                        "model": MODEL,
                        "messages": [{"role": "user", "content": current_prompt}],
                        "max_tokens": 800,
                        "temperature": 0.0
                    },
                    timeout=30
                )
                response.raise_for_status()
                res_content = response.json()["choices"][0]["message"]["content"].strip()
                break
            except Exception as e:
                retry_count += 1
                print(f"第{current_chunk_num}块请求失败（重试{retry_count}/{max_retries}）：{str(e)}")
                time.sleep(2)
                if retry_count == max_retries:
                    raise

        # 解析结果
        chunk_info_line, json_chunk_line = res_content.split("\n", 1)
        chunk_info = json.loads(chunk_info_line.strip())
        current_json = json.loads(json_chunk_line.strip())

        # 校验并更新信息
        M = chunk_info["current_chunk"]
        N = chunk_info["total_chunks"]
        if total_chunks is None:
            total_chunks = N
            print(f"总块数：{total_chunks}")
        if M != current_chunk_num or N != total_chunks:
            raise ValueError(f"块号/总块数不一致：{M}/{N}")

        # 保存块（按chunk_type分类，避免重复）
        chunk_type = chunk_info["chunk_type"]
        if chunk_type not in chunks:
            chunks[chunk_type] = []
        chunks[chunk_type].append(current_json)
        print(f"已收集第{M}/{total_chunks}块（类型：{chunk_type}）")

        # 终止条件
        if len(chunks) == total_chunks:
            break
        current_chunk_num += 1

    # -------------------------- 拼接逻辑（按类型合并） --------------------------
    complete_data = {}
    for chunk_type, chunk_list in chunks.items():
        if len(chunk_list) == 1:
            # 单个块的子字段，直接合并
            complete_data.update(chunk_list[0])
        else:
            # 多个块的子字段（数组片段），拼接数组
            merged = {chunk_type: []}
            for chunk in chunk_list:
                merged[chunk_type].extend(chunk[chunk_type])
            complete_data.update(merged)

    return complete_data

# 执行
if __name__ == "__main__":
    try:
        complete_json = collect_all_chunks_layered()
        with open("分层分块_完整JSON.json", "w", encoding="utf-8") as f:
            json.dump(complete_json, f, ensure_ascii=False, indent=2)
        print("✅ 分层分块拼接成功，无内容丢失！")
    except Exception as e:
        print(f"❌ 执行失败：{str(e)}")

适用场景

• JSON 是多字段对象（如包含basic_info、order_list、address_list等）；
• 想让拆分逻辑更合理，减少 “跨语义拆块” 的失误。

总结：方案选择建议

方案	核心优势	开发成本	适用场景
1. 基础压缩	简单高效，无需复杂逻辑	低	JSON 接近 Token 限制，无大文本
2. 字段缩写压缩	Token 压缩比高	中	结构化数据，字段名较长
3. Base64 编码	适合大文本 / 大数组	低	JSON 包含大量长文本、重复字段
4. 循环轻量进度	通用稳定，输入不超 Token	中	所有大 JSON 场景（核心推荐）
5. 循环增量锚点	续传更准，无重复遗漏	中	长列表数据（100 + 元素）
6. 大模型 / 配额	极简落地，无需开发	极低	支持大上下文模型 / 可申请配额
7. 分块 + 校验	100% 完整，兜底保障	中高	对数据完整性要求极高
8. 分层分块	拆分合理，减少失误	中	多字段对象 JSON（如用户完整信息）

所有方案均保证 “不丢任何内容”，可根据你的开发成本、数据结构、模型权限选择，也可组合使用（如 “分层分块 + 增量锚点 + 完整性校验”）。