diff --git a/frontend/components/AiSettings.vue b/frontend/components/AiSettings.vue
index b9c1462f..380c0623 100644
--- a/frontend/components/AiSettings.vue
+++ b/frontend/components/AiSettings.vue
@@ -3,7 +3,7 @@
     <header class="ais-heading">
       <div class="ais-heading-icon"><WandSparkles :size="16" :stroke-width="1.8" aria-hidden="true" /></div>
       <div><h3>AI 服务</h3><p>管理 AI 模型、本地搜索与对话体验。</p></div>
-      <span class="ais-local"><Lock :size="16" :stroke-width="1.8" aria-hidden="true" /> {{ activeTab==='local' ? '搜索在本机运行' : '密钥本机保存' }}</span>
+      <span class="ais-local"><Lock :size="16" :stroke-width="1.8" aria-hidden="true" /> {{ activeTab==='local' ? '本机或你指定的服务' : '密钥本机保存' }}</span>
     </header>
 
     <div class="ais-tabs" role="tablist" aria-label="AI 服务页面">
diff --git a/frontend/components/LocalSearchSettings.vue b/frontend/components/LocalSearchSettings.vue
index f2dce5f8..7dc9542c 100644
--- a/frontend/components/LocalSearchSettings.vue
+++ b/frontend/components/LocalSearchSettings.vue
@@ -119,18 +119,28 @@
           <details v-if="state.audit?.length" class="lss-section"><summary>本地处理记录</summary><p v-for="a in state.audit" :key="a.id" class="lss-note">{{ a.kind==='search' ? '检索' : '整理聊天' }} · {{ a.model }} · {{ a.actual_device==='cuda' ? 'NVIDIA GPU' : 'CPU' }} · {{ Number(a.seconds).toFixed(1) }} 秒</p></details>
         </div>
       </details>
-      <div class="lss-bottom-note"><Laptop :size="16" :stroke-width="1.8" aria-hidden="true" /><span>本地搜索不上传聊天。AI 助手回答时，引用的内容仍会发送至你配置的模型服务。</span></div>
+      <div class="lss-bottom-note"><Laptop :size="16" :stroke-width="1.8" aria-hidden="true" /><span>{{ selectedModel?.backend==='remote' ? '检索由你配置的远端服务执行：建立索引和搜索时，聊天文本会发送到该服务。AI 助手回答时，引用的内容仍会发送至你配置的模型服务。' : '本地搜索不上传聊天。AI 助手回答时，引用的内容仍会发送至你配置的模型服务。' }}</span></div>
     </div>
 
     <Teleport to="body"><div v-if="dialog" class="lss-overlay" @click.self="closeDialog" @keydown.esc.stop="closeDialog" @keydown.tab="trapFocus">
       <section ref="dialogRef" class="lss-dialog local-search-settings" :class="{ 'lss-model-dialog':dialog==='models', 'lss-scope-dialog':dialog==='scope' }" role="dialog" aria-modal="true" :aria-label="dialogTitle" tabindex="-1">
-        <header class="lss-dialog-heading"><div><h4>{{ dialogTitle }}</h4><p>{{ dialog==='models' ? '按语言和电脑配置选择，下载完成后点击「使用此模型」。' : dialog==='scope' ? '按分类选择要检索的聊天' : '导入后会校验版本和文件完整性。' }}</p></div><button type="button" aria-label="关闭" :disabled="busy" @click="closeDialog"><X :size="16" :stroke-width="1.8" aria-hidden="true" /></button></header>
+        <header class="lss-dialog-heading"><div><h4>{{ dialogTitle }}</h4><p>{{ dialog==='models' ? '按语言和电脑配置选择，下载完成后点击「使用此模型」；远端模型无需下载，填好服务地址和模型名后直接使用。' : dialog==='scope' ? '按分类选择要检索的聊天' : '导入后会校验版本和文件完整性。' }}</p></div><button type="button" aria-label="关闭" :disabled="busy" @click="closeDialog"><X :size="16" :stroke-width="1.8" aria-hidden="true" /></button></header>
         <p v-if="dialogError" class="lss-feedback lss-error" role="alert">{{ dialogError }}</p>
         <template v-if="dialog==='models'">    <div class="lss-models" role="list" aria-label="可用检索模型">
       <article v-for="m in state.models || []" :key="m.id" class="lss-card lss-model" :class="{selected: form.model===m.id}" role="listitem">
-        <div class="lss-row"><h5>{{ m.name }} <small v-if="m.recommended">推荐</small></h5><span class="lss-note">{{ m.downloaded ? '已下载' : stage(m.job) }}</span></div>
-        <p>{{ m.description }}</p><p class="lss-note">{{ bytes(m.size) }} · 本地运行 · {{ m.license }}</p>
-        <details class="lss-source"><summary>模型来源</summary><a :href="`https://huggingface.co/${m.repo}`" target="_blank" rel="noopener noreferrer">{{ m.repo }}</a><p>{{ m.id.startsWith('bge') ? '原作者 BAAI · ONNX 转换 Xenova' : '原作者 intfloat' }}</p><p>固定版本 {{ m.revision.slice(0, 12) }}</p></details>
+        <div class="lss-row"><h5>{{ m.name }} <small v-if="m.recommended">推荐</small></h5><span class="lss-note">{{ m.backend==='remote' ? '局域网服务' : m.downloaded ? '已下载' : stage(m.job) }}</span></div>
+        <p>{{ m.description }}</p><p class="lss-note">{{ m.backend==='remote' ? '远端运行' : bytes(m.size)+' · 本地运行' }}{{ m.license ? ' · '+m.license : '' }}</p>
+        <div v-if="m.backend==='remote'" class="lss-endpoint">
+          <div class="lss-presets"><span>快速预设</span><button v-for="preset in remotePresets" :key="preset.label" type="button" :disabled="busy" @click="applyPreset(preset)">{{ preset.label }}</button></div>
+          <span>服务地址</span><input v-model="form.remote_endpoint" type="text" inputmode="url" placeholder="https://192.168.1.10:11434/v1" aria-label="远端向量服务地址" />
+          <span>模型名</span><input v-model="form.remote_model" type="text" placeholder="tencent/WeMM-Embedding-2B" aria-label="远端服务模型名" />
+          <span>API Key（可选）</span><input v-model="form.remote_api_key" type="password" autocomplete="off" placeholder="服务不校验密钥时留空" aria-label="远端服务 API Key" />
+          <label class="lss-check"><input v-model="form.remote_allow_self_signed" type="checkbox" />允许自签名证书</label>
+          <div class="lss-actions"><button type="button" :disabled="busy || !form.remote_endpoint" @click="testRemote">测试连接</button></div>
+          <p v-if="remoteTestText" class="lss-note" :class="{ 'lss-error': remoteTest && remoteTest.status !== 'success' }">{{ remoteTestText }}</p>
+          <small>地址填到 /v1 即可（也接受完整的 /v1/embeddings）；服务需提供 OpenAI 兼容的向量接口。建立索引和搜索时，文本会发送到该服务。</small>
+        </div>
+        <details class="lss-source"><summary>模型来源</summary><a v-if="m.repo" :href="`https://huggingface.co/${m.repo}`" target="_blank" rel="noopener noreferrer">{{ m.repo }}</a><p>{{ m.backend==='remote' ? '向量推理由你填写的服务提供，本工具只按 OpenAI 兼容协议调用' : m.id.startsWith('bge') ? '原作者 BAAI · ONNX 转换 Xenova' : '原作者 intfloat' }}</p><p v-if="m.revision">固定版本 {{ m.revision.slice(0, 12) }}</p></details>
         <template v-if="m.job && !['done','error'].includes(m.job.status)"><progress :value="m.job.total ? m.job.bytes : undefined" :max="m.job.total || undefined" :aria-label="`${m.name} 下载进度`" /><p class="lss-note">{{ stage(m.job) }} · {{ bytes(m.job.bytes) }} / {{ bytes(m.job.total) }}<span v-if="m.job.speed"> · {{ bytes(m.job.speed) }}/s</span><span v-if="m.job.stage==='retry_wait'"> · {{ Math.max(0,Math.ceil(m.job.next_retry-now)) }} 秒后重试</span></p></template>
         <p v-if="m.job?.error" class="lss-error">{{ m.job.error }}</p>
         <div class="lss-actions lss-model-actions">
@@ -138,7 +148,7 @@
           <button v-else-if="!['running','queued'].includes(m.job?.status)" type="button" class="lss-primary" :disabled="busy" @click="act(()=>request(`/models/${m.id}/download`,{method:'POST'}))">{{ m.job ? '继续 / 重试' : '下载' }}</button>
           <button v-else type="button" :disabled="busy" @click="act(()=>request(`/models/${m.id}/pause`,{method:'POST'}))">暂停</button>
           <button v-if="!m.downloaded" type="button" :disabled="busy || modelActive(m.id)" @click="openImport(m.id)">离线导入</button>
-          <button v-if="m.downloaded || m.job" type="button" :disabled="busy || form.model===m.id" @click="removeModel(m)">{{ m.downloaded ? '删除' : '取消并清理' }}</button>
+          <button v-if="m.backend!=='remote' && (m.downloaded || m.job)" type="button" :disabled="busy || form.model===m.id" @click="removeModel(m)">{{ m.downloaded ? '删除' : '取消并清理' }}</button>
         </div>
       </article>
     </div>
@@ -178,7 +188,7 @@ import UiSelect from './UiSelect.vue'
 const props=defineProps({accountWide:{type:Boolean,default:false}})
 const { selectedAccount: account }=storeToRefs(useChatAccountsStore())
 const api=useAiApi(), route=useRoute()
-const state=ref({}), form=reactive({enabled:false,model:null,usernames:[],days:90,start:null,end:null,device:'auto',device_id:0,auto_update:true,read_batch_size:0})
+const state=ref({}), form=reactive({enabled:false,model:null,usernames:[],days:90,start:null,end:null,device:'auto',device_id:0,auto_update:true,read_batch_size:0,remote_endpoint:null,remote_model:null,remote_api_key:null,remote_allow_self_signed:false})
 const statusRef=ref(null)
 const advancedOpen=ref(false),busy=ref(false),dialogError=ref(''),error=ref(''),notice=ref(''),now=ref(Date.now()/1000),gpuDevices=ref([])
 const dialog=ref(''),dialogRef=ref(null),scopeSearch=ref(''),scopeDraft=ref([]),chats=ref([]),importId=ref(''),importPath=ref('')
@@ -282,6 +292,33 @@ const date=n=>n ? new Date(n*1000).toLocaleString() : '—'
 const elapsed=j=>`${Math.max(0,Math.floor((j.finished || (['paused','done','error'].includes(j.status) ? j.updated : now.value) || now.value)-j.started))} 秒`
 const stage=j=>!j ? '未下载' : ({counting:'正在统计消息总量',importing:'导入中',pausing:'正在暂停',queued:'等待整理',connecting:'连接中',downloading:'下载中',retry_wait:'等待重试',paused:'已暂停',verifying:'校验中',verified:'校验完成',loading:'测试模型',done:'已完成',error:'处理失败',reading:'读取聊天记录',organizing:'整理消息片段',embedding:'正在理解聊天内容',saving:'正在保存搜索数据',installing:'安装加速组件'}[j.status==='error' || j.status==='paused' ? j.status : j.stage] || '处理中')
 const request=(path,options={},scoped=false)=>api.request(`/local-search${path}${scoped && account.value ? `${path.includes('?')?'&':'?'}account=${encodeURIComponent(account.value)}`:''}`,options)
+// 远端模型只按 OpenAI 兼容协议调用，常见服务用预设把地址和模型名一次填好。
+const remotePresets=[
+  {label:'WeMM 2B',endpoint:'',model:'tencent/WeMM-Embedding-2B'},
+  {label:'Ollama',endpoint:'http://127.0.0.1:11434/v1',model:'bge-m3'},
+  {label:'LM Studio',endpoint:'http://127.0.0.1:1234/v1',model:'text-embedding-bge-m3'},
+]
+const remoteTest=ref(null)
+function applyPreset(preset){
+  if(preset.endpoint)form.remote_endpoint=preset.endpoint
+  if(preset.model)form.remote_model=preset.model
+  remoteTest.value=null
+}
+const remoteTestText=computed(()=>{
+  const result=remoteTest.value
+  if(!result)return ''
+  if(result.status!=='success')return result.error || '连接失败'
+  const parts=[`连接成功，向量维度 ${result.dimension}`]
+  // 服务端不会校验模型名（写错也会返回向量），所以清单里没有就一定要提醒。
+  if(result.model_listed===false)parts.push(`但服务的模型清单里没有「${form.remote_model}」`)
+  else if(result.models?.length)parts.push(`服务提供 ${result.models.length} 个模型：${result.models.slice(0,5).join('、')}`)
+  return parts.join('；')
+})
+async function testRemote(){
+  await act(async()=>{
+    remoteTest.value=await request('/remote/test',{method:'POST',body:{endpoint:form.remote_endpoint || '',model:form.remote_model || '',api_key:form.remote_api_key || '',allow_self_signed:!!form.remote_allow_self_signed}})
+  })
+}
 let refreshDone=Promise.resolve()
 let timer, loading=false, version=0, gpuVersion=0, needsReset=false, previousFocus, stopEvents
 const defaults={...form,usernames:[]}
@@ -520,6 +557,12 @@ summary{cursor:pointer}
 .lss-model small{color:#079b57;font-size:10px;font-weight:400}.lss-model p{font-size:11px}
 .lss-model .lss-row{align-items:flex-start}.lss-model-actions{margin-top:auto;padding-top:12px}
 .lss-source{font-size:10px;color:var(--app-text-secondary);margin-top:10px;overflow-wrap:anywhere}.lss-source a{color:#079b57}
+.lss-endpoint{display:grid;gap:4px;margin-top:10px}
+.lss-endpoint>span{font-size:11px;font-weight:500}
+.lss-endpoint small{color:var(--app-text-secondary);font-size:10px;line-height:1.5}
+.lss-presets{display:flex;align-items:center;gap:6px;flex-wrap:wrap;font-size:10px;color:var(--app-text-secondary)}
+.lss-presets button{font-size:10px;padding:2px 8px;border-radius:999px;border:1px solid var(--app-border,#d8e1da);background:transparent;color:inherit;cursor:pointer}
+.lss-presets button:disabled{opacity:.5;cursor:default}
 @container (max-width:600px){.lss-heading{flex-wrap:wrap}.lss-start{align-items:stretch;flex-direction:column}.lss-start>button{width:100%}.lss-time-row{flex-wrap:wrap}.lss-time-row>.lss-note{width:100%}.lss-model-summary{flex-wrap:wrap}.lss-model-summary>.lss-grow{min-width:180px}.lss-step{padding:15px}.lss-advanced>summary>.lss-note{font-size:9px}.lss-advanced .lss-row{flex-wrap:wrap}}
 @media(max-width:600px){.lss-models,.lss-grid{grid-template-columns:1fr}.lss-row{flex-wrap:wrap}.lss-dialog{padding:16px}.lss-model-dialog{width:100%}}
 @media(prefers-reduced-motion:reduce){.agent-icon-spin{animation:none}}
diff --git a/src/wechat_decrypt_tool/ai/providers.py b/src/wechat_decrypt_tool/ai/providers.py
index efd7e078..3987cbae 100644
--- a/src/wechat_decrypt_tool/ai/providers.py
+++ b/src/wechat_decrypt_tool/ai/providers.py
@@ -91,6 +91,23 @@ def is_lan_address(host):
     return any(address in network for network in LAN_NETWORKS)
 
 
+# 代理绕过比「明文 HTTP 例外」宽：覆盖网络（Tailscale 等用 100.64.0.0/10）和链路本地
+# 地址都只能直连。这些地址交给系统代理转发会被拦下，报错看不出真正原因，所以判定
+# 独立于上面的明文策略，不改动 HTTP 明文允许范围。
+PROXY_BYPASS_NETWORKS = (*LAN_NETWORKS, ipaddress.ip_network("100.64.0.0/10"), ipaddress.ip_network("169.254.0.0/16"))
+
+
+def is_proxy_bypass_host(host):
+    """必须绕过系统代理、直连的地址：私有网段、覆盖网络（CGNAT）、链路本地。只认 IP 字面量。"""
+    if not isinstance(host, str) or "%" in host:
+        return False
+    try:
+        address = ipaddress.ip_address(host)
+    except ValueError:
+        return False
+    return any(address in network for network in PROXY_BYPASS_NETWORKS)
+
+
 def validate_url(value):
     url = urlparse(value)
     if url.scheme not in {"https", "http"} or not url.hostname or url.username or url.password or url.query or url.fragment:
diff --git a/src/wechat_decrypt_tool/ai/runtime_check.py b/src/wechat_decrypt_tool/ai/runtime_check.py
index 1585fc94..861755c7 100644
--- a/src/wechat_decrypt_tool/ai/runtime_check.py
+++ b/src/wechat_decrypt_tool/ai/runtime_check.py
@@ -119,7 +119,7 @@ def check_runtime(model_root=None):
         output = io.BytesIO(); picture.save(output, 'PDF')
         assert any(part.get('image') for part in parse_document(output.getvalue(), '.pdf'))
         report['media'] = parsed + ['.pdf', 'JPEG', 'PNG', 'WEBP', 'GIF']
-        report['catalog'] = [model_spec(name)['id'] for name in ['bge-small-zh', 'bge-base-zh', 'e5-small']]
+        report['catalog'] = [model_spec(name)['id'] for name in ['bge-small-zh', 'bge-base-zh', 'e5-small', 'remote-openai']]
         if model_root:
             engine = LocalInference()
             try:
diff --git a/src/wechat_decrypt_tool/local_search/catalog.py b/src/wechat_decrypt_tool/local_search/catalog.py
index f7a101ad..8964e780 100644
--- a/src/wechat_decrypt_tool/local_search/catalog.py
+++ b/src/wechat_decrypt_tool/local_search/catalog.py
@@ -12,6 +12,46 @@ def model_spec(id):
             return model
     raise ValueError('不支持的检索模型')
 
+def remote_spec(id, endpoint=None, model=None, api_key=None, allow_self_signed=False, dimension=None):
+    """远端模型的地址、模型名和密钥都由账号配置覆盖，目录里的值只是预设。
+
+    协议固定为 OpenAI 兼容的 /v1/embeddings，所以这里不再区分服务商。
+    """
+    spec = model_spec(id)
+    if spec.get('backend') != 'remote':
+        return spec
+    spec = {**spec}
+    endpoint = str(endpoint or '').strip().rstrip('/')
+    if endpoint:
+        spec['endpoint'] = endpoint
+    model = str(model or '').strip()
+    if model:
+        spec['model'] = model
+    key = str(api_key or '').strip()
+    if key:
+        spec['api_key'] = key
+    if allow_self_signed:
+        spec['allow_self_signed'] = True
+    if dimension:
+        try:
+            spec['dimension'] = int(dimension)
+        except (TypeError, ValueError):
+            pass
+    return spec
+
+
+def remote_identity(spec):
+    """索引身份指纹。
+
+    同一个模型 id 下换了服务地址、模型名或维度，索引里的旧向量就和新查询不在同一个
+    向量空间，余弦距离算出来只是无意义的数字，所以这些字段必须参与「要不要重建」的判断。
+    """
+    if spec.get('backend') != 'remote':
+        return None
+    fields = [str(spec.get('protocol') or 'openai'), str(spec.get('endpoint') or ''), str(spec.get('model') or ''),
+              str(spec.get('dimension') or '')]
+    return hashlib.sha256('\n'.join(fields).encode()).hexdigest()[:32]
+
 def file_hash(path):
     digest = hashlib.sha256()
     with Path(path).open('rb') as stream:
diff --git a/src/wechat_decrypt_tool/local_search/downloads.py b/src/wechat_decrypt_tool/local_search/downloads.py
index 965bd37c..774681c1 100644
--- a/src/wechat_decrypt_tool/local_search/downloads.py
+++ b/src/wechat_decrypt_tool/local_search/downloads.py
@@ -139,6 +139,10 @@ def update(self, job, **values):
     def models(self):
         values = []
         for spec in CATALOG:
+            if spec.get('backend') == 'remote':
+                values.append({**spec, 'downloaded': True, 'size': 0,
+                               'job': None})
+                continue
             root = model_dir(self.root, spec['id'])
             record = self.store.get('model', spec['id']) or {}
             available = record.get('revision') == spec['revision'] and all((root / f['path']).is_file() and (root / f['path']).stat().st_size == f['size'] for f in spec['files'])
diff --git a/src/wechat_decrypt_tool/local_search/index.py b/src/wechat_decrypt_tool/local_search/index.py
index 1583c1f3..dabaabaa 100644
--- a/src/wechat_decrypt_tool/local_search/index.py
+++ b/src/wechat_decrypt_tool/local_search/index.py
@@ -197,22 +197,41 @@ def prune(self, generation, usernames, start, end):
             db.execute('DELETE FROM chunks WHERE NOT EXISTS (SELECT 1 FROM members WHERE chunk=chunks.id)')
 
 
-def make_chunks(messages, tokenizer, max_tokens=384, overlap=64):
+def make_chunks(messages, tokenizer, max_tokens=384, overlap=64, max_chars=None):
+    """把消息切成可嵌入的块。
+
+    有 tokenizer 时按 token 精确切；远端服务可以不提供 tokenizer，这时退化为按字符切：
+    字符数是 token 数的上界（中文 1 字≈1 token，英文更省），宁可多切几块，也不越过模型
+    上下文——溢出会变成服务端 400 或静默截断，比多几个块难排查得多。
+    """
+    if tokenizer is None:
+        window = max(32, int(max_chars or max_tokens))
+        step = max(1, window - max(1, min(overlap, window // 4)))
+    else:
+        window = max_tokens
+        step = max(1, max_tokens - overlap)
+
+    def units(text):
+        return tokenizer.encode(text + '\n', add_special_tokens=False).ids if tokenizer is not None else list(text + '\n')
+
+    def text_of(part):
+        return tokenizer.decode(part) if tokenizer is not None else ''.join(part)
+
     chunks, tokens, owners, username, last_time = [], [], [], '', 0
     def flush():
         nonlocal tokens, owners
-        for start in range(0,len(tokens),max_tokens-overlap):
-            part=tokens[start:start+max_tokens]
-            text=tokenizer.decode(part)
-            if text.strip(): chunks.append({'text':text,'sources':list(dict.fromkeys(owners[start:start+max_tokens])),'username':username})
-            if start+max_tokens>=len(tokens): break
+        for start in range(0,len(tokens),step):
+            part=tokens[start:start+window]
+            text=text_of(part)
+            if text.strip(): chunks.append({'text':text,'sources':list(dict.fromkeys(owners[start:start+window])),'username':username})
+            if start+window>=len(tokens): break
         tokens,owners=[],[]
     for message in messages:
         text = '\n'.join(filter(None,[message.get('text',''),message.get('local_attachment_text','')])).strip()
         if not text: continue
         if username and (username != message['username'] or message['time'] - last_time > 600): flush()
         username, last_time = message['username'], message['time']
-        part = tokenizer.encode(text+'\n', add_special_tokens=False).ids
+        part = units(text)
         tokens.extend(part);owners.extend([message['source']]*len(part))
     flush()
     return chunks
diff --git a/src/wechat_decrypt_tool/local_search/inference.py b/src/wechat_decrypt_tool/local_search/inference.py
index df946d26..73cd3875 100644
--- a/src/wechat_decrypt_tool/local_search/inference.py
+++ b/src/wechat_decrypt_tool/local_search/inference.py
@@ -1,15 +1,18 @@
 """隔离推理进程：CUDA 故障后销毁进程，再用 CPU 重放未提交批次。"""
 from ..ai.diagnostics import observed, event as diagnostic_event
+import ipaddress
 import logging
 import json
 import multiprocessing as mp
 import os
 from pathlib import Path
+import re
 import sys
 import tempfile
 import threading
 import time
 from ..ai.diagnostics import exception_fields
+from urllib.parse import urlparse
 
 
 class InferenceFailure(RuntimeError):
@@ -18,6 +21,78 @@ def __init__(self, message, category='runtime'):
         self.category = category
 
 
+def is_lan_endpoint(endpoint):
+    """判断远端向量服务地址是否属于局域网/回环，用于决定要不要绕过系统代理。
+
+    Windows 上代理客户端会把代理写进注册表，httpx 会自动读取并使用它；不绕过的话，
+    发往局域网 GPU 的请求会被本机代理拦下，表现为 502 或超时，报错看不出真正原因。
+    """
+    host = urlparse(str(endpoint or '')).hostname
+    if not host:
+        return False
+    host = host.strip('[]').lower()
+    if host == 'localhost' or host.endswith('.local'):
+        return True
+    from ..ai.providers import is_proxy_bypass_host
+    # 私有网段、Tailscale 等 100.64/10 覆盖网络、链路本地都直连；只有真正对外的
+    # 地址才让代理参与。
+    if is_proxy_bypass_host(host):
+        return True
+    try:
+        ipaddress.ip_address(host)
+    except ValueError:
+        # 单标签主机名（如 gpu-server）按局域网处理。
+        return '.' not in host
+    return False
+
+
+def remote_api_base(endpoint):
+    """OpenAI 兼容服务的基地址：接受 .../v1、.../v1/embeddings 或裸主机地址。
+
+    用户填的地址形态不统一，这里统一归一到 `.../v1`，再拼 /embeddings 与 /models。
+    """
+    endpoint = str(endpoint or '').strip().rstrip('/')
+    if not endpoint:
+        return ''
+    if endpoint.endswith('/embeddings'):
+        endpoint = endpoint[:-len('/embeddings')]
+    if not re.search(r'/v\d+$', endpoint):
+        endpoint += '/v1'
+    return endpoint
+
+
+def decode_remote_vector(value):
+    """向量既可能是浮点数组，也可能是 base64 编码的 float32 小端数据。"""
+    if isinstance(value, list):
+        return [float(item) for item in value]
+    if isinstance(value, str):
+        import base64
+        import struct
+        raw = base64.b64decode(value)
+        if not raw or len(raw) % 4:
+            raise InferenceFailure('远端返回的 base64 向量长度不合法', 'remote')
+        return list(struct.unpack('<%df' % (len(raw) // 4), raw))
+    raise InferenceFailure('远端返回的向量格式无法识别', 'remote')
+
+
+def parse_remote_vectors(data, expected, dimension=None):
+    """按 OpenAI 规范的 index 排序取向量：不能假设服务端按返回顺序对齐请求顺序。"""
+    items = data.get('data') if isinstance(data, dict) else data
+    if not isinstance(items, list):
+        raise InferenceFailure('远端返回不是 OpenAI 兼容的向量结构', 'remote')
+    ordered = sorted(items, key=lambda item: item.get('index', 0) if isinstance(item, dict) else 0)
+    vectors = []
+    for item in ordered:
+        value = item.get('embedding') if isinstance(item, dict) else item
+        vector = decode_remote_vector(value)
+        if dimension and len(vector) != dimension:
+            raise InferenceFailure('远端向量维度与索引不一致（%d ≠ %d），请重新建立索引' % (len(vector), dimension), 'remote')
+        vectors.append(vector)
+    if len(vectors) != expected:
+        raise InferenceFailure('远端向量数量不匹配', 'remote')
+    return vectors
+
+
 def inference_worker(pipe, root, spec, device, device_id, gpu_root):
     # 子进程只经 Pipe 回传元数据，由父进程统一落盘。
     logging.disable(logging.CRITICAL)
@@ -160,8 +235,79 @@ def _receive(self, cancelled, timeout=90):
                 raise InferenceFailure('推理进程已退出', 'process')
         raise InferenceFailure('模型响应超时', 'timeout')
 
+    QUERY_MAX_CHARS = 2000
+
+    def _remote_encode(self, spec, texts, query=False, cancelled=None):
+        """调用 OpenAI 兼容的 /v1/embeddings。
+
+        协议固定为 `{model, input, encoding_format}` → `data[].embedding`，Ollama、LM Studio、
+        vLLM 等服务都提供这个入口，不需要用户另行为本工具实现一套接口。
+        """
+        import httpx
+
+        def status_message(exc):
+            response = getattr(exc, 'response', None)
+            status = getattr(response, 'status_code', 0)
+            detail = ''
+            try:
+                body = (response.text or '').strip()
+                if body:
+                    detail = '：' + body[:180]
+            except Exception:
+                detail = ''
+            if status in (401, 403):
+                return '远端服务拒绝访问（密钥无效或未授权）%s' % detail
+            if status == 404:
+                return '远端服务没有 /v1/embeddings（检查地址是否缺少 /v1，或该服务不提供向量接口）%s' % detail
+            if status == 400:
+                return '远端服务拒绝了这批文本（模型名不存在或文本超出上下文）%s' % detail
+            if status == 429:
+                return '远端服务限流，请稍后重试%s' % detail
+            if status >= 500:
+                return '远端服务返回 %d%s' % (status, detail)
+            return '远端服务返回 %d%s' % (status, detail)
+
+        endpoint = str(spec.get('endpoint') or '').strip()
+        base = remote_api_base(endpoint)
+        if not base:
+            raise InferenceFailure('远端模型未配置服务地址', 'remote')
+        model = str(spec.get('model') or '').strip()
+        if not model:
+            raise InferenceFailure('远端模型未配置模型名', 'remote')
+        if cancelled and cancelled():
+            raise InferenceFailure('处理已暂停', 'cancelled')
+        values = [str(text) for text in texts]
+        if query:
+            # 查询串按字符上界收口：上下文小的模型遇到长句会直接 400。
+            values = [text[:self.QUERY_MAX_CHARS] for text in values]
+        headers = {}
+        key = str(spec.get('api_key') or '').strip()
+        if key:
+            headers['Authorization'] = 'Bearer ' + key
+        payload = {'model': model, 'input': values, 'encoding_format': 'float'}
+        timeout = httpx.Timeout(float(spec.get('timeout') or 300.0), connect=10.0)
+        try:
+            # 局域网与覆盖网络地址绕过系统代理，否则请求会被本机代理拦下；
+            # 自签名证书只在用户显式允许时跳过校验。
+            with httpx.Client(timeout=timeout, trust_env=not is_lan_endpoint(endpoint),
+                              verify=not bool(spec.get('allow_self_signed'))) as client:
+                response = client.post(base + '/embeddings', json=payload, headers=headers)
+                response.raise_for_status()
+                data = response.json()
+        except httpx.HTTPStatusError as exc:
+            raise InferenceFailure(status_message(exc), 'remote') from None
+        except httpx.HTTPError as exc:
+            raise InferenceFailure('无法连接远端向量服务：%s' % exc, 'remote') from None
+        except ValueError as exc:
+            raise InferenceFailure('远端返回不是有效 JSON：%s' % exc, 'remote') from None
+        if cancelled and cancelled():
+            raise InferenceFailure('处理已暂停', 'cancelled')
+        return parse_remote_vectors(data, len(values), spec.get('dimension') or None)
+
     @observed('inference.encode')
     def encode(self, root, spec, texts, strategy='auto', device_id=0, query=False, cancelled=None):
+        if spec.get('backend') == 'remote':
+            return self._remote_encode(spec, texts, query=query, cancelled=cancelled)
         queued = time.monotonic()
         with self.priority:
             if query: self.query_waiting+=1
diff --git a/src/wechat_decrypt_tool/local_search/service.py b/src/wechat_decrypt_tool/local_search/service.py
index 34997cce..189b158d 100644
--- a/src/wechat_decrypt_tool/local_search/service.py
+++ b/src/wechat_decrypt_tool/local_search/service.py
@@ -12,17 +12,21 @@
 
 from ..ai.storage import AIStore
 from ..app_paths import get_data_dir, get_output_dir
-from .catalog import model_dir, model_spec
+from .catalog import model_dir, model_spec, remote_identity, remote_spec
 from .downloads import ModelDownloads
 from .index import SemanticIndex, make_chunks, fuse
-from .inference import LocalInference, InferenceFailure
+from .inference import LocalInference, InferenceFailure, is_lan_endpoint
 from .progressive import ProgressiveIndex, reading_segments, committed_coverage, coverage_complete
 from .totals import MessageTotals
 
 
 DEFAULTS = {'enabled': False, 'model': None, 'usernames': [], 'days': 90,
             'start': None, 'end': None, 'device': 'auto', 'device_id': 0, 'auto_update': True,
-            'read_batch_size': 0, 'agent_global': False}
+            'read_batch_size': 0, 'agent_global': False,
+            # 远端向量服务的四项配置。必须列在 DEFAULTS 里，否则「只改地址/模型名/密钥」
+            # 会被 _configure 的无变化判断吞掉，保存静默失效。
+            'remote_endpoint': None, 'remote_model': None, 'remote_api_key': None,
+            'remote_allow_self_signed': False, 'remote_dimension': None}
 
 # 进度事件里体积大且很少变化、或可从权威记录重建的字段，不随每次进度写入事件表。
 EVENT_OMITTED_FIELDS = frozenset({'config', 'coverage', 'segments', 'read_starts'})
@@ -76,6 +80,26 @@ async def _configure(self, account, values):
         old = self.config(account)
         cfg = {**old, **values, 'account': account}
         if cfg['model'] is not None: model_spec(cfg['model'])
+        # 留空表示沿用目录里的默认地址；非法地址在这里拦下，避免拖到检索时才报错。
+        endpoint = str(cfg.get('remote_endpoint') or '').strip().rstrip('/')
+        if endpoint and not endpoint.startswith(('http://', 'https://')):
+            raise ValueError('服务地址需要以 http:// 或 https:// 开头')
+        cfg['remote_endpoint'] = endpoint or None
+        cfg['remote_model'] = str(cfg.get('remote_model') or '').strip() or None
+        cfg['remote_api_key'] = str(cfg.get('remote_api_key') or '').strip() or None
+        # 还没选模型时不查目录：保存设备、范围等设置不该被「尚未选择模型」挡住。
+        spec = remote_spec(cfg['model'], cfg.get('remote_endpoint'), cfg.get('remote_model'),
+                           cfg.get('remote_api_key'), cfg.get('remote_allow_self_signed'),
+                           cfg.get('remote_dimension')) if cfg['model'] is not None else {}
+        if spec.get('backend') == 'remote':
+            if not spec.get('endpoint'): raise ValueError('请填写远端向量服务地址')
+            if not spec.get('model'): raise ValueError('请填写远端服务的模型名')
+            # 地址或模型名变化、或还没有探测到维度时探一次。服务暂时不可达不阻断保存，
+            # 只让索引身份里少一个维度约束，等下次保存或检索时再补。
+            if (endpoint != old.get('remote_endpoint') or cfg['remote_model'] != old.get('remote_model')
+                    or not cfg.get('remote_dimension')):
+                probed = await asyncio.to_thread(self.remote_probe, spec)
+                if probed.get('dimension'): cfg['remote_dimension'] = probed['dimension']
         if cfg['enabled'] and not self.downloads.available(cfg['model']):
             raise ValueError('请先下载并选择可用的本地模型')
         # 重复保存相同设置不使断点失效，也不打断后台任务。
@@ -167,7 +191,13 @@ async def _build(self, account, rebuild=False, incremental=True):
         end = min(cfg['end'] or int(time.time()), int(time.time()))
         start = cfg['start'] if cfg['start'] is not None else max(0, end - cfg['days'] * 86400) if cfg['days'] else 0
         active = cfg.get('active') or {}
-        new_generation = rebuild or active.get('model') != cfg['model'] or not active.get('generation')
+        # 远端服务换了地址、模型名或维度，索引里的旧向量就不在同一个向量空间里，
+        # 余弦距离只会算出无意义的数字，所以身份指纹变了必须重建。
+        identity = remote_identity(remote_spec(cfg['model'], cfg.get('remote_endpoint'), cfg.get('remote_model'),
+                                               cfg.get('remote_api_key'), cfg.get('remote_allow_self_signed'),
+                                               cfg.get('remote_dimension')))
+        new_generation = (rebuild or active.get('model') != cfg['model'] or not active.get('generation')
+                          or (identity is not None and active.get('identity') != identity))
         generation = uuid.uuid4().hex if new_generation else active['generation']
         enrichment = await asyncio.to_thread(self.enrichment_version, account)
         # 增量保留同秒和短期补写窗口；旧转写/附件变化或每天一次校对重读范围。
@@ -280,6 +310,91 @@ def pages():
             finally:
                 executor.shutdown(wait=False)
 
+    async def ensure_tokenizer(self, spec, root):
+        """尽力拿到与远端模型一致的 tokenizer；拿不到就返回 None，由切块层退化为字符上界。
+
+        切块口径必须与远端模型一致，不能用别的模型的 tokenizer 顶替，所以这里只接受远端
+        服务提供的 tokenizer.json：OpenAI、Ollama、vLLM 等通常不提供，那属于正常情况，
+        不是配置错误。
+        """
+        path = Path(root) / 'tokenizer.json'
+        if path.is_file():
+            return path
+        endpoint = str(spec.get('endpoint') or '').strip().rstrip('/')
+        if spec.get('backend') != 'remote' or not endpoint:
+            # 本地模型的缺失继续由推理层给出统一的「重新下载或导入」提示。
+            return path
+        url = endpoint + '/tokenizer.json'
+        import httpx
+        try:
+            # 局域网地址绕过系统代理，否则请求会被本机代理拦成 502。
+            async with httpx.AsyncClient(timeout=httpx.Timeout(60.0, connect=10.0), trust_env=not is_lan_endpoint(endpoint)) as client:
+                response = await client.get(url, follow_redirects=True)
+                if response.status_code == 404:
+                    diagnostic_event('inference.remote.tokenizer.absent', level=logging.INFO, url=url)
+                    return None
+                response.raise_for_status()
+                data = response.content
+        except httpx.HTTPError as exc:
+            # 取不到 tokenizer 不该让整轮索引失败：字符上界切块同样能建出可用的索引。
+            diagnostic_event('inference.remote.tokenizer.unavailable', level=logging.WARNING, url=url, error=exc)
+            return None
+        if not data.lstrip().startswith(b'{'):
+            diagnostic_event('inference.remote.tokenizer.invalid', level=logging.WARNING, url=url)
+            return None
+        # 先写临时文件再替换，中断留下的半份文件不会被当成已缓存的 tokenizer。
+        path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = path.with_name(path.name + '.part')
+        temporary.write_bytes(data)
+        temporary.replace(path)
+        return path
+
+    def remote_probe(self, spec):
+        """探测 OpenAI 兼容服务：返回模型清单、探针维度与可读错误，不抛异常。
+
+        配置保存与「测试连接」共用：模型名不做强校验（各服务的命名规则不同），只把
+        清单和命中情况报给用户。
+        """
+        import httpx
+        from .inference import remote_api_base, parse_remote_vectors
+        endpoint = str(spec.get('endpoint') or '').strip()
+        base = remote_api_base(endpoint)
+        result = {'reachable': False, 'models': [], 'dimension': None, 'model_listed': None, 'error': ''}
+        if not base:
+            result['error'] = '未填写服务地址'
+            return result
+        headers = {}
+        key = str(spec.get('api_key') or '').strip()
+        if key: headers['Authorization'] = 'Bearer ' + key
+        model = str(spec.get('model') or '').strip()
+        try:
+            with httpx.Client(timeout=httpx.Timeout(30.0, connect=8.0), trust_env=not is_lan_endpoint(endpoint),
+                              verify=not bool(spec.get('allow_self_signed'))) as client:
+                try:
+                    listed = client.get(base + '/models', headers=headers)
+                    if listed.status_code == 200:
+                        items = listed.json().get('data')
+                        if isinstance(items, list):
+                            result['models'] = [str(item['id']) for item in items if isinstance(item, dict) and item.get('id')]
+                except (httpx.HTTPError, ValueError):
+                    # 有的服务不实现 /models，探针维度仍然有效。
+                    pass
+                if result['models']:
+                    result['model_listed'] = model in result['models']
+                probe = client.post(base + '/embeddings',
+                                    json={'model': model, 'input': ['ping'], 'encoding_format': 'float'}, headers=headers)
+                if probe.status_code == 200:
+                    vectors = parse_remote_vectors(probe.json(), 1)
+                    result['dimension'] = len(vectors[0])
+                    result['reachable'] = True
+                else:
+                    result['error'] = '服务返回 %d：%s' % (probe.status_code, (probe.text or '').strip()[:180])
+        except httpx.HTTPError as exc:
+            result['error'] = '无法连接：%s' % exc
+        except (ValueError, InferenceFailure) as exc:
+            result['error'] = '响应无法解析：%s' % exc
+        return result
+
     @observed('search.run', id_field='task_id', execution=True)
     async def run(self, job):
         cfg, account = job['config'], job['account']
@@ -291,9 +406,12 @@ def check():
             try:
                 check()
                 from tokenizers import Tokenizer
-                spec = model_spec(cfg['model'])
+                spec = remote_spec(cfg['model'], cfg.get('remote_endpoint'), cfg.get('remote_model'),
+                                   cfg.get('remote_api_key'), cfg.get('remote_allow_self_signed'), cfg.get('remote_dimension'))
                 root = model_dir(self.downloads.root, cfg['model'])
-                tokenizer = Tokenizer.from_file(str(root / 'tokenizer.json'))
+                # 远端服务可以不提供 tokenizer：拿不到就按字符上界切块，而不是拒绝建索引。
+                tokenizer_path = await self.ensure_tokenizer(spec, root)
+                tokenizer = Tokenizer.from_file(str(tokenizer_path)) if tokenizer_path else None
                 index = self.index(account)
                 self.update(job, status='running', read_count=job['processed'], embedded_count=job['embedded'])
                 plan = await self.count_message_total(job, check)
@@ -340,7 +458,8 @@ def batch_size_changed(size):
                             self.update(job, stage='organizing', read_count=job['processed'] + len(messages))
                             unchanged = await asyncio.to_thread(index.existing, job['generation'], messages)
                             changed = await asyncio.to_thread(index.affected_messages, job['generation'], [m for m in messages if m['source'] not in unchanged])
-                            chunks = await asyncio.to_thread(make_chunks, changed, tokenizer)
+                            chunks = await asyncio.to_thread(make_chunks, changed, tokenizer,
+                                                              max_chars=spec.get('max_chars'))
                             diagnostic_event('index.page.organized', count=len(changed), unchanged=len(unchanged), chunks=len(chunks))
                             vectors = []
                             last_embedding_update = time.monotonic()
@@ -397,6 +516,7 @@ def batch_size_changed(size):
                 current['active'] = {'generation': job['generation'], 'model': cfg['model'], 'start': job['start'],
                                      'end': job['end'], 'usernames': cfg['usernames'], 'updated': time.time(), 'source': job.get('source'),
                                      'revision': cfg['revision'], 'enrichment': job.get('enrichment'),
+                                     'identity': remote_identity(spec),
                                      'coverage': coverage,
                                      'partial': cfg.get('agent_global', False) and not coverage_complete(coverage, cfg['usernames'], job['start'], job['end']),
                                      'reconciled': cfg.get('active',{}).get('reconciled',time.time()) if job.get('incremental') else time.time()}
@@ -459,7 +579,8 @@ def as_hit(m):
             # 渐进索引里的新消息可能尚未进入旧全文索引，原文命中必须独立于向量召回。
             committed_keyword_hits = [as_hit(m) for m in literal]
             keyword = {**keyword, 'hits': fuse([*committed_keyword_hits, *keyword.get('hits', [])], [])}
-            spec = model_spec(active['model'])
+            spec = remote_spec(active['model'], cfg.get('remote_endpoint'), cfg.get('remote_model'),
+                               cfg.get('remote_api_key'), cfg.get('remote_allow_self_signed'), cfg.get('remote_dimension'))
             root = model_dir(self.downloads.root, active['model'])
             vectors = await asyncio.to_thread(self.engine.encode, root, spec, [q], cfg['device'], cfg['device_id'], True)
             rows = await asyncio.to_thread(index.search, active['generation'], vectors[0], sorted(allowed), query_start, query_end, sender, kinds, 200)
diff --git a/src/wechat_decrypt_tool/resources/local_search_models.json b/src/wechat_decrypt_tool/resources/local_search_models.json
index ac5c2e6b..1b7fb5bc 100644
--- a/src/wechat_decrypt_tool/resources/local_search_models.json
+++ b/src/wechat_decrypt_tool/resources/local_search_models.json
@@ -136,5 +136,25 @@
       }
     ],
     "description": "适合中英文及多语言聊天"
+  },
+  {
+    "id": "remote-openai",
+    "name": "远端向量服务（OpenAI 兼容）",
+    "repo": "",
+    "revision": "",
+    "dimension": null,
+    "pooling": "last",
+    "query_prefix": "",
+    "passage_prefix": "",
+    "max_tokens": 8192,
+    "max_chars": 512,
+    "license": "",
+    "recommended": false,
+    "backend": "remote",
+    "protocol": "openai",
+    "endpoint": "",
+    "model": "",
+    "files": [],
+    "description": "连接 OpenAI 兼容的 /v1/embeddings 服务（Ollama、LM Studio、vLLM、自建网关等）。向量推理在服务端执行，本机不下载权重；建立索引时聊天文本会发送到你填写的服务。"
   }
 ]
diff --git a/src/wechat_decrypt_tool/routers/local_search.py b/src/wechat_decrypt_tool/routers/local_search.py
index f1a2f598..5cdddf9b 100644
--- a/src/wechat_decrypt_tool/routers/local_search.py
+++ b/src/wechat_decrypt_tool/routers/local_search.py
@@ -7,7 +7,7 @@
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 from .ai import local_only, account_name
 from ..local_search.service import get_local_search
-from ..local_search.catalog import model_dir
+from ..local_search.catalog import model_dir, remote_spec
 
 router = APIRouter(prefix='/api/ai/local-search', dependencies=[Depends(local_only)])
 
@@ -15,7 +15,12 @@ class Settings(BaseModel):
     model_config = ConfigDict(extra='forbid')
     enabled: bool = False
     agent_global: bool = False
-    model: Literal['bge-small-zh','bge-base-zh','e5-small'] | None = None
+    model: Literal['bge-small-zh','bge-base-zh','e5-small','remote-openai'] | None = None
+    # 仅远端模型使用；地址、模型名与密钥都由账号配置覆盖目录预设。
+    remote_endpoint: str | None = Field(default=None, max_length=2048)
+    remote_model: str | None = Field(default=None, max_length=512)
+    remote_api_key: str | None = Field(default=None, max_length=2048)
+    remote_allow_self_signed: bool = False
     usernames: list[str] = Field(default_factory=list, max_length=2000)
     days: Literal[0,30,90] = 90
     start: int | None = Field(default=None, ge=0)
@@ -33,6 +38,22 @@ def ranges(self):
 class ImportBody(BaseModel):
     path: str
 
+class RemoteTestBody(BaseModel):
+    model_config = ConfigDict(extra='forbid')
+    endpoint: str = Field(max_length=2048)
+    model: str = Field(default='', max_length=512)
+    api_key: str = Field(default='', max_length=2048)
+    allow_self_signed: bool = False
+
+@router.post('/remote/test')
+async def remote_test(body: RemoteTestBody):
+    """「测试连接」：列出服务上的模型并探测向量维度，错误文案直接给用户照着改。"""
+    spec = remote_spec('remote-openai', body.endpoint, body.model, body.api_key, body.allow_self_signed)
+    probed = await asyncio.to_thread(get_local_search().remote_probe, spec)
+    if probed.get('models') and probed.get('model_listed') is False:
+        probed['hint'] = '服务上没有这个模型名，请从上面的清单里选一个'
+    return {'status': 'success' if probed.get('reachable') else 'error', **probed}
+
 @router.get('/status')
 def status(account: str | None = None):
     return get_local_search().status(account_name(account) if account else None)
@@ -86,14 +107,13 @@ async def index_action(action: Literal['build','rebuild','pause','resume','clear
 async def recheck(account: str):
     service = get_local_search()
     cfg = service.config(account_name(account))
-    from ..local_search.catalog import model_dir, model_spec
     def reset():
         with service.engine.lock:
             service.engine.close()
             service.engine.gpu_failed = False
     await asyncio.to_thread(reset)
     try:
-        await asyncio.to_thread(service.engine.encode, model_dir(service.downloads.root,cfg['model']), model_spec(cfg['model']), ['设备检测'],cfg['device'],cfg['device_id'])
+        await asyncio.to_thread(service.engine.encode, model_dir(service.downloads.root,cfg['model']), remote_spec(cfg['model'],cfg.get('remote_endpoint'),cfg.get('remote_model'),cfg.get('remote_api_key'),cfg.get('remote_allow_self_signed'),cfg.get('remote_dimension')), ['设备检测'],cfg['device'],cfg['device_id'])
     except Exception: raise HTTPException(400,'设备检测未完成，请先准备模型和运行组件') from None
     return service.engine.status
 
diff --git a/tests/test_ai_message_pages.py b/tests/test_ai_message_pages.py
index 323e8611..b1b45c52 100644
--- a/tests/test_ai_message_pages.py
+++ b/tests/test_ai_message_pages.py
@@ -331,7 +331,7 @@ def encode(*args):
 
     engine = SimpleNamespace(status={'actual_device': 'cpu'}, gpu_root=None, gpu_failed=False,
         close=lambda: None, last_used=0, lock=threading.RLock(), key=None, encode=encode)
-    monkeypatch.setattr(module, 'make_chunks', lambda messages, tokenizer: [
+    monkeypatch.setattr(module, 'make_chunks', lambda messages, tokenizer, **kwargs: [
         {'text': '\n'.join(m['text'] for m in messages), 'sources': [m['source'] for m in messages], 'username': 'chat'}
     ] if messages else [])
 
diff --git a/tests/test_local_search.py b/tests/test_local_search.py
index 34cd1ca6..f727bb22 100644
--- a/tests/test_local_search.py
+++ b/tests/test_local_search.py
@@ -100,11 +100,19 @@ def test_fusion_dedup_and_matching_metadata():
 
 def test_catalog_pinned_and_hashed():
     from wechat_decrypt_tool.local_search.catalog import CATALOG
-    assert len(CATALOG)==3
-    for model in CATALOG:
+    local=[m for m in CATALOG if m.get('backend')!='remote']
+    remote=[m for m in CATALOG if m.get('backend')=='remote']
+    assert len(local)==3
+    for model in local:
         assert len(model['revision'])==40
         assert all(len(f['sha256'])==64 and f['size']>0 for f in model['files'])
         assert [f['path'] for f in model['files'] if f['path'].endswith('.onnx')]==['onnx/model.onnx']
+    # 远端模型不下载权重，所以不参与固定版本与哈希校验；它的约束是协议和切块上界。
+    assert [m['id'] for m in remote]==['remote-openai']
+    assert remote[0]['protocol']=='openai'
+    assert remote[0]['files']==[]
+    assert remote[0]['dimension'] is None
+    assert remote[0]['max_chars']>0 and remote[0]['max_tokens']>0
 
 def test_model_corruption_detected(tmp_path):
     (tmp_path/'test').write_bytes(b'wrong')