DMXAPI驱动的小说生成系统：从集成到优化的完整实践

参数	推荐值（小说场景）	作用机理
`temperature`	0.7-0.85	低于0.7导致情节 predictable，高于0.85出现逻辑跳跃
`top_p`	0.92-0.95	核采样控制，配合temperature精细调节创造性
`frequency_penalty`	0.3-0.5	抑制高频词重复，避免"他说道"类表达冗余
`presence_penalty`	0.1-0.2	鼓励引入新元素，推动情节发展
`max_tokens`	动态计算	按预估字数×1.5设置，预留结构标记空间

提升生成质量的进阶技巧

1. 提示工程的三层架构

指令层：明确任务"创作奇幻小说章节，包含对话与场景描写"
上下文层：提供前文概要"主角已获得火焰剑，但同伴背叛"
约束层：添加负向提示"避免使用现代词汇，不要突然引入新魔法体系"

2. 分阶段生成法 将单次生成拆分为三次调用：

第一次：生成情节大纲（bullet points）
第二次：扩展关键场景（scene writing）
第三次：润色语言风格（polishing）

此法可将生成长文本的 abandonment rate 从35%降至8%。

代码示例

请先前往DMXAPI官网，注册账号后获取API密钥（需要保证一定余额以支持小说的生成）

效果图：

html 复制代码

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AI小说生成器</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
        }
        
        body {
            background-color: #f8fafc;
            color: #1e293b;
            line-height: 1.6;
            padding: 20px;
            min-height: 100vh;
        }
        
        .container {
            max-width: 1200px;
            margin: 0 auto;
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 30px;
        }
        
        @media (max-width: 768px) {
            .container {
                grid-template-columns: 1fr;
            }
        }
        
        .panel {
            background-color: white;
            border-radius: 12px;
            padding: 30px;
            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
        }
        
        h1 {
            font-size: 28px;
            font-weight: 700;
            margin-bottom: 30px;
            color: #0f172a;
            text-align: center;
        }
        
        .form-group {
            margin-bottom: 20px;
        }
        
        label {
            display: block;
            font-weight: 600;
            margin-bottom: 8px;
            color: #334155;
            font-size: 15px;
        }
        
        input, textarea, select {
            width: 100%;
            padding: 12px 16px;
            border: 1px solid #e2e8f0;
            border-radius: 8px;
            font-size: 15px;
            transition: border-color 0.2s;
        }
        
        input:focus, textarea:focus, select:focus {
            outline: none;
            border-color: #3b82f6;
        }
        
        textarea {
            min-height: 120px;
            resize: vertical;
        }
        
        .word-count-options {
            display: grid;
            grid-template-columns: repeat(2, 1fr);
            gap: 10px;
            margin-top: 5px;
        }
        
        .word-option {
            padding: 12px;
            border: 2px solid #e2e8f0;
            border-radius: 8px;
            text-align: center;
            cursor: pointer;
            transition: all 0.2s;
            font-weight: 500;
        }
        
        .word-option:hover {
            border-color: #3b82f6;
            background-color: #eff6ff;
        }
        
        .word-option.selected {
            border-color: #3b82f6;
            background-color: #3b82f6;
            color: white;
        }
        
        .custom-word-count {
            display: flex;
            gap: 10px;
            align-items: center;
            margin-top: 10px;
        }
        
        .custom-word-count input {
            flex: 1;
            padding: 10px;
        }
        
        .custom-word-count span {
            color: #64748b;
            font-size: 14px;
        }
        
        .buttons {
            display: flex;
            gap: 12px;
            margin-top: 30px;
        }
        
        button {
            flex: 1;
            padding: 14px;
            border: none;
            border-radius: 8px;
            font-size: 16px;
            font-weight: 600;
            cursor: pointer;
            transition: all 0.2s;
        }
        
        .btn-generate {
            background-color: #3b82f6;
            color: white;
        }
        
        .btn-generate:hover:not(:disabled) {
            background-color: #2563eb;
        }
        
        .btn-stop {
            background-color: #ef4444;
            color: white;
        }
        
        .btn-stop:hover:not(:disabled) {
            background-color: #dc2626;
        }
        
        button:disabled {
            opacity: 0.6;
            cursor: not-allowed;
        }
        
        .result-header {
            display: flex;
            justify-content: space-between;
            align-items: center;
            margin-bottom: 20px;
            flex-wrap: wrap;
            gap: 10px;
        }
        
        .result-title {
            font-size: 20px;
            font-weight: 700;
            color: #0f172a;
        }
        
        .status {
            font-size: 14px;
            color: #64748b;
            display: flex;
            align-items: center;
        }
        
        .status-dot {
            width: 8px;
            height: 8px;
            border-radius: 50%;
            margin-right: 6px;
            background-color: #94a3b8;
        }
        
        .status-dot.active {
            background-color: #22c55e;
            animation: pulse 1.5s infinite;
        }
        
        @keyframes pulse {
            0% { opacity: 1; }
            50% { opacity: 0.5; }
            100% { opacity: 1; }
        }
        
        .result-content {
            background-color: #f8fafc;
            border-radius: 8px;
            padding: 24px;
            min-height: 400px;
            max-height: 60vh;
            overflow-y: auto;
            white-space: pre-wrap;
            line-height: 1.7;
            font-size: 16px;
            border: 1px solid #e2e8f0;
        }
        
        .result-content.streaming::after {
            content: '▌';
            animation: blink 1s infinite;
            color: #3b82f6;
        }
        
        @keyframes blink {
            0%, 100% { opacity: 1; }
            50% { opacity: 0; }
        }
        
        .error {
            background-color: #fef2f2;
            color: #dc2626;
            padding: 12px 16px;
            border-radius: 8px;
            margin-top: 16px;
            font-size: 14px;
            display: none;
        }
        
        .error.show {
            display: block;
        }
        
        .stats {
            display: flex;
            gap: 20px;
            margin-top: 15px;
            font-size: 14px;
            color: #64748b;
        }
        
        .stat-item {
            display: flex;
            align-items: center;
            gap: 6px;
        }
        
        .progress-container {
            width: 100%;
            height: 6px;
            background-color: #e2e8f0;
            border-radius: 3px;
            margin-top: 10px;
            overflow: hidden;
        }
        
        .progress-bar {
            height: 100%;
            background-color: #3b82f6;
            border-radius: 3px;
            width: 0%;
            transition: width 0.3s ease;
        }
    </style>
</head>
<body>
    <h1>AI小说生成器</h1>
    
    <div class="container">
        <div class="panel">
            <div class="form-group">
                <label for="api-key">API密钥</label>
                <input type="password" id="api-key" placeholder="请输入您的API密钥" autocomplete="off">
            </div>
            
            <div class="form-group">
                <label for="novel-title">小说名称</label>
                <input type="text" id="novel-title" placeholder="例如：星辰之旅" value="星辰之旅">
            </div>
            
            <div class="form-group">
                <label for="novel-plot">主线情节</label>
                <textarea id="novel-plot" placeholder="详细描述小说的主要情节...">在遥远的未来，人类已经掌握了星际旅行技术。主角林风是一名星际探险家，他在一次探索任务中意外发现了一个古老的外星文明遗迹。这个遗迹中隐藏着改变人类命运的秘密，但同时也引来了其他势力的觊觎。林风必须与时间赛跑，解开遗迹的谜题，同时保护这个秘密不被邪恶势力利用。</textarea>
            </div>
            
            <div class="form-group">
                <label for="novel-genre">小说类型</label>
                <select id="novel-genre">
                    <option value="科幻">科幻</option>
                    <option value="奇幻">奇幻</option>
                    <option value="武侠">武侠</option>
                    <option value="言情">言情</option>
                    <option value="悬疑">悬疑</option>
                    <option value="历史">历史</option>
                </select>
            </div>
            
            <div class="form-group">
                <label>小说字数</label>
                <div class="word-count-options">
                    <div class="word-option selected" data-words="1000">1000字</div>
                    <div class="word-option" data-words="2000">2000字</div>
                    <div class="word-option" data-words="3000">3000字</div>
                    <div class="word-option" data-words="5000">5000字</div>
                </div>
                
                <div class="custom-word-count">
                    <input type="number" id="custom-words" min="500" max="10000" value="1000" placeholder="自定义字数">
                    <span>字</span>
                </div>
                
                <div class="progress-container">
                    <div class="progress-bar" id="progress-bar"></div>
                </div>
            </div>
            
            <div class="buttons">
                <button id="generate-btn" class="btn-generate">生成小说</button>
                <button id="stop-btn" class="btn-stop" disabled>停止</button>
            </div>
            
            <div id="error" class="error"></div>
        </div>
        
        <div class="panel">
            <div class="result-header">
                <div class="result-title">生成结果</div>
                <div class="status">
                    <span class="status-dot"></span>
                    <span id="status-text">等待生成</span>
                </div>
            </div>
            
            <div id="result-content" class="result-content">
                小说内容将在这里实时显示...
            </div>
            
            <div class="stats">
                <div class="stat-item">
                    <span>字数:</span>
                    <span id="current-words">0</span> / <span id="target-words">1000</span>
                </div>
                <div class="stat-item">
                    <span>进度:</span>
                    <span id="progress-text">0%</span>
                </div>
                <div class="stat-item">
                    <span>模型:</span>
                    <span>mimo-v2-flash-free</span>
                </div>
            </div>
        </div>
    </div>

    <script>
        document.addEventListener('DOMContentLoaded', function() {
            // 获取DOM元素
            const apiKeyInput = document.getElementById('api-key');
            const novelTitleInput = document.getElementById('novel-title');
            const novelPlotInput = document.getElementById('novel-plot');
            const novelGenreSelect = document.getElementById('novel-genre');
            const generateBtn = document.getElementById('generate-btn');
            const stopBtn = document.getElementById('stop-btn');
            const resultContent = document.getElementById('result-content');
            const errorElement = document.getElementById('error');
            const statusDot = document.querySelector('.status-dot');
            const statusText = document.getElementById('status-text');
            const wordOptions = document.querySelectorAll('.word-option');
            const customWordsInput = document.getElementById('custom-words');
            const currentWordsSpan = document.getElementById('current-words');
            const targetWordsSpan = document.getElementById('target-words');
            const progressText = document.getElementById('progress-text');
            const progressBar = document.getElementById('progress-bar');
            
            let streamController = null;
            let isStreaming = false;
            let targetWords = 1000;
            let currentWords = 0;
            
            // 字数选项点击事件
            wordOptions.forEach(option => {
                option.addEventListener('click', function() {
                    // 移除所有选项的选中状态
                    wordOptions.forEach(opt => opt.classList.remove('selected'));
                    // 添加当前选项的选中状态
                    this.classList.add('selected');
                    // 更新目标字数
                    targetWords = parseInt(this.dataset.words);
                    customWordsInput.value = targetWords;
                    targetWordsSpan.textContent = targetWords;
                    // 重置进度
                    resetProgress();
                });
            });
            
            // 自定义字数输入事件
            customWordsInput.addEventListener('input', function() {
                const value = parseInt(this.value) || 1000;
                // 确保字数在合理范围内
                if (value < 500) this.value = 500;
                if (value > 10000) this.value = 10000;
                
                targetWords = parseInt(this.value);
                targetWordsSpan.textContent = targetWords;
                
                // 更新选项选中状态
                wordOptions.forEach(opt => {
                    if (parseInt(opt.dataset.words) === targetWords) {
                        opt.classList.add('selected');
                    } else {
                        opt.classList.remove('selected');
                    }
                });
                
                // 如果没有匹配的预设选项，清除所有选中状态
                const hasMatch = Array.from(wordOptions).some(opt => 
                    parseInt(opt.dataset.words) === targetWords
                );
                if (!hasMatch) {
                    wordOptions.forEach(opt => opt.classList.remove('selected'));
                }
            });
            
            // 计算中文字数
            function countChineseWords(text) {
                // 统计中文字符（包括中文标点）
                const chineseChars = text.match(/[\u4e00-\u9fa5]/g) || [];
                return chineseChars.length;
            }
            
            // 更新进度显示
            function updateProgress(additionalText = '') {
                if (additionalText) {
                    currentWords += countChineseWords(additionalText);
                }
                
                currentWordsSpan.textContent = currentWords;
                
                // 计算进度百分比
                const progress = Math.min(Math.round((currentWords / targetWords) * 100), 100);
                progressText.textContent = `${progress}%`;
                progressBar.style.width = `${progress}%`;
                
                // 根据进度调整进度条颜色
                if (progress >= 100) {
                    progressBar.style.backgroundColor = '#10b981'; // 绿色
                } else if (progress >= 80) {
                    progressBar.style.backgroundColor = '#f59e0b'; // 黄色
                } else {
                    progressBar.style.backgroundColor = '#3b82f6'; // 蓝色
                }
            }
            
            // 重置进度
            function resetProgress() {
                currentWords = 0;
                currentWordsSpan.textContent = currentWords;
                progressText.textContent = '0%';
                progressBar.style.width = '0%';
                progressBar.style.backgroundColor = '#3b82f6';
            }
            
            // 更新状态显示
            function updateStatus(text, isActive = false) {
                statusText.textContent = text;
                if (isActive) {
                    statusDot.classList.add('active');
                } else {
                    statusDot.classList.remove('active');
                }
            }
            
            // 显示错误
            function showError(message) {
                errorElement.textContent = message;
                errorElement.classList.add('show');
            }
            
            // 隐藏错误
            function hideError() {
                errorElement.classList.remove('show');
            }
            
            // 生成小说函数（流式输出）
            async function generateNovel() {
                // 获取输入值
                const apiKey = apiKeyInput.value.trim();
                const novelTitle = novelTitleInput.value.trim();
                const novelPlot = novelPlotInput.value.trim();
                const novelGenre = novelGenreSelect.value;
                
                // 验证输入
                if (!apiKey) {
                    showError('请输入API密钥');
                    return;
                }
                
                if (!novelTitle) {
                    showError('请输入小说名称');
                    return;
                }
                
                if (!novelPlot) {
                    showError('请输入小说主线情节');
                    return;
                }
                
                // 设置UI状态
                generateBtn.disabled = true;
                stopBtn.disabled = false;
                resultContent.textContent = '';
                resultContent.classList.add('streaming');
                updateStatus('正在生成...', true);
                hideError();
                resetProgress();
                
                // 构建提示词（根据字数调整提示）
                let lengthInstruction = '';
                if (targetWords <= 1000) {
                    lengthInstruction = '请生成小说的第一章内容，包括章节标题和简要情节发展，大约1000字左右。';
                } else if (targetWords <= 2000) {
                    lengthInstruction = '请生成小说的前两章内容，每章包括章节标题和详细情节发展，大约2000字左右。';
                } else if (targetWords <= 3000) {
                    lengthInstruction = '请生成小说的前三章内容，每章包括章节标题和详细情节发展，大约3000字左右。';
                } else {
                    lengthInstruction = `请生成小说的前几章内容，每章包括章节标题和详细情节发展，总字数大约${targetWords}字左右。`;
                }
                
                const prompt = `请创作一部${novelGenre}小说，小说名为《${novelTitle}》。主线情节：${novelPlot}。${lengthInstruction}`;
                
                try {
                    // 计算max_tokens（假设1个中文字约等于2个tokens）
                    const maxTokens = Math.min(targetWords * 2, 8000);
                    
                    // 调用DMXAPI（流式输出）
                    const response = await fetch('https://www.dmxapi.cn/v1/chat/completions', {
                        method: 'POST',
                        headers: {
                            'Content-Type': 'application/json',
                            'Authorization': `Bearer ${apiKey}`
                        },
                        body: JSON.stringify({
                            model: 'mimo-v2-flash-free',
                            messages: [
                                {
                                    role: 'user',
                                    content: prompt
                                }
                            ],
                            stream: true,  // 启用流式输出
                            temperature: 0.8,
                            max_tokens: maxTokens
                        })
                    });
                    
                    if (!response.ok) {
                        throw new Error(`API请求失败: ${response.status}`);
                    }
                    
                    streamController = new AbortController();
                    isStreaming = true;
                    
                    // 读取流数据
                    const reader = response.body.getReader();
                    const decoder = new TextDecoder('utf-8');
                    
                    while (isStreaming) {
                        const {done, value} = await reader.read();
                        
                        if (done) {
                            break;
                        }
                        
                        // 解码数据块
                        const chunk = decoder.decode(value);
                        const lines = chunk.split('\n');
                        
                        for (const line of lines) {
                            if (line.startsWith('data: ')) {
                                const data = line.slice(6);
                                
                                if (data === '[DONE]') {
                                    isStreaming = false;
                                    break;
                                }
                                
                                try {
                                    const parsed = JSON.parse(data);
                                    const content = parsed.choices[0]?.delta?.content || '';
                                    
                                    // 将内容追加到结果区域
                                    if (content) {
                                        resultContent.textContent += content;
                                        // 更新进度
                                        updateProgress(content);
                                        // 滚动到底部
                                        resultContent.scrollTop = resultContent.scrollHeight;
                                    }
                                } catch (e) {
                                    // 忽略JSON解析错误
                                }
                            }
                        }
                    }
                    
                    // 完成生成
                    updateStatus('生成完成');
                    resultContent.classList.remove('streaming');
                    
                } catch (error) {
                    if (error.name === 'AbortError') {
                        updateStatus('已停止');
                        resultContent.textContent += '\n\n【生成已停止】';
                    } else {
                        console.error('生成小说时出错:', error);
                        showError(`生成失败: ${error.message}`);
                        updateStatus('生成失败');
                    }
                    resultContent.classList.remove('streaming');
                } finally {
                    // 重置UI状态
                    generateBtn.disabled = false;
                    stopBtn.disabled = true;
                    isStreaming = false;
                    streamController = null;
                }
            }
            
            // 停止生成函数
            function stopGeneration() {
                if (streamController) {
                    streamController.abort();
                }
                isStreaming = false;
                stopBtn.disabled = true;
                updateStatus('正在停止...');
            }
            
            // 绑定事件
            generateBtn.addEventListener('click', generateNovel);
            stopBtn.addEventListener('click', stopGeneration);
            
            // 按Enter键生成
            document.addEventListener('keydown', function(e) {
                if (e.key === 'Enter' && e.ctrlKey && !generateBtn.disabled) {
                    generateNovel();
                }
            });
            
            // API密钥输入提示
            apiKeyInput.addEventListener('focus', function() {
                hideError();
            });
            
            // 初始状态
            updateStatus('等待生成');
            targetWordsSpan.textContent = targetWords;
            
            // 初始化自定义字数输入
            customWordsInput.value = targetWords;
        });
    </script>
</body>
</html>

四、生产环境挑战与解决方案

（方案来源于网络，可能存在纰漏）

挑战1：生成不可控导致内容风险

解决方案：

启用DMX的content_safety_filter参数，设置strictness=high
在后端实现关键词黑名单与语义相似度检测（使用sentence-transformers）
关键情节节点引入人工审核标记，生成后暂停等待确认

挑战2：响应延迟影响用户体验

优化手段：

流式传输 ：设置stream=true，首字节响应时间（TTFB）从8s降至0.8s
智能缓存：对相同题材+风格+关键词的生成请求，缓存7天，命中率可达25%
预生成策略：在用户输入时后台预加载模型，减少冷启动延迟

挑战3：成本爆炸式增长

控制措施：

精确计算token用量：输入token（提示+上下文）+ 输出token × 1.2（安全冗余）
实现配额分层：免费用户单次生成≤1000token，付费用户按等级递增
质量兜底机制：当生成内容重复度>70%时自动重试，避免浪费额度

五、高级应用场景架构

场景1：交互式共创系统

实现"AI生成-用户选择分支-续写"的循环：

AI生成3个情节走向选项
用户投票选择
将选择结果作为强制指令写入下一轮提示
记录决策树，支持故事线回溯

场景2：世界观一致性维护

创建"世界观知识库"JSON，包含：

地理设定（大陆、城市、天气系统）
魔法规则（能量来源、施法限制、代价）
人物档案（性格标签、口头禅、关系图谱）

每次生成前将相关知识片段注入上下文，实现类似"冰与火之歌"的复杂世界架构。

六、监控与迭代体系

核心指标观测：

用户完成率：生成开始后完整阅读比例
编辑距离：生成内容与用户最终发布版本的差异度
二次生成率：同一主题重复请求次数（反映满意度）

数据驱动优化：收集用户编辑行为，构建反馈数据集。每月微调一次提示模板，将高频人工修改模式转化为自动规则。

结语

将DMXAPI视为创作伙伴而非黑盒，通过精细化参数调控、健壮的后端架构、数据驱动的迭代，方能构建真正具有商业价值的小说生成系统。技术挑战背后，是对叙事本质的深刻理解与技术实现的精巧平衡。