support long audio

.gitattributes

@@ -69,3 +69,15 @@ ax_meeting/recordings/fb6451b9-4df9-48a7-9ca3-753155a5a2d8.webm filter=lfs diff=
 ax_meeting/recordings/fde9916e-930d-49d3-9f23-9db3fef0a63e.mp3 filter=lfs diff=lfs merge=lfs -text
 ax_meeting/recordings/fde9916e-930d-49d3-9f23-9db3fef0a63e.webm filter=lfs diff=lfs merge=lfs -text
 wav/fb6451b9-4df9-48a7-9ca3-753155a5a2d8.mp3 filter=lfs diff=lfs merge=lfs -text
+ax_meeting/_upload_1566a625-52a6-4663-a62b-7570dac7b7dd_20200327_2P.wav filter=lfs diff=lfs merge=lfs -text
+ax_meeting/_upload_1676128a-2d16-45b0-a3d5-faa94dea89bd_20200327_2P.wav filter=lfs diff=lfs merge=lfs -text
+ax_meeting/_upload_176e329f-da53-4e64-85ca-4ba3f7ac76a3_20200327_2P.wav filter=lfs diff=lfs merge=lfs -text
+ax_meeting/_upload_911af462-37e5-4314-911b-78fd3024cb7f_20200327_2P.wav filter=lfs diff=lfs merge=lfs -text
+ax_meeting/_upload_cfac62fb-1bd0-425f-8e31-317aa922604e_20200327_2P.wav filter=lfs diff=lfs merge=lfs -text
+ax_meeting/_upload_e4b352ae-a156-4e46-b41f-37313325fcfe_20200327_2P.wav filter=lfs diff=lfs merge=lfs -text
+ax_meeting/_upload_eb77c179-4271-48e8-8fda-8e0dc528417c_20200327_2P.wav filter=lfs diff=lfs merge=lfs -text
+wav/cache_test/clip_01.wav filter=lfs diff=lfs merge=lfs -text
+wav/cache_test/clip_02.wav filter=lfs diff=lfs merge=lfs -text
+wav/cache_test/clip_03.wav filter=lfs diff=lfs merge=lfs -text
+wav/cache_test/clip_04.wav filter=lfs diff=lfs merge=lfs -text
+wav/cache_test/long_5min.wav filter=lfs diff=lfs merge=lfs -text

.pytest_cache/v/cache/nodeids

@@ -1,6 +1,15 @@
 [
+  "tests/test_lightweight.py::TestIncrementalSummarizer::test_summarize_incrementally_uses_previous_summary_and_returns_last_round",
   "tests/test_lightweight.py::TestPickSpeaker::test_pick_speaker_no_overlap",
   "tests/test_lightweight.py::TestPickSpeaker::test_pick_speaker_overlap",
+  "tests/test_lightweight.py::TestServerStartup::test_preload_models_calls_ensure_loaded",
+  "tests/test_lightweight.py::TestSummarizerHelpers::test_split_text_fixed_size_chunks_by_chars",
+  "tests/test_lightweight.py::TestSummarizerHelpers::test_split_text_fixed_size_empty",
+  "tests/test_lightweight.py::TestSummarizerHelpers::test_split_text_fixed_size_invalid_chunk_size",
+  "tests/test_lightweight.py::TestSummarizerHelpers::test_summary_chunk_chars_uses_environment_override",
+  "tests/test_lightweight.py::TestSummarizerHelpers::test_summary_target_range_from_scalar",
+  "tests/test_lightweight.py::TestSummarizerHelpers::test_summary_target_range_from_tuple",
+  "tests/test_lightweight.py::TestSummarizerHelpers::test_summary_target_range_normalizes_reverse_order",
   "tests/test_lightweight.py::TestTextCleaner::test_angle_tokens",
   "tests/test_lightweight.py::TestTextCleaner::test_concat_tokens",
   "tests/test_lightweight.py::TestTextCleaner::test_empty_after_clean",

app/config.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import os
 
 SAMPLE_RATE = 16000
 
@@ -14,6 +15,8 @@ MIN_SEGMENT_MS = 300
 # Merge VAD segments shorter than this in offline diarization
 MERGE_VAD_MAX_LEN_MS = 15 * 1000
 
-# LLM summarization chunking
-SUMMARY_CHUNK_CHARS = 1000
-SUMMARY_TARGET_CHARS = 100
+# LLM summarization chunking, measured in transcript characters instead of tokens
+SUMMARY_CHUNK_CHARS = int(os.getenv("SUMMARY_CHUNK_CHARS", 12 * 1000))
+
+# Target summary length range in Chinese characters
+SUMMARY_TARGET_CHARS = (100, 500)

app/summarizer.py

@@ -11,26 +11,24 @@ except Exception as e:  # pragma: no cover
     OpenAI = None
 
 
-def _split_text(text: str, max_chars: int) -> List[str]:
+def _split_text_fixed_size(text: str, chunk_chars: int) -> List[str]:
     text = text.strip()
     if not text:
         return []
-    chunks = []
-    buf = []
-    cur = 0
-    for line in text.splitlines():
-        if cur + len(line) + 1 > max_chars and buf:
-            chunks.append("\n".join(buf))
-            buf = []
-            cur = 0
-        buf.append(line)
-        cur += len(line) + 1
-    if buf:
-        chunks.append("\n".join(buf))
-    # Fallback if a single line is too long
-    if len(chunks) == 1 and len(chunks[0]) > max_chars:
-        chunks = [chunks[0][i:i + max_chars] for i in range(0, len(chunks[0]), max_chars)]
-    return chunks
+    if chunk_chars <= 0:
+        raise ValueError("SUMMARY_CHUNK_CHARS must be > 0")
+    return [text[i:i + chunk_chars] for i in range(0, len(text), chunk_chars)]
+
+
+def _summary_target_range() -> tuple[int, int]:
+    if isinstance(SUMMARY_TARGET_CHARS, (tuple, list)) and len(SUMMARY_TARGET_CHARS) == 2:
+        min_chars = int(SUMMARY_TARGET_CHARS[0])
+        max_chars = int(SUMMARY_TARGET_CHARS[1])
+    else:
+        min_chars = max_chars = int(SUMMARY_TARGET_CHARS)
+    if min_chars > max_chars:
+        min_chars, max_chars = max_chars, min_chars
+    return min_chars, max_chars
 
 
 class IncrementalSummarizer:
@@ -46,24 +44,50 @@ class IncrementalSummarizer:
         self.model = model if model is not None else os.getenv("OPENAI_MODEL", "AXERA-TECH/Qwen3-1.7B")
 
     def summarize_incrementally(self, transcript: str) -> str:
-        chunks = _split_text(transcript, SUMMARY_CHUNK_CHARS)
+        transcript = transcript.strip()
+        chunks = _split_text_fixed_size(transcript, SUMMARY_CHUNK_CHARS)
         if not chunks:
             return ""
 
+        min_chars, max_chars = _summary_target_range()
+        total_chunks = len(chunks)
+        print(f"[summarizer] transcript_total_chars={len(transcript)}")
+        print(f"[summarizer] summary_chunk_chars={SUMMARY_CHUNK_CHARS}, total_chunks={total_chunks}")
+
         summary = ""
-        for idx, chunk in enumerate(chunks):
+        for idx, chunk in enumerate(chunks, start=1):
+            print(f"[summarizer] chunk_{idx}_chars={len(chunk)}")
+            if idx == 1:
+                previous_summary_block = "无。这是第一轮请求。"
+            else:
+                previous_summary_block = (
+                    "以下内容是上一轮请求返回的摘要，属于更早时序的内容，不是新的原始会议文本。\n"
+                    f"{summary}"
+                )
+
             prompt = (
-                "你是会议纪要助手。"\
-                f"\n前情提要(可为空): {summary}"\
-                f"\n本段会议文本(第{idx + 1}段):\n{chunk}"\
-                f"\n请将本段内容总结为约{SUMMARY_TARGET_CHARS}字中文摘要。"\
-                "输出要求: 只输出摘要正文, 不要标题。/no_think"
+                "你是会议纪要助手。"
+                f"\n当前是第{idx}/{total_chunks}轮总结请求，请严格按照时间顺序理解内容。"
+                "\n请区分两类输入："
+                "\n1. <previous_summary> 标签内是上一轮摘要，表示已处理过的、更早时序内容；"
+                "\n2. <current_transcript> 标签内是本轮新发送的原始 transcript，时序上晚于上一轮摘要。"
+                "\n<previous_summary>"
+                f"\n{previous_summary_block}"
+                "\n</previous_summary>"
+                "\n<current_transcript>"
+                "\n以下内容是本轮新发送的 transcript 原文，请与上一轮摘要衔接后理解："
+                f"\n{chunk}"
+                "\n</current_transcript>"
+                "\n请基于 <previous_summary> 和 <current_transcript> 生成一个更新后的摘要，覆盖截至当前轮为止的全部会议信息。"
+                "\n请务必保留此前各轮与本轮中出现的关键决策、结论、待办事项、负责人、时间点、风险与分歧；若新内容与旧摘要有关，请在更新摘要时延续并整合，不要遗漏已有关键事实。"
+                f"\n请根据内容丰富度和文本长度，将摘要控制在约{min_chars}到{max_chars}字。"
+                "\n输出要求: 只输出摘要正文，不要标题，不要重复标签。/no_think"
             )
 
             resp = self.client.chat.completions.create(
                 model=self.model,
                 messages=[
-                    {"role": "system", "content": "你擅长从会议记录中抽取关键信息并总结。"},
+                    {"role": "system", "content": "你擅长按时间顺序理解会议记录，并基于已有摘要与新增文本生成连贯的更新摘要。"},
                     {"role": "user", "content": prompt},
                 ],
                 temperature=0.2,
@@ -71,5 +95,5 @@ class IncrementalSummarizer:
 
             summary = (resp.choices[0].message.content or "").strip()
             summary = re.sub(r"<think>.*?</think>", "", summary, flags=re.DOTALL).strip()
-            print(f"Summary chunk {idx + 1}: {summary}")
+            print(f"Summary chunk {idx}: {summary}")
         return summary

ax_meeting.egg-info/PKG-INFO

@@ -71,78 +71,77 @@ For those who are interested in model conversion, you can try to export axmodel
 -  链接互联网，确保 AX650N 的设备能正常执行 apt install, pip install 等指令   
 -  已验证设备：AX650N DEMO Board  
 
-## Python API 运行
-
-在python3.10(验证)  
-Requirements  
-
-```
-pip3 install -r requirements.txt
-```
-
 ## 流式会议纪要 Web Demo
 
-支持浏览器麦克风实时分段转录，会议结束后自动做说话人聚类 + ASR，并调用 OpenAI 兼容接口生成会议纪要。
+总体功能：支持浏览器麦克风实时分段转录，会议结束后自动做说话人聚类 + ASR，并调用 OpenAI 兼容接口生成会议纪要。
 
-启动：
+### 环境配置
 
 ```bash
-python -m ax_meeting.server
-```
-
-服务会在启动阶段预加载 VAD / 说话人 / ASR 相关 axmodel，首次会议转写不再叠加模型加载耗时。
-
-浏览器访问：
+cd 3D-Speaker-MT.axera
 
-```
-http://127.0.0.1:8000
-```
-
-环境变量（可选，用作会议纪要生成）：
+pip3 install -r requirements.txt
 
+pip3 install ./dist/ax_meeting-0.1.1-py3-none-any.whl
 ```
-OPENAI_API_KEY=xxx
-OPENAI_BASE_URL=http://127.0.0.1:8001/v1  # 本地 OpenAI 协议服务时设置
-OPENAI_MODEL=AXERA-TECH/Qwen3-1.7B
-HOST=0.0.0.0
-PORT=8000
-SSL_CERT=cert.pem
-SSL_KEY=key.pem
-AX_MODEL_DIR=/path/to/ax_model
-```
-
-依赖提示（WebSocket）：
-- 请确保安装了 `websockets` 或 `uvicorn[standard]`，否则浏览器实时流式会失败
-
-设备权限提示：
-- 如果遇到 `/dev/axcl_host` 权限错误，请用有权限的账号或 `sudo` 运行
 
-axengine 依赖提示：
-- 如果无法从 pip 获取 `pyaxengine`，请将本地 wheel 放到 `ax_meeting/vendor/`，或设置 `AXENGINE_WHEEL=/path/to/pyaxengine.whl`
-
-HTTPS（推荐，便于浏览器麦克风权限）：
+HTTPS（推荐本地生成自签证书，便于浏览器麦克风权限）：
 
 ```bash
 openssl req -x509 -newkey rsa:2048 -nodes \\
   -keyout key.pem -out cert.pem -days 365 \\
-  -subj "/CN=<你的IP>"
+  -subj "/CN=<你的IP>" 
 ```
 
+### 实时及离线会议转录服务
+
 ```bash
+# 使用本地生成的证书
 SSL_CERT=cert.pem SSL_KEY=key.pem python -m ax_meeting.server
-```
 
-使用包内自签证书（默认打包在 `ax_meeting/certs/`）：
-
-```bash
+# 或者使用包内自签证书（默认打包在 ax_meeting/certs/）
 SSL_CERT=ax_meeting/certs/cert.pem SSL_KEY=ax_meeting/certs/key.pem python -m ax_meeting.server
-```
 
+Local URL:  https://10.126.29.13:8000
+AX_ASR_OUTPUT_TIMESTAMP=0
+INFO:     Started server process [3930453]
+INFO:     Waiting for application startup.
+Preloading AX models...
+[INFO] Using provider: AXCLRTExecutionProvider
+[INFO] SOC Name: AX650N
+[INFO] VNPU type: VNPUType.DISABLED
+[INFO] Compiler version: 4.2 057581a9
+[INFO] Using provider: AXCLRTExecutionProvider
+[INFO] SOC Name: AX650N
+[INFO] VNPU type: VNPUType.DISABLED
+[INFO] Compiler version: 4.2 057581a9
+[INFO] Using provider: AXCLRTExecutionProvider
+[INFO] SOC Name: AX650N
+[INFO] VNPU type: VNPUType.DISABLED
+[INFO] Compiler version: 4.2 2cc4ac86
+AX model preload complete.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on https://0.0.0.0:8000 (Press CTRL+C to quit)
+```
 网页参数说明（说话人聚类）：
 - `mer_cos` 越小越容易分开说话人（更敏感，可能误分）
 - `min_cluster_size` 越小越容易分出更多说话人
 - `AHC` 更稳定但可能偏保守，`spectral` 更灵敏
 
+
+### 会议转录+本地大模型纪要总结服务
+
+默认已启动本地大模型服务端口8001，详细服务启动见：[AXERA-TECH/Qwen3-1.7B](https://huggingface.co/AXERA-TECH/Qwen3-1.7B)
+
+```
+chmod +x start_meeting_server.sh
+./start_meeting_server.sh
+```
+![meeting_ui.jpg](assert/meeting_ui.jpg)
+
+设备权限提示：
+- 如果遇到 `/dev/axcl_host` 权限错误，请用有权限的账号或 `sudo` 运行
+
 ## 生成 wheel 包
 
 ```bash
@@ -151,9 +150,6 @@ SSL_CERT=ax_meeting/certs/cert.pem SSL_KEY=ax_meeting/certs/key.pem python -m ax
 
 生成结果在 `dist/` 目录。
 
-![meeting_demo.png](assert/meeting_demo.png)
-
-
 ## 离线处理脚本
 
 对单个会议音频文件执行说话人聚类 + ASR，并导出文本，可选会议总结（LLM 通过参数配置）：

ax_meeting/_upload_1566a625-52a6-4663-a62b-7570dac7b7dd_20200327_2P.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bd799992bb9327844b78547d3c91b444376cf359b5fdc03f26c14c1c921f0c0
+size 31283820

ax_meeting/_upload_1676128a-2d16-45b0-a3d5-faa94dea89bd_20200327_2P.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bd799992bb9327844b78547d3c91b444376cf359b5fdc03f26c14c1c921f0c0
+size 31283820

ax_meeting/_upload_176e329f-da53-4e64-85ca-4ba3f7ac76a3_20200327_2P.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bd799992bb9327844b78547d3c91b444376cf359b5fdc03f26c14c1c921f0c0
+size 31283820

ax_meeting/_upload_911af462-37e5-4314-911b-78fd3024cb7f_20200327_2P.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bd799992bb9327844b78547d3c91b444376cf359b5fdc03f26c14c1c921f0c0
+size 31283820

ax_meeting/_upload_cfac62fb-1bd0-425f-8e31-317aa922604e_20200327_2P.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bd799992bb9327844b78547d3c91b444376cf359b5fdc03f26c14c1c921f0c0
+size 31283820

ax_meeting/_upload_e4b352ae-a156-4e46-b41f-37313325fcfe_20200327_2P.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bd799992bb9327844b78547d3c91b444376cf359b5fdc03f26c14c1c921f0c0
+size 31283820

ax_meeting/_upload_eb77c179-4271-48e8-8fda-8e0dc528417c_20200327_2P.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3bd799992bb9327844b78547d3c91b444376cf359b5fdc03f26c14c1c921f0c0
+size 31283820

ax_meeting/config.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import os
 
 SAMPLE_RATE = 16000
 
@@ -17,6 +18,8 @@ MERGE_VAD_MAX_LEN_MS = 15 * 1000
 # For diarization output segments, keep shorter to avoid mixing speakers
 DIAR_MERGE_VAD_MAX_LEN_MS = 8 * 1000
 
-# LLM summarization chunking
-SUMMARY_CHUNK_CHARS = 1000
-SUMMARY_TARGET_CHARS = 100
+# LLM summarization chunking, measured in transcript characters instead of tokens
+SUMMARY_CHUNK_CHARS = int(os.getenv("SUMMARY_CHUNK_CHARS", 12 * 1000))
+
+# Target summary length range in Chinese characters
+SUMMARY_TARGET_CHARS = (100, 500)

ax_meeting/diar_asr_cli.py

@@ -1,21 +1,29 @@
-# -*- coding: utf-8 -*-
-import argparse
-from pathlib import Path
+# -*- coding: utf-8 -*-
+import argparse
+import os
+from pathlib import Path
 
 import numpy as np
 import soundfile as sf
 
 from ax_meeting.model_bundle import ModelBundle
 from ax_meeting.utils.vad_utils import merge_vad
-from ax_meeting.utils.ax_cam_bin import (
+from ax_meeting.utils.ax_cam_bin import (
     chunk,
     distribute_spk,
     do_clustering,
     get_trans_sentence_sensevoice,
-)
+)
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.getenv(name)
+    if raw is None or raw == "":
+        return default
+    return float(raw)
 
 
-def load_audio(path: str, target_sr: int = 16000) -> np.ndarray:
+def load_audio(path: str, target_sr: int = 16000) -> np.ndarray:
     audio, sr = sf.read(path, dtype="float32")
     if audio.ndim > 1:
         audio = audio.mean(axis=1)
@@ -27,33 +35,110 @@ def load_audio(path: str, target_sr: int = 16000) -> np.ndarray:
         x_old = np.linspace(0, 1, num=len(audio), endpoint=False)
         x_new = np.linspace(0, 1, num=new_len, endpoint=False)
         audio = np.interp(x_new, x_old, audio).astype(np.float32)
-    return audio
-
-
-def diar_asr(
-    bundle: ModelBundle,
-    speech: np.ndarray,
-    spk_params: dict | None = None,
-    fs: int = 16000,
-) -> str:
-    if speech.size == 0:
-        return ""
-
-    res_vad = bundle.vad_infer(speech)
-    if not res_vad:
-        return ""
-
-    vad_segments = merge_vad(res_vad, 15 * 1000)
+    return audio
+
+
+def _merge_overlapping_vad(vad_segments: list[list[int]], max_gap_ms: int = 0) -> list[list[int]]:
+    if not vad_segments:
+        return []
+    ordered = sorted(vad_segments, key=lambda item: (item[0], item[1]))
+    merged = [ordered[0]]
+    for start_ms, end_ms in ordered[1:]:
+        last = merged[-1]
+        if start_ms <= last[1] + max_gap_ms:
+            last[1] = max(last[1], end_ms)
+        else:
+            merged.append([start_ms, end_ms])
+    return merged
+
+
+def detect_vad_segments_chunked(
+    bundle: ModelBundle,
+    speech: np.ndarray,
+    fs: int = 16000,
+    chunk_sec: float | None = None,
+    overlap_sec: float | None = None,
+) -> list[list[int]]:
+    if speech.size == 0:
+        return []
+
+    chunk_sec = _env_float("DIAR_VAD_CHUNK_SEC", 300.0) if chunk_sec is None else chunk_sec
+    overlap_sec = _env_float("DIAR_VAD_OVERLAP_SEC", 2.0) if overlap_sec is None else overlap_sec
+    duration_sec = speech.shape[0] / float(fs)
+    if chunk_sec <= 0 or duration_sec <= chunk_sec:
+        return bundle.vad_infer(speech)
+
+    chunk_samples = max(int(chunk_sec * fs), 1)
+    overlap_samples = max(int(overlap_sec * fs), 0)
+    total_samples = speech.shape[0]
+    collected: list[list[int]] = []
+
+    for core_start in range(0, total_samples, chunk_samples):
+        core_end = min(core_start + chunk_samples, total_samples)
+        read_start = max(0, core_start - overlap_samples)
+        read_end = min(total_samples, core_end + overlap_samples)
+        chunk_audio = speech[read_start:read_end]
+        local_segments = bundle.vad_infer(chunk_audio)
+        core_start_ms = int(core_start / fs * 1000)
+        core_end_ms = int(core_end / fs * 1000)
+        read_start_ms = int(read_start / fs * 1000)
+        audio_end_ms = int(total_samples / fs * 1000)
+
+        for local_start_ms, local_end_ms in local_segments:
+            global_start_ms = max(0, int(local_start_ms) + read_start_ms)
+            global_end_ms = min(audio_end_ms, int(local_end_ms) + read_start_ms)
+            if global_end_ms <= global_start_ms:
+                continue
+            mid_ms = (global_start_ms + global_end_ms) // 2
+            if core_start_ms <= mid_ms < core_end_ms:
+                collected.append([global_start_ms, global_end_ms])
+
+    return _merge_overlapping_vad(collected, max_gap_ms=0)
+
+
+def _remap_speaker_labels_by_first_start(diar_results: list[list[float]]) -> list[list[float]]:
+    if not diar_results:
+        return []
+    first_start_by_spk: dict[int, float] = {}
+    for start_sec, _end_sec, spk in sorted(diar_results, key=lambda item: (item[0], item[1])):
+        spk_id = int(spk)
+        if spk_id not in first_start_by_spk:
+            first_start_by_spk[spk_id] = float(start_sec)
+    spk_map = {
+        spk_id: new_id
+        for new_id, spk_id in enumerate(
+            sorted(first_start_by_spk, key=lambda spk_id: (first_start_by_spk[spk_id], spk_id))
+        )
+    }
+    return [[start_sec, end_sec, spk_map[int(spk)]] for start_sec, end_sec, spk in diar_results]
+
+
+def diar_asr(
+    bundle: ModelBundle,
+    speech: np.ndarray,
+    spk_params: dict | None = None,
+    fs: int = 16000,
+    vad_merge_max_len_ms: int = 15 * 1000,
+) -> str:
+    if speech.size == 0:
+        return ""
+
+    res_vad = detect_vad_segments_chunked(bundle, speech, fs=fs)
+    if not res_vad:
+        return ""
+
+    vad_segments = merge_vad(res_vad, vad_merge_max_len_ms)
     vad_time = [[vad_t[0] / 1000, vad_t[1] / 1000] for vad_t in res_vad]
     chunks = [c for (st, ed) in vad_time for c in chunk(st, ed)]
 
     if not chunks:
         return ""
 
-    embeddings = bundle.speaker_infer(speech, fs, chunks=chunks)
-    _, diar_results = do_clustering(chunks, embeddings, speaker_num=None, params=spk_params)
-
-    lines = []
+    embeddings = bundle.speaker_infer(speech, fs, chunks=chunks)
+    _, diar_results = do_clustering(chunks, embeddings, speaker_num=None, params=spk_params)
+    diar_results = _remap_speaker_labels_by_first_start(diar_results)
+
+    lines = []
     all_metadata = {"merged_words": [], "merged_timestamps": []}
     audio_duration = speech.shape[0] / float(fs) if fs > 0 else 0.0
 

ax_meeting/engines.py

@@ -11,6 +11,7 @@ import soundfile as sf
 from ax_meeting.model_bundle import ModelBundle
 from ax_meeting.config import SAMPLE_RATE, PAUSE_MS, MIN_SEGMENT_MS, MERGE_VAD_MAX_LEN_MS, DIAR_MERGE_VAD_MAX_LEN_MS
 from ax_meeting.diar_utils import pick_speaker
+from ax_meeting.diar_asr_cli import diar_asr
 from ax_meeting.utils.vad_utils import merge_vad
 from ax_meeting.utils.ax_cam_bin import chunk, distribute_spk, do_clustering, get_trans_sentence_sensevoice
 
@@ -173,6 +174,11 @@ class VadAsrEngine:
                 out.append(VadAsrSegment(start_ms, end_ms, text.strip(), seg_audio))
         return out
 
+    def reset(self) -> None:
+        self.audio_chunks = []
+        self.total_samples = 0
+        self.last_processed_ms = 0
+
 
 class DiarAsrEngine:
     def __init__(
@@ -205,60 +211,13 @@ class DiarAsrEngine:
         if not chunks:
             return ""
         speech = np.concatenate(chunks, axis=0)
-        # return diar_asr(self.bundle, speech, fs=self.sample_rate, spk_params=spk_params)
-        res_vad = self.bundle.vad_infer(speech)
-        if not res_vad:
-            return ""
-
-        vad_segments = merge_vad(res_vad, DIAR_MERGE_VAD_MAX_LEN_MS)
-        vad_time = [[vad_t[0] / 1000, vad_t[1] / 1000] for vad_t in res_vad]
-        chunks = [c for (st, ed) in vad_time for c in chunk(st, ed)]
-        if not chunks:
-            return ""
-
-        embeddings = self.bundle.speaker_infer(speech, self.sample_rate, chunks=chunks)
-        _, diar_results = do_clustering(chunks, embeddings, speaker_num=None, params=spk_params)
-
-        lines = []
-        all_metadata = {"merged_words": [], "merged_timestamps": []}
-        audio_duration = speech.shape[0] / float(self.sample_rate) if self.sample_rate > 0 else 0.0
-
-        for i, segment in enumerate(vad_segments):
-            segment_start, segment_end = segment
-            start_sample = int(segment_start / 1000 * self.sample_rate)
-            end_sample = min(int(segment_end / 1000 * self.sample_rate), speech.shape[0])
-            segment_speech = speech[start_sample:end_sample]
-            time_offset_sec = segment_start / 1000.0
-
-            _, meta = self.bundle.asr_infer(
-                segment_speech,
-                output_timestamp=True,
-                key=f"segment_{i}",
-            )
-
-            seg_words = meta.get("merged_words", [])
-            seg_timestamps = meta.get("merged_timestamps", [])
-            if seg_words and seg_timestamps and len(seg_words) == len(seg_timestamps):
-                adjusted_timestamps = [
-                    [
-                        min(ts[0] + time_offset_sec, audio_duration),
-                        min(ts[1] + time_offset_sec, audio_duration),
-                    ]
-                    for ts in seg_timestamps
-                ]
-                all_metadata["merged_words"].extend(seg_words)
-                all_metadata["merged_timestamps"].extend(adjusted_timestamps)
-
-        if all_metadata["merged_words"]:
-            output_asr = {
-                "merged_words": all_metadata["merged_words"],
-                "merged_timestamps": all_metadata["merged_timestamps"],
-            }
-            asr_timestamps = get_trans_sentence_sensevoice(output_asr)
-            sentence_info_with_spk = distribute_spk(asr_timestamps, diar_results)
-            lines = [
-                f"Speaker_{spk}: [{timeinterval[0]:.3f} {timeinterval[1]:.3f}] {text_string}"
-                for text_string, timeinterval, spk in sentence_info_with_spk
-            ]
-
-        return "\n".join(lines)
+        return diar_asr(
+            self.bundle,
+            speech,
+            fs=self.sample_rate,
+            spk_params=spk_params,
+            vad_merge_max_len_ms=DIAR_MERGE_VAD_MAX_LEN_MS,
+        )
+
+    def reset(self) -> None:
+        self.audio_chunks = []

ax_meeting/pipeline.py

@@ -151,3 +151,12 @@ class StreamingMeetingSession:
             fs=self.sample_rate,
             spk_params=getattr(self, "spk_params", None),
         )
+
+    def release(self) -> None:
+        self.audio_chunks = []
+        self.total_samples = 0
+        self.last_processed_ms = 0
+        self.last_vad_check_ts = 0.0
+        self.processing = False
+        if hasattr(self, "spk_params"):
+            delattr(self, "spk_params")

ax_meeting/server.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 import asyncio
 from contextlib import asynccontextmanager
+from datetime import datetime
+import gc
 import json
 import os
 import uuid
@@ -19,6 +21,7 @@ from ax_meeting.summarizer import IncrementalSummarizer
 
 APP_DIR = Path(__file__).parent
 STATIC_DIR = APP_DIR / "static"
+RESULT_DIR = Path(os.getenv("RESULT_TXT_DIR", "result_txt")).resolve()
 
 def preload_models() -> None:
     print("Preloading AX models...")
@@ -43,6 +46,44 @@ TRANSCRIPT_STORE = {}
 RECORDING_STORE = {}
 RECORDING_DIR = APP_DIR / "recordings"
 RECORDING_DIR.mkdir(exist_ok=True)
+DISABLE_SUMMARY = os.getenv("DISABLE_SUMMARY", "0").lower() in {"1", "true", "yes", "on"}
+
+
+def _malloc_trim() -> None:
+    try:
+        import ctypes
+
+        ctypes.CDLL("libc.so.6").malloc_trim(0)
+    except Exception:
+        pass
+
+
+def release_process_memory() -> None:
+    gc.collect()
+    _malloc_trim()
+
+
+def persist_result_texts(transcript: str, summary: str) -> tuple[Path, Path]:
+    RESULT_DIR.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    transcript_path = RESULT_DIR / f"{stamp}_transcript.txt"
+    summary_path = RESULT_DIR / f"{stamp}_summary.txt"
+    transcript_path.write_text(transcript, encoding="utf-8")
+    summary_path.write_text(summary, encoding="utf-8")
+    return transcript_path, summary_path
+
+
+def clear_session_cache(session_id: str, session: StreamingMeetingSession | None = None) -> None:
+    TRANSCRIPT_STORE.pop(session_id, None)
+    recording_path = RECORDING_STORE.pop(session_id, None)
+    if recording_path:
+        try:
+            recording_path.unlink(missing_ok=True)
+        except Exception:
+            pass
+    if session is not None:
+        session.release()
+    release_process_memory()
 
 
 async def summarize_transcript_text(
@@ -51,6 +92,8 @@ async def summarize_transcript_text(
     openai_api_key: str | None = None,
     openai_model: str | None = None,
 ) -> str:
+    if DISABLE_SUMMARY:
+        return ""
     # 每次请求都新建一次总结器，避免复用上一次会话上下文。
     summarizer = IncrementalSummarizer(
         api_key=openai_api_key or None,
@@ -76,6 +119,7 @@ def index():
 async def ws_endpoint(ws: WebSocket):
     await ws.accept()
     session_id = str(uuid.uuid4())
+    session = None
     try:
         await asyncio.to_thread(models.ensure_loaded)
     except Exception as e:
@@ -106,20 +150,33 @@ async def ws_endpoint(ws: WebSocket):
                         session.spk_params = data.get("spk_params")
                     result = await session.finalize()
 
-                    # Summarize
-                    try:
-                        summary = await summarize_transcript_text(
-                            result.get("transcript", ""),
-                            openai_base_url=data.get("openai_base_url") or None,
-                        )
-                    except Exception as e:
-                        summary = f"LLM 总结失败: {e}"
+                    summary = ""
+                    if not DISABLE_SUMMARY:
+                        try:
+                            summary = await summarize_transcript_text(
+                                result.get("transcript", ""),
+                                openai_base_url=data.get("openai_base_url") or None,
+                            )
+                        except Exception as e:
+                            summary = f"LLM 总结失败: {e}"
 
                     final_text = result.get("transcript", "")
-                    TRANSCRIPT_STORE[session_id] = final_text
+                    try:
+                        transcript_path, summary_path = persist_result_texts(final_text, summary)
+                    except Exception as e:
+                        await ws.send_json({"type": "error", "message": f"结果文件保存失败: {e}"})
+                        continue
                     await ws.send_json({"type": "final_transcript", "text": final_text})
                     await ws.send_json({"type": "summary", "text": summary})
+                    await ws.send_json(
+                        {
+                            "type": "saved_files",
+                            "transcript_path": str(transcript_path),
+                            "summary_path": str(summary_path),
+                        }
+                    )
                     await ws.send_json({"type": "end_ack"})
+                    clear_session_cache(session_id, session=session)
 
                 elif msg_type == "ping":
                     await ws.send_json({"type": "pong"})
@@ -129,6 +186,10 @@ async def ws_endpoint(ws: WebSocket):
 
     except WebSocketDisconnect:
         return
+    finally:
+        if session is not None:
+            session.release()
+            release_process_memory()
 
 
 @app.post("/diar_asr")
@@ -154,14 +215,18 @@ async def diar_asr_api(
     temp_path = APP_DIR / f"_upload_{session_id}_{file.filename}"
     content = await file.read()
     temp_path.write_bytes(content)
+    engine = None
     try:
         engine = DiarAsrEngine(models)
         text = engine.transcribe(str(temp_path), spk_params=spk_params or None)
     finally:
+        if engine is not None:
+            engine.reset()
         try:
             temp_path.unlink(missing_ok=True)
         except Exception:
             pass
+        release_process_memory()
     TRANSCRIPT_STORE[session_id] = text
     return {"session_id": session_id, "text": text}
 
@@ -173,7 +238,12 @@ async def summary_api(
     openai_api_key: str = Form(default=""),
     openai_model: str = Form(default=""),
 ):
-    transcript = TRANSCRIPT_STORE.get(session_id, "").strip()
+    if DISABLE_SUMMARY:
+        raise HTTPException(status_code=503, detail="summary disabled")
+    transcript = TRANSCRIPT_STORE.get(session_id)
+    if transcript is None:
+        raise HTTPException(status_code=404, detail="session not found")
+    transcript = transcript.strip()
     if not transcript:
         raise HTTPException(status_code=400, detail="当前会话没有可总结的转录文本，请先完成导入识别或会议转写。")
 
@@ -187,12 +257,25 @@ async def summary_api(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"会议纪要生成失败: {e}") from e
 
-    return {"session_id": session_id, "text": summary}
+    try:
+        transcript_path, summary_path = persist_result_texts(transcript, summary)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"结果文件保存失败: {e}") from e
+
+    clear_session_cache(session_id)
+    return {
+        "session_id": session_id,
+        "text": summary,
+        "transcript_path": str(transcript_path),
+        "summary_path": str(summary_path),
+    }
 
 
 @app.get("/export/{session_id}")
 async def export_transcript(session_id: str):
-    text = TRANSCRIPT_STORE.get(session_id, "")
+    text = TRANSCRIPT_STORE.get(session_id)
+    if text is None:
+        return PlainTextResponse("not found", status_code=404)
     return PlainTextResponse(text, media_type="text/plain; charset=utf-8")
 
 

ax_meeting/summarizer.py

@@ -11,26 +11,24 @@ except Exception as e:  # pragma: no cover
     OpenAI = None
 
 
-def _split_text(text: str, max_chars: int) -> List[str]:
+def _split_text_fixed_size(text: str, chunk_chars: int) -> List[str]:
     text = text.strip()
     if not text:
         return []
-    chunks = []
-    buf = []
-    cur = 0
-    for line in text.splitlines():
-        if cur + len(line) + 1 > max_chars and buf:
-            chunks.append("\n".join(buf))
-            buf = []
-            cur = 0
-        buf.append(line)
-        cur += len(line) + 1
-    if buf:
-        chunks.append("\n".join(buf))
-    # Fallback if a single line is too long
-    if len(chunks) == 1 and len(chunks[0]) > max_chars:
-        chunks = [chunks[0][i:i + max_chars] for i in range(0, len(chunks[0]), max_chars)]
-    return chunks
+    if chunk_chars <= 0:
+        raise ValueError("SUMMARY_CHUNK_CHARS must be > 0")
+    return [text[i:i + chunk_chars] for i in range(0, len(text), chunk_chars)]
+
+
+def _summary_target_range() -> tuple[int, int]:
+    if isinstance(SUMMARY_TARGET_CHARS, (tuple, list)) and len(SUMMARY_TARGET_CHARS) == 2:
+        min_chars = int(SUMMARY_TARGET_CHARS[0])
+        max_chars = int(SUMMARY_TARGET_CHARS[1])
+    else:
+        min_chars = max_chars = int(SUMMARY_TARGET_CHARS)
+    if min_chars > max_chars:
+        min_chars, max_chars = max_chars, min_chars
+    return min_chars, max_chars
 
 
 class IncrementalSummarizer:
@@ -46,24 +44,50 @@ class IncrementalSummarizer:
         self.model = model if model is not None else os.getenv("OPENAI_MODEL", "AXERA-TECH/Qwen3-1.7B")
 
     def summarize_incrementally(self, transcript: str) -> str:
-        chunks = _split_text(transcript, SUMMARY_CHUNK_CHARS)
+        transcript = transcript.strip()
+        chunks = _split_text_fixed_size(transcript, SUMMARY_CHUNK_CHARS)
         if not chunks:
             return ""
 
+        min_chars, max_chars = _summary_target_range()
+        total_chunks = len(chunks)
+        print(f"[summarizer] transcript_total_chars={len(transcript)}")
+        print(f"[summarizer] summary_chunk_chars={SUMMARY_CHUNK_CHARS}, total_chunks={total_chunks}")
+
         summary = ""
-        for idx, chunk in enumerate(chunks):
+        for idx, chunk in enumerate(chunks, start=1):
+            print(f"[summarizer] chunk_{idx}_chars={len(chunk)}")
+            if idx == 1:
+                previous_summary_block = "无。这是第一轮请求。"
+            else:
+                previous_summary_block = (
+                    "以下内容是上一轮请求返回的摘要，属于更早时序的内容，不是新的原始会议文本。\n"
+                    f"{summary}"
+                )
+
             prompt = (
-                "你是会议纪要助手。"\
-                f"\n前情提要(可为空): {summary}"\
-                f"\n本段会议文本(第{idx + 1}段):\n{chunk}"\
-                f"\n请将本段内容总结为约{SUMMARY_TARGET_CHARS}字中文摘要。"\
-                "输出要求: 只输出摘要正文, 不要标题。/no_think"
+                "你是会议纪要助手。"
+                f"\n当前是第{idx}/{total_chunks}轮总结请求，请严格按照时间顺序理解内容。"
+                "\n请区分两类输入："
+                "\n1. <previous_summary> 标签内是上一轮摘要，表示已处理过的、更早时序内容；"
+                "\n2. <current_transcript> 标签内是本轮新发送的原始 transcript，时序上晚于上一轮摘要。"
+                "\n<previous_summary>"
+                f"\n{previous_summary_block}"
+                "\n</previous_summary>"
+                "\n<current_transcript>"
+                "\n以下内容是本轮新发送的 transcript 原文，请与上一轮摘要衔接后理解："
+                f"\n{chunk}"
+                "\n</current_transcript>"
+                "\n请基于 <previous_summary> 和 <current_transcript> 生成一个更新后的摘要，覆盖截至当前轮为止的全部会议信息。"
+                "\n请务必保留此前各轮与本轮中出现的关键决策、结论、待办事项、负责人、时间点、风险与分歧；若新内容与旧摘要有关，请在更新摘要时延续并整合，不要遗漏已有关键事实。"
+                f"\n请根据内容丰富度和文本长度，将摘要控制在约{min_chars}到{max_chars}字。"
+                "\n输出要求: 只输出摘要正文，不要标题，不要重复标签。/no_think"
             )
 
             resp = self.client.chat.completions.create(
                 model=self.model,
                 messages=[
-                    {"role": "system", "content": "你擅长从会议记录中抽取关键信息并总结。"},
+                    {"role": "system", "content": "你擅长按时间顺序理解会议记录，并基于已有摘要与新增文本生成连贯的更新摘要。"},
                     {"role": "user", "content": prompt},
                 ],
                 temperature=0.2,
@@ -71,5 +95,5 @@ class IncrementalSummarizer:
 
             summary = (resp.choices[0].message.content or "").strip()
             summary = re.sub(r"<think>.*?</think>", "", summary, flags=re.DOTALL).strip()
-            print(f"Summary chunk {idx + 1}: {summary}")
+            print(f"Summary chunk {idx}: {summary}")
         return summary

ax_meeting/utils/ax_cam_bin.py

@@ -209,8 +209,8 @@ class AX_SpeakerEmbeddingInference:
         if wav.ndim > 1:
             wav = wav.reshape(-1)
 
-        wavs = [wav[int(st * fs):int(ed * fs)] for st, ed in chunks]
-        max_len = max([x.shape[0] for x in wavs])
+        chunk_ranges = [(int(st * fs), int(ed * fs)) for st, ed in chunks]
+        max_len = max((max(ed - st, 0) for st, ed in chunk_ranges), default=0)
         max_len = max(max_len, 57900)
 
         def circle_pad_np(x: np.ndarray, target_len: int) -> np.ndarray:
@@ -220,14 +220,14 @@ class AX_SpeakerEmbeddingInference:
             xcat = np.tile(x, n)
             return xcat[:target_len]
 
-        wavs = [circle_pad_np(x, max_len) for x in wavs]
-
         batch_size = 1
         embeddings = []
-        for i in range(0, len(wavs), batch_size):
-            batch_wavs = wavs[i:i+batch_size]
+        for i in range(0, len(chunk_ranges), batch_size):
+            batch_ranges = chunk_ranges[i:i+batch_size]
             feats_list = []
-            for w in batch_wavs:
+            for st, ed in batch_ranges:
+                w = wav[st:ed]
+                w = circle_pad_np(w, max_len)
                 feat = compute_fbank(w, fs, n_mels=80, mean_nor=True)
                 if feat.shape[0] >= 360:
                     feat = feat[:360]

ax_meeting/utils/frontend.py

@@ -11,6 +11,10 @@ root_dir = Path(__file__).resolve().parent
 logger_initialized = {}
 
 
+def _prepare_waveform_buffer(waveform: np.ndarray) -> np.ndarray:
+    return np.ascontiguousarray(waveform * (1 << 15), dtype=np.float32)
+
+
 class WavFrontend:
     """Conventional frontend structure for ASR."""
 
@@ -51,9 +55,9 @@ class WavFrontend:
         self.reset_status()
 
     def fbank(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         self.fbank_fn = knf.OnlineFbank(self.opts)
-        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = self.fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(frames):
@@ -63,9 +67,9 @@ class WavFrontend:
         return feat, feat_len
 
     def fbank_online(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         # self.fbank_fn = knf.OnlineFbank(self.opts)
-        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = self.fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(self.fbank_beg_idx, frames):

ax_meeting/utils/utils/frontend.py

@@ -12,6 +12,10 @@ root_dir = Path(__file__).resolve().parent
 logger_initialized = {}
 
 
+def _prepare_waveform_buffer(waveform: np.ndarray) -> np.ndarray:
+    return np.ascontiguousarray(waveform * (1 << 15), dtype=np.float32)
+
+
 class WavFrontend:
     """Conventional frontend structure for ASR."""
 
@@ -52,9 +56,9 @@ class WavFrontend:
         self.reset_status()
 
     def fbank(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         fbank_fn = knf.OnlineFbank(self.opts)
-        fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(frames):
@@ -64,9 +68,9 @@ class WavFrontend:
         return feat, feat_len
 
     def fbank_online(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         # self.fbank_fn = knf.OnlineFbank(self.opts)
-        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = self.fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(self.fbank_beg_idx, frames):

build/lib/ax_meeting/config.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import os
 
 SAMPLE_RATE = 16000
 
@@ -17,6 +18,8 @@ MERGE_VAD_MAX_LEN_MS = 15 * 1000
 # For diarization output segments, keep shorter to avoid mixing speakers
 DIAR_MERGE_VAD_MAX_LEN_MS = 8 * 1000
 
-# LLM summarization chunking
-SUMMARY_CHUNK_CHARS = 1000
-SUMMARY_TARGET_CHARS = 100
+# LLM summarization chunking, measured in transcript characters instead of tokens
+SUMMARY_CHUNK_CHARS = int(os.getenv("SUMMARY_CHUNK_CHARS", 12 * 1000))
+
+# Target summary length range in Chinese characters
+SUMMARY_TARGET_CHARS = (100, 500)

build/lib/ax_meeting/diar_asr_cli.py

@@ -1,21 +1,29 @@
-# -*- coding: utf-8 -*-
-import argparse
-from pathlib import Path
+# -*- coding: utf-8 -*-
+import argparse
+import os
+from pathlib import Path
 
 import numpy as np
 import soundfile as sf
 
 from ax_meeting.model_bundle import ModelBundle
 from ax_meeting.utils.vad_utils import merge_vad
-from ax_meeting.utils.ax_cam_bin import (
+from ax_meeting.utils.ax_cam_bin import (
     chunk,
     distribute_spk,
     do_clustering,
     get_trans_sentence_sensevoice,
-)
+)
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.getenv(name)
+    if raw is None or raw == "":
+        return default
+    return float(raw)
 
 
-def load_audio(path: str, target_sr: int = 16000) -> np.ndarray:
+def load_audio(path: str, target_sr: int = 16000) -> np.ndarray:
     audio, sr = sf.read(path, dtype="float32")
     if audio.ndim > 1:
         audio = audio.mean(axis=1)
@@ -27,33 +35,110 @@ def load_audio(path: str, target_sr: int = 16000) -> np.ndarray:
         x_old = np.linspace(0, 1, num=len(audio), endpoint=False)
         x_new = np.linspace(0, 1, num=new_len, endpoint=False)
         audio = np.interp(x_new, x_old, audio).astype(np.float32)
-    return audio
-
-
-def diar_asr(
-    bundle: ModelBundle,
-    speech: np.ndarray,
-    spk_params: dict | None = None,
-    fs: int = 16000,
-) -> str:
-    if speech.size == 0:
-        return ""
-
-    res_vad = bundle.vad_infer(speech)
-    if not res_vad:
-        return ""
-
-    vad_segments = merge_vad(res_vad, 15 * 1000)
+    return audio
+
+
+def _merge_overlapping_vad(vad_segments: list[list[int]], max_gap_ms: int = 0) -> list[list[int]]:
+    if not vad_segments:
+        return []
+    ordered = sorted(vad_segments, key=lambda item: (item[0], item[1]))
+    merged = [ordered[0]]
+    for start_ms, end_ms in ordered[1:]:
+        last = merged[-1]
+        if start_ms <= last[1] + max_gap_ms:
+            last[1] = max(last[1], end_ms)
+        else:
+            merged.append([start_ms, end_ms])
+    return merged
+
+
+def detect_vad_segments_chunked(
+    bundle: ModelBundle,
+    speech: np.ndarray,
+    fs: int = 16000,
+    chunk_sec: float | None = None,
+    overlap_sec: float | None = None,
+) -> list[list[int]]:
+    if speech.size == 0:
+        return []
+
+    chunk_sec = _env_float("DIAR_VAD_CHUNK_SEC", 300.0) if chunk_sec is None else chunk_sec
+    overlap_sec = _env_float("DIAR_VAD_OVERLAP_SEC", 2.0) if overlap_sec is None else overlap_sec
+    duration_sec = speech.shape[0] / float(fs)
+    if chunk_sec <= 0 or duration_sec <= chunk_sec:
+        return bundle.vad_infer(speech)
+
+    chunk_samples = max(int(chunk_sec * fs), 1)
+    overlap_samples = max(int(overlap_sec * fs), 0)
+    total_samples = speech.shape[0]
+    collected: list[list[int]] = []
+
+    for core_start in range(0, total_samples, chunk_samples):
+        core_end = min(core_start + chunk_samples, total_samples)
+        read_start = max(0, core_start - overlap_samples)
+        read_end = min(total_samples, core_end + overlap_samples)
+        chunk_audio = speech[read_start:read_end]
+        local_segments = bundle.vad_infer(chunk_audio)
+        core_start_ms = int(core_start / fs * 1000)
+        core_end_ms = int(core_end / fs * 1000)
+        read_start_ms = int(read_start / fs * 1000)
+        audio_end_ms = int(total_samples / fs * 1000)
+
+        for local_start_ms, local_end_ms in local_segments:
+            global_start_ms = max(0, int(local_start_ms) + read_start_ms)
+            global_end_ms = min(audio_end_ms, int(local_end_ms) + read_start_ms)
+            if global_end_ms <= global_start_ms:
+                continue
+            mid_ms = (global_start_ms + global_end_ms) // 2
+            if core_start_ms <= mid_ms < core_end_ms:
+                collected.append([global_start_ms, global_end_ms])
+
+    return _merge_overlapping_vad(collected, max_gap_ms=0)
+
+
+def _remap_speaker_labels_by_first_start(diar_results: list[list[float]]) -> list[list[float]]:
+    if not diar_results:
+        return []
+    first_start_by_spk: dict[int, float] = {}
+    for start_sec, _end_sec, spk in sorted(diar_results, key=lambda item: (item[0], item[1])):
+        spk_id = int(spk)
+        if spk_id not in first_start_by_spk:
+            first_start_by_spk[spk_id] = float(start_sec)
+    spk_map = {
+        spk_id: new_id
+        for new_id, spk_id in enumerate(
+            sorted(first_start_by_spk, key=lambda spk_id: (first_start_by_spk[spk_id], spk_id))
+        )
+    }
+    return [[start_sec, end_sec, spk_map[int(spk)]] for start_sec, end_sec, spk in diar_results]
+
+
+def diar_asr(
+    bundle: ModelBundle,
+    speech: np.ndarray,
+    spk_params: dict | None = None,
+    fs: int = 16000,
+    vad_merge_max_len_ms: int = 15 * 1000,
+) -> str:
+    if speech.size == 0:
+        return ""
+
+    res_vad = detect_vad_segments_chunked(bundle, speech, fs=fs)
+    if not res_vad:
+        return ""
+
+    vad_segments = merge_vad(res_vad, vad_merge_max_len_ms)
     vad_time = [[vad_t[0] / 1000, vad_t[1] / 1000] for vad_t in res_vad]
     chunks = [c for (st, ed) in vad_time for c in chunk(st, ed)]
 
     if not chunks:
         return ""
 
-    embeddings = bundle.speaker_infer(speech, fs, chunks=chunks)
-    _, diar_results = do_clustering(chunks, embeddings, speaker_num=None, params=spk_params)
-
-    lines = []
+    embeddings = bundle.speaker_infer(speech, fs, chunks=chunks)
+    _, diar_results = do_clustering(chunks, embeddings, speaker_num=None, params=spk_params)
+    diar_results = _remap_speaker_labels_by_first_start(diar_results)
+
+    lines = []
     all_metadata = {"merged_words": [], "merged_timestamps": []}
     audio_duration = speech.shape[0] / float(fs) if fs > 0 else 0.0
 

build/lib/ax_meeting/engines.py

@@ -11,6 +11,7 @@ import soundfile as sf
 from ax_meeting.model_bundle import ModelBundle
 from ax_meeting.config import SAMPLE_RATE, PAUSE_MS, MIN_SEGMENT_MS, MERGE_VAD_MAX_LEN_MS, DIAR_MERGE_VAD_MAX_LEN_MS
 from ax_meeting.diar_utils import pick_speaker
+from ax_meeting.diar_asr_cli import diar_asr
 from ax_meeting.utils.vad_utils import merge_vad
 from ax_meeting.utils.ax_cam_bin import chunk, distribute_spk, do_clustering, get_trans_sentence_sensevoice
 
@@ -173,6 +174,11 @@ class VadAsrEngine:
                 out.append(VadAsrSegment(start_ms, end_ms, text.strip(), seg_audio))
         return out
 
+    def reset(self) -> None:
+        self.audio_chunks = []
+        self.total_samples = 0
+        self.last_processed_ms = 0
+
 
 class DiarAsrEngine:
     def __init__(
@@ -205,60 +211,13 @@ class DiarAsrEngine:
         if not chunks:
             return ""
         speech = np.concatenate(chunks, axis=0)
-        # return diar_asr(self.bundle, speech, fs=self.sample_rate, spk_params=spk_params)
-        res_vad = self.bundle.vad_infer(speech)
-        if not res_vad:
-            return ""
-
-        vad_segments = merge_vad(res_vad, DIAR_MERGE_VAD_MAX_LEN_MS)
-        vad_time = [[vad_t[0] / 1000, vad_t[1] / 1000] for vad_t in res_vad]
-        chunks = [c for (st, ed) in vad_time for c in chunk(st, ed)]
-        if not chunks:
-            return ""
-
-        embeddings = self.bundle.speaker_infer(speech, self.sample_rate, chunks=chunks)
-        _, diar_results = do_clustering(chunks, embeddings, speaker_num=None, params=spk_params)
-
-        lines = []
-        all_metadata = {"merged_words": [], "merged_timestamps": []}
-        audio_duration = speech.shape[0] / float(self.sample_rate) if self.sample_rate > 0 else 0.0
-
-        for i, segment in enumerate(vad_segments):
-            segment_start, segment_end = segment
-            start_sample = int(segment_start / 1000 * self.sample_rate)
-            end_sample = min(int(segment_end / 1000 * self.sample_rate), speech.shape[0])
-            segment_speech = speech[start_sample:end_sample]
-            time_offset_sec = segment_start / 1000.0
-
-            _, meta = self.bundle.asr_infer(
-                segment_speech,
-                output_timestamp=True,
-                key=f"segment_{i}",
-            )
-
-            seg_words = meta.get("merged_words", [])
-            seg_timestamps = meta.get("merged_timestamps", [])
-            if seg_words and seg_timestamps and len(seg_words) == len(seg_timestamps):
-                adjusted_timestamps = [
-                    [
-                        min(ts[0] + time_offset_sec, audio_duration),
-                        min(ts[1] + time_offset_sec, audio_duration),
-                    ]
-                    for ts in seg_timestamps
-                ]
-                all_metadata["merged_words"].extend(seg_words)
-                all_metadata["merged_timestamps"].extend(adjusted_timestamps)
-
-        if all_metadata["merged_words"]:
-            output_asr = {
-                "merged_words": all_metadata["merged_words"],
-                "merged_timestamps": all_metadata["merged_timestamps"],
-            }
-            asr_timestamps = get_trans_sentence_sensevoice(output_asr)
-            sentence_info_with_spk = distribute_spk(asr_timestamps, diar_results)
-            lines = [
-                f"Speaker_{spk}: [{timeinterval[0]:.3f} {timeinterval[1]:.3f}] {text_string}"
-                for text_string, timeinterval, spk in sentence_info_with_spk
-            ]
-
-        return "\n".join(lines)
+        return diar_asr(
+            self.bundle,
+            speech,
+            fs=self.sample_rate,
+            spk_params=spk_params,
+            vad_merge_max_len_ms=DIAR_MERGE_VAD_MAX_LEN_MS,
+        )
+
+    def reset(self) -> None:
+        self.audio_chunks = []

build/lib/ax_meeting/pipeline.py

@@ -151,3 +151,12 @@ class StreamingMeetingSession:
             fs=self.sample_rate,
             spk_params=getattr(self, "spk_params", None),
         )
+
+    def release(self) -> None:
+        self.audio_chunks = []
+        self.total_samples = 0
+        self.last_processed_ms = 0
+        self.last_vad_check_ts = 0.0
+        self.processing = False
+        if hasattr(self, "spk_params"):
+            delattr(self, "spk_params")

build/lib/ax_meeting/server.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 import asyncio
 from contextlib import asynccontextmanager
+from datetime import datetime
+import gc
 import json
 import os
 import uuid
@@ -19,6 +21,7 @@ from ax_meeting.summarizer import IncrementalSummarizer
 
 APP_DIR = Path(__file__).parent
 STATIC_DIR = APP_DIR / "static"
+RESULT_DIR = Path(os.getenv("RESULT_TXT_DIR", "result_txt")).resolve()
 
 def preload_models() -> None:
     print("Preloading AX models...")
@@ -43,6 +46,44 @@ TRANSCRIPT_STORE = {}
 RECORDING_STORE = {}
 RECORDING_DIR = APP_DIR / "recordings"
 RECORDING_DIR.mkdir(exist_ok=True)
+DISABLE_SUMMARY = os.getenv("DISABLE_SUMMARY", "0").lower() in {"1", "true", "yes", "on"}
+
+
+def _malloc_trim() -> None:
+    try:
+        import ctypes
+
+        ctypes.CDLL("libc.so.6").malloc_trim(0)
+    except Exception:
+        pass
+
+
+def release_process_memory() -> None:
+    gc.collect()
+    _malloc_trim()
+
+
+def persist_result_texts(transcript: str, summary: str) -> tuple[Path, Path]:
+    RESULT_DIR.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+    transcript_path = RESULT_DIR / f"{stamp}_transcript.txt"
+    summary_path = RESULT_DIR / f"{stamp}_summary.txt"
+    transcript_path.write_text(transcript, encoding="utf-8")
+    summary_path.write_text(summary, encoding="utf-8")
+    return transcript_path, summary_path
+
+
+def clear_session_cache(session_id: str, session: StreamingMeetingSession | None = None) -> None:
+    TRANSCRIPT_STORE.pop(session_id, None)
+    recording_path = RECORDING_STORE.pop(session_id, None)
+    if recording_path:
+        try:
+            recording_path.unlink(missing_ok=True)
+        except Exception:
+            pass
+    if session is not None:
+        session.release()
+    release_process_memory()
 
 
 async def summarize_transcript_text(
@@ -51,6 +92,8 @@ async def summarize_transcript_text(
     openai_api_key: str | None = None,
     openai_model: str | None = None,
 ) -> str:
+    if DISABLE_SUMMARY:
+        return ""
     # 每次请求都新建一次总结器，避免复用上一次会话上下文。
     summarizer = IncrementalSummarizer(
         api_key=openai_api_key or None,
@@ -76,6 +119,7 @@ def index():
 async def ws_endpoint(ws: WebSocket):
     await ws.accept()
     session_id = str(uuid.uuid4())
+    session = None
     try:
         await asyncio.to_thread(models.ensure_loaded)
     except Exception as e:
@@ -106,20 +150,33 @@ async def ws_endpoint(ws: WebSocket):
                         session.spk_params = data.get("spk_params")
                     result = await session.finalize()
 
-                    # Summarize
-                    try:
-                        summary = await summarize_transcript_text(
-                            result.get("transcript", ""),
-                            openai_base_url=data.get("openai_base_url") or None,
-                        )
-                    except Exception as e:
-                        summary = f"LLM 总结失败: {e}"
+                    summary = ""
+                    if not DISABLE_SUMMARY:
+                        try:
+                            summary = await summarize_transcript_text(
+                                result.get("transcript", ""),
+                                openai_base_url=data.get("openai_base_url") or None,
+                            )
+                        except Exception as e:
+                            summary = f"LLM 总结失败: {e}"
 
                     final_text = result.get("transcript", "")
-                    TRANSCRIPT_STORE[session_id] = final_text
+                    try:
+                        transcript_path, summary_path = persist_result_texts(final_text, summary)
+                    except Exception as e:
+                        await ws.send_json({"type": "error", "message": f"结果文件保存失败: {e}"})
+                        continue
                     await ws.send_json({"type": "final_transcript", "text": final_text})
                     await ws.send_json({"type": "summary", "text": summary})
+                    await ws.send_json(
+                        {
+                            "type": "saved_files",
+                            "transcript_path": str(transcript_path),
+                            "summary_path": str(summary_path),
+                        }
+                    )
                     await ws.send_json({"type": "end_ack"})
+                    clear_session_cache(session_id, session=session)
 
                 elif msg_type == "ping":
                     await ws.send_json({"type": "pong"})
@@ -129,6 +186,10 @@ async def ws_endpoint(ws: WebSocket):
 
     except WebSocketDisconnect:
         return
+    finally:
+        if session is not None:
+            session.release()
+            release_process_memory()
 
 
 @app.post("/diar_asr")
@@ -154,14 +215,18 @@ async def diar_asr_api(
     temp_path = APP_DIR / f"_upload_{session_id}_{file.filename}"
     content = await file.read()
     temp_path.write_bytes(content)
+    engine = None
     try:
         engine = DiarAsrEngine(models)
         text = engine.transcribe(str(temp_path), spk_params=spk_params or None)
     finally:
+        if engine is not None:
+            engine.reset()
         try:
             temp_path.unlink(missing_ok=True)
         except Exception:
             pass
+        release_process_memory()
     TRANSCRIPT_STORE[session_id] = text
     return {"session_id": session_id, "text": text}
 
@@ -173,7 +238,12 @@ async def summary_api(
     openai_api_key: str = Form(default=""),
     openai_model: str = Form(default=""),
 ):
-    transcript = TRANSCRIPT_STORE.get(session_id, "").strip()
+    if DISABLE_SUMMARY:
+        raise HTTPException(status_code=503, detail="summary disabled")
+    transcript = TRANSCRIPT_STORE.get(session_id)
+    if transcript is None:
+        raise HTTPException(status_code=404, detail="session not found")
+    transcript = transcript.strip()
     if not transcript:
         raise HTTPException(status_code=400, detail="当前会话没有可总结的转录文本，请先完成导入识别或会议转写。")
 
@@ -187,12 +257,25 @@ async def summary_api(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"会议纪要生成失败: {e}") from e
 
-    return {"session_id": session_id, "text": summary}
+    try:
+        transcript_path, summary_path = persist_result_texts(transcript, summary)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"结果文件保存失败: {e}") from e
+
+    clear_session_cache(session_id)
+    return {
+        "session_id": session_id,
+        "text": summary,
+        "transcript_path": str(transcript_path),
+        "summary_path": str(summary_path),
+    }
 
 
 @app.get("/export/{session_id}")
 async def export_transcript(session_id: str):
-    text = TRANSCRIPT_STORE.get(session_id, "")
+    text = TRANSCRIPT_STORE.get(session_id)
+    if text is None:
+        return PlainTextResponse("not found", status_code=404)
     return PlainTextResponse(text, media_type="text/plain; charset=utf-8")
 
 

build/lib/ax_meeting/summarizer.py

@@ -11,26 +11,24 @@ except Exception as e:  # pragma: no cover
     OpenAI = None
 
 
-def _split_text(text: str, max_chars: int) -> List[str]:
+def _split_text_fixed_size(text: str, chunk_chars: int) -> List[str]:
     text = text.strip()
     if not text:
         return []
-    chunks = []
-    buf = []
-    cur = 0
-    for line in text.splitlines():
-        if cur + len(line) + 1 > max_chars and buf:
-            chunks.append("\n".join(buf))
-            buf = []
-            cur = 0
-        buf.append(line)
-        cur += len(line) + 1
-    if buf:
-        chunks.append("\n".join(buf))
-    # Fallback if a single line is too long
-    if len(chunks) == 1 and len(chunks[0]) > max_chars:
-        chunks = [chunks[0][i:i + max_chars] for i in range(0, len(chunks[0]), max_chars)]
-    return chunks
+    if chunk_chars <= 0:
+        raise ValueError("SUMMARY_CHUNK_CHARS must be > 0")
+    return [text[i:i + chunk_chars] for i in range(0, len(text), chunk_chars)]
+
+
+def _summary_target_range() -> tuple[int, int]:
+    if isinstance(SUMMARY_TARGET_CHARS, (tuple, list)) and len(SUMMARY_TARGET_CHARS) == 2:
+        min_chars = int(SUMMARY_TARGET_CHARS[0])
+        max_chars = int(SUMMARY_TARGET_CHARS[1])
+    else:
+        min_chars = max_chars = int(SUMMARY_TARGET_CHARS)
+    if min_chars > max_chars:
+        min_chars, max_chars = max_chars, min_chars
+    return min_chars, max_chars
 
 
 class IncrementalSummarizer:
@@ -46,24 +44,50 @@ class IncrementalSummarizer:
         self.model = model if model is not None else os.getenv("OPENAI_MODEL", "AXERA-TECH/Qwen3-1.7B")
 
     def summarize_incrementally(self, transcript: str) -> str:
-        chunks = _split_text(transcript, SUMMARY_CHUNK_CHARS)
+        transcript = transcript.strip()
+        chunks = _split_text_fixed_size(transcript, SUMMARY_CHUNK_CHARS)
         if not chunks:
             return ""
 
+        min_chars, max_chars = _summary_target_range()
+        total_chunks = len(chunks)
+        print(f"[summarizer] transcript_total_chars={len(transcript)}")
+        print(f"[summarizer] summary_chunk_chars={SUMMARY_CHUNK_CHARS}, total_chunks={total_chunks}")
+
         summary = ""
-        for idx, chunk in enumerate(chunks):
+        for idx, chunk in enumerate(chunks, start=1):
+            print(f"[summarizer] chunk_{idx}_chars={len(chunk)}")
+            if idx == 1:
+                previous_summary_block = "无。这是第一轮请求。"
+            else:
+                previous_summary_block = (
+                    "以下内容是上一轮请求返回的摘要，属于更早时序的内容，不是新的原始会议文本。\n"
+                    f"{summary}"
+                )
+
             prompt = (
-                "你是会议纪要助手。"\
-                f"\n前情提要(可为空): {summary}"\
-                f"\n本段会议文本(第{idx + 1}段):\n{chunk}"\
-                f"\n请将本段内容总结为约{SUMMARY_TARGET_CHARS}字中文摘要。"\
-                "输出要求: 只输出摘要正文, 不要标题。/no_think"
+                "你是会议纪要助手。"
+                f"\n当前是第{idx}/{total_chunks}轮总结请求，请严格按照时间顺序理解内容。"
+                "\n请区分两类输入："
+                "\n1. <previous_summary> 标签内是上一轮摘要，表示已处理过的、更早时序内容；"
+                "\n2. <current_transcript> 标签内是本轮新发送的原始 transcript，时序上晚于上一轮摘要。"
+                "\n<previous_summary>"
+                f"\n{previous_summary_block}"
+                "\n</previous_summary>"
+                "\n<current_transcript>"
+                "\n以下内容是本轮新发送的 transcript 原文，请与上一轮摘要衔接后理解："
+                f"\n{chunk}"
+                "\n</current_transcript>"
+                "\n请基于 <previous_summary> 和 <current_transcript> 生成一个更新后的摘要，覆盖截至当前轮为止的全部会议信息。"
+                "\n请务必保留此前各轮与本轮中出现的关键决策、结论、待办事项、负责人、时间点、风险与分歧；若新内容与旧摘要有关，请在更新摘要时延续并整合，不要遗漏已有关键事实。"
+                f"\n请根据内容丰富度和文本长度，将摘要控制在约{min_chars}到{max_chars}字。"
+                "\n输出要求: 只输出摘要正文，不要标题，不要重复标签。/no_think"
             )
 
             resp = self.client.chat.completions.create(
                 model=self.model,
                 messages=[
-                    {"role": "system", "content": "你擅长从会议记录中抽取关键信息并总结。"},
+                    {"role": "system", "content": "你擅长按时间顺序理解会议记录，并基于已有摘要与新增文本生成连贯的更新摘要。"},
                     {"role": "user", "content": prompt},
                 ],
                 temperature=0.2,
@@ -71,5 +95,5 @@ class IncrementalSummarizer:
 
             summary = (resp.choices[0].message.content or "").strip()
             summary = re.sub(r"<think>.*?</think>", "", summary, flags=re.DOTALL).strip()
-            print(f"Summary chunk {idx + 1}: {summary}")
+            print(f"Summary chunk {idx}: {summary}")
         return summary

build/lib/ax_meeting/utils/ax_cam_bin.py

@@ -209,8 +209,8 @@ class AX_SpeakerEmbeddingInference:
         if wav.ndim > 1:
             wav = wav.reshape(-1)
 
-        wavs = [wav[int(st * fs):int(ed * fs)] for st, ed in chunks]
-        max_len = max([x.shape[0] for x in wavs])
+        chunk_ranges = [(int(st * fs), int(ed * fs)) for st, ed in chunks]
+        max_len = max((max(ed - st, 0) for st, ed in chunk_ranges), default=0)
         max_len = max(max_len, 57900)
 
         def circle_pad_np(x: np.ndarray, target_len: int) -> np.ndarray:
@@ -220,14 +220,14 @@ class AX_SpeakerEmbeddingInference:
             xcat = np.tile(x, n)
             return xcat[:target_len]
 
-        wavs = [circle_pad_np(x, max_len) for x in wavs]
-
         batch_size = 1
         embeddings = []
-        for i in range(0, len(wavs), batch_size):
-            batch_wavs = wavs[i:i+batch_size]
+        for i in range(0, len(chunk_ranges), batch_size):
+            batch_ranges = chunk_ranges[i:i+batch_size]
             feats_list = []
-            for w in batch_wavs:
+            for st, ed in batch_ranges:
+                w = wav[st:ed]
+                w = circle_pad_np(w, max_len)
                 feat = compute_fbank(w, fs, n_mels=80, mean_nor=True)
                 if feat.shape[0] >= 360:
                     feat = feat[:360]

build/lib/ax_meeting/utils/frontend.py

@@ -11,6 +11,10 @@ root_dir = Path(__file__).resolve().parent
 logger_initialized = {}
 
 
+def _prepare_waveform_buffer(waveform: np.ndarray) -> np.ndarray:
+    return np.ascontiguousarray(waveform * (1 << 15), dtype=np.float32)
+
+
 class WavFrontend:
     """Conventional frontend structure for ASR."""
 
@@ -51,9 +55,9 @@ class WavFrontend:
         self.reset_status()
 
     def fbank(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         self.fbank_fn = knf.OnlineFbank(self.opts)
-        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = self.fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(frames):
@@ -63,9 +67,9 @@ class WavFrontend:
         return feat, feat_len
 
     def fbank_online(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         # self.fbank_fn = knf.OnlineFbank(self.opts)
-        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = self.fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(self.fbank_beg_idx, frames):

build/lib/ax_meeting/utils/utils/frontend.py

@@ -12,6 +12,10 @@ root_dir = Path(__file__).resolve().parent
 logger_initialized = {}
 
 
+def _prepare_waveform_buffer(waveform: np.ndarray) -> np.ndarray:
+    return np.ascontiguousarray(waveform * (1 << 15), dtype=np.float32)
+
+
 class WavFrontend:
     """Conventional frontend structure for ASR."""
 
@@ -52,9 +56,9 @@ class WavFrontend:
         self.reset_status()
 
     def fbank(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         fbank_fn = knf.OnlineFbank(self.opts)
-        fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(frames):
@@ -64,9 +68,9 @@ class WavFrontend:
         return feat, feat_len
 
     def fbank_online(self, waveform: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
-        waveform = waveform * (1 << 15)
+        waveform = _prepare_waveform_buffer(waveform)
         # self.fbank_fn = knf.OnlineFbank(self.opts)
-        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform.tolist())
+        self.fbank_fn.accept_waveform(self.opts.frame_opts.samp_freq, waveform)
         frames = self.fbank_fn.num_frames_ready
         mat = np.empty([frames, self.opts.mel_opts.num_bins])
         for i in range(self.fbank_beg_idx, frames):

dist/ax_meeting-0.1.1-py3-none-any.whl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:99bb01894a15b4a080f24cace042a8f9c0cf43d634acb57079af23d61c3a5bc0
-size 234144959
+oid sha256:6e1f81ecca959cb6b14b217da82402d7c9090cd1cc782021ff55e28d5ffd7137
+size 234146965

start_meeting_server.sh

@@ -1,8 +1,10 @@
 OPENAI_API_KEY=xxx \
-OPENAI_BASE_URL=http://127.0.0.1:8001/v1 \
-OPENAI_MODEL=AXERA-TECH/Qwen3-1.7B \
+OPENAI_BASE_URL=http://127.0.0.1:8000/v1 \
+OPENAI_MODEL=AXERA-TECH/Qwen3.5-2B \
+SUMMARY_CHUNK_CHARS=12000 \
+RESULT_TXT_DIR=result_txt \
 HOST=0.0.0.0 \
-PORT=8000 \
+PORT=8090 \
 SSL_CERT=cert.pem \
 SSL_KEY=key.pem \
-python3 -m ax_meeting.server
+python3 -m ax_meeting.server

tests/test_lightweight.py

@@ -1,9 +1,40 @@
 # -*- coding: utf-8 -*-
+import importlib
+import asyncio
+import os
+from pathlib import Path
+import sys
+import tempfile
+import types
 import unittest
+from types import SimpleNamespace
 from unittest.mock import patch
 
 from ax_meeting.text_cleaner import clean_asr_text
 from ax_meeting.diar_utils import pick_speaker
+from ax_meeting import summarizer as summarizer_module
+
+
+fake_model_bundle_module = types.ModuleType("ax_meeting.model_bundle")
+
+
+class FakeModelBundle:
+    def ensure_loaded(self):
+        pass
+
+
+fake_model_bundle_module.ModelBundle = FakeModelBundle
+sys.modules.setdefault("ax_meeting.model_bundle", fake_model_bundle_module)
+
+fake_engines_module = types.ModuleType("ax_meeting.engines")
+fake_engines_module.DiarAsrEngine = object
+sys.modules.setdefault("ax_meeting.engines", fake_engines_module)
+
+fake_pipeline_module = types.ModuleType("ax_meeting.pipeline")
+fake_pipeline_module.StreamingMeetingSession = object
+sys.modules.setdefault("ax_meeting.pipeline", fake_pipeline_module)
+
+from ax_meeting import config as config_module
 from ax_meeting import server
 
 
@@ -47,5 +78,152 @@ class TestServerStartup(unittest.TestCase):
         mocked.assert_called_once_with()
 
 
+class TestServerPersistence(unittest.TestCase):
+    def test_persist_result_texts_writes_timestamped_files(self):
+        with tempfile.TemporaryDirectory() as tmpdir, patch.object(server, "RESULT_DIR", Path(tmpdir)):
+            transcript_path, summary_path = server.persist_result_texts("transcript body", "summary body")
+            transcript_body = transcript_path.read_text(encoding="utf-8")
+            summary_body = summary_path.read_text(encoding="utf-8")
+
+        self.assertTrue(transcript_path.name.endswith("_transcript.txt"))
+        self.assertTrue(summary_path.name.endswith("_summary.txt"))
+        self.assertEqual(transcript_body, "transcript body")
+        self.assertEqual(summary_body, "summary body")
+
+    def test_clear_session_cache_removes_store_and_releases_session(self):
+        class FakeSession:
+            def __init__(self):
+                self.released = False
+
+            def release(self):
+                self.released = True
+
+        with tempfile.TemporaryDirectory() as tmpdir, patch.object(server, "release_process_memory") as mocked_release:
+            record_path = Path(tmpdir) / "meeting.mp3"
+            record_path.write_bytes(b"dummy")
+            server.TRANSCRIPT_STORE["sid"] = "hello"
+            server.RECORDING_STORE["sid"] = record_path
+            fake_session = FakeSession()
+
+            server.clear_session_cache("sid", session=fake_session)
+
+        self.assertNotIn("sid", server.TRANSCRIPT_STORE)
+        self.assertNotIn("sid", server.RECORDING_STORE)
+        self.assertFalse(record_path.exists())
+        self.assertTrue(fake_session.released)
+        mocked_release.assert_called_once_with()
+
+    def test_summary_api_persists_files_and_clears_cache(self):
+        server.TRANSCRIPT_STORE["sid"] = "meeting transcript"
+        fake_transcript_path = Path("/tmp/transcript.txt")
+        fake_summary_path = Path("/tmp/summary.txt")
+
+        async def run_test():
+            with patch.object(server, "summarize_transcript_text", return_value="meeting summary"), patch.object(
+                server, "persist_result_texts", return_value=(fake_transcript_path, fake_summary_path)
+            ) as mocked_persist, patch.object(server, "clear_session_cache") as mocked_clear:
+                result = await server.summary_api(
+                    session_id="sid",
+                    openai_base_url="",
+                    openai_api_key="",
+                    openai_model="",
+                )
+
+            self.assertEqual(result["text"], "meeting summary")
+            self.assertEqual(result["transcript_path"], str(fake_transcript_path))
+            self.assertEqual(result["summary_path"], str(fake_summary_path))
+            mocked_persist.assert_called_once_with("meeting transcript", "meeting summary")
+            mocked_clear.assert_called_once_with("sid")
+
+        asyncio.run(run_test())
+        server.TRANSCRIPT_STORE.pop("sid", None)
+
+
+class TestSummarizerHelpers(unittest.TestCase):
+    def test_split_text_fixed_size_empty(self):
+        self.assertEqual(summarizer_module._split_text_fixed_size("   ", 4), [])
+
+    def test_split_text_fixed_size_chunks_by_chars(self):
+        self.assertEqual(
+            summarizer_module._split_text_fixed_size("abcdefghij", 4),
+            ["abcd", "efgh", "ij"],
+        )
+
+    def test_split_text_fixed_size_invalid_chunk_size(self):
+        with self.assertRaises(ValueError):
+            summarizer_module._split_text_fixed_size("abc", 0)
+
+    def test_summary_target_range_from_scalar(self):
+        with patch.object(summarizer_module, "SUMMARY_TARGET_CHARS", 120):
+            self.assertEqual(summarizer_module._summary_target_range(), (120, 120))
+
+    def test_summary_target_range_from_tuple(self):
+        with patch.object(summarizer_module, "SUMMARY_TARGET_CHARS", (100, 300)):
+            self.assertEqual(summarizer_module._summary_target_range(), (100, 300))
+
+    def test_summary_target_range_normalizes_reverse_order(self):
+        with patch.object(summarizer_module, "SUMMARY_TARGET_CHARS", [300, 100]):
+            self.assertEqual(summarizer_module._summary_target_range(), (100, 300))
+
+    def test_summary_chunk_chars_uses_environment_override(self):
+        old_value = os.environ.get("SUMMARY_CHUNK_CHARS")
+        try:
+            os.environ["SUMMARY_CHUNK_CHARS"] = "3456"
+            reloaded = importlib.reload(config_module)
+            self.assertEqual(reloaded.SUMMARY_CHUNK_CHARS, 3456)
+        finally:
+            if old_value is None:
+                os.environ.pop("SUMMARY_CHUNK_CHARS", None)
+            else:
+                os.environ["SUMMARY_CHUNK_CHARS"] = old_value
+            importlib.reload(config_module)
+
+
+class TestIncrementalSummarizer(unittest.TestCase):
+    def _make_response(self, content: str):
+        return SimpleNamespace(
+            choices=[
+                SimpleNamespace(
+                    message=SimpleNamespace(content=content),
+                )
+            ]
+        )
+
+    def test_summarize_incrementally_uses_previous_summary_and_returns_last_round(self):
+        fake_client = SimpleNamespace(
+            chat=SimpleNamespace(
+                completions=SimpleNamespace(
+                    create=unittest.mock.Mock(
+                        side_effect=[
+                            self._make_response("第一轮摘要"),
+                            self._make_response("<think>ignored</think>最终摘要"),
+                        ]
+                    )
+                )
+            )
+        )
+
+        with patch.object(summarizer_module, "OpenAI", return_value=fake_client), patch.object(
+            summarizer_module, "SUMMARY_CHUNK_CHARS", 5
+        ), patch.object(summarizer_module, "SUMMARY_TARGET_CHARS", (100, 300)):
+            summarizer = summarizer_module.IncrementalSummarizer(api_key="test-key")
+            summary = summarizer.summarize_incrementally("abcdefghij")
+
+        self.assertEqual(summary, "最终摘要")
+        create = fake_client.chat.completions.create
+        self.assertEqual(create.call_count, 2)
+
+        first_prompt = create.call_args_list[0].kwargs["messages"][1]["content"]
+        second_prompt = create.call_args_list[1].kwargs["messages"][1]["content"]
+
+        self.assertIn("<previous_summary>\n无。这是第一轮请求。\n</previous_summary>", first_prompt)
+        self.assertIn("<current_transcript>\n以下内容是本轮新发送的 transcript 原文，请与上一轮摘要衔接后理解：\nabcde", first_prompt)
+        self.assertIn("请务必保留此前各轮与本轮中出现的关键决策、结论、待办事项、负责人、时间点、风险与分歧", first_prompt)
+        self.assertIn("当前是第2/2轮总结请求", second_prompt)
+        self.assertIn("以下内容是上一轮请求返回的摘要", second_prompt)
+        self.assertIn("第一轮摘要", second_prompt)
+        self.assertIn("\nfghij\n</current_transcript>", second_prompt)
+
+
 if __name__ == "__main__":
     unittest.main()

wav/cache_test/clip_01.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:323f80635ee6c7eadece0ea9f1ee8c71e9b4c458dc0eaf3b0c0439a90e15f590
+size 160044

wav/cache_test/clip_02.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5be642f1eb0ec3b4cd9a965c755b422b996db313d5edc7ae8f8518d2b69a592d
+size 160044

wav/cache_test/clip_03.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e048137d192911cea15d626815ce43a1edb262329f7ff5b266d7cbce8f8874fa
+size 160044

wav/cache_test/clip_04.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06277334abab56f990b9016be95f99276077f252c99847f485b3a77668e32e29
+size 160044

wav/cache_test/long_5min.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5df2a2f8573af97c3ff269891d853f0c887dcf15f933864df367ba6c88a36e86
+size 4800044