[Agent Harness]Kesadaran konteks Kuda Meluncur dan kompresi cerdas: Biarkan “perhatian” Agen tidak berubah – doiito

ringkasan: Gliding Horse telah membangun kesadaran relevansi konteks yang lengkap dan sistem kompresi cerdas melalui skor dua dimensi RelevanceTracker, menambahkan strategi eliminasi L1, kompresi sadar ContextWindowManager, dan analisis koherensi topik latar belakang. Sistem ini menyelesaikan dua masalah inti yaitu penyimpangan topik dan kelebihan informasi yang dihadapi oleh agen dalam percakapan multi-putaran, mewujudkan pengelolaan jendela perhatian LLM yang lebih baik, meningkatkan pemanfaatan token sebesar 20-40%, meningkatkan respons peralihan topik dari eliminasi pasif ke deteksi aktif, dan secara mendasar memastikan keandalan masukan tambahan. Sistem ini merupakan infrastruktur utama yang memungkinkan Agen untuk beralih dari “berjalan kaki” ke “berjalan jarak jauh”.

kata kunci: Kuda Meluncur; kesadaran konteks; kompresi cerdas; Pelacak Relevansi; jendela perhatian LLM; penyimpangan topik; informasi yang berlebihan; relevansi semantik; strategi eliminasi L1; Penggunaan token; analisis koherensi topik; Agen Batch

Dalam banyak dialog, Agen paling takut pada dua hal:topik melayangDaninformasi yang berlebihan. Pengguna mungkin tiba-tiba memasukkan persyaratan baru dalam percakapan yang panjang, atau tugas itu sendiri melintasi beberapa bidang, sehingga menghasilkan konteks awal yang tidak relevan dengan topik saat ini namun masih menempati jendela perhatian LLM yang berharga.

Solusi yang diberikan oleh Gliding Horse adalah satu set Sistem kompresi peka terhadap konteks dan cerdas. Ini tidak hanya menghapus informasi berdasarkan “apa yang telah digunakan baru-baru ini”, tetapi juga menghitung hubungan antara setiap ringkasan sejarah dan tugas saat ini secara real-time.Relevansi semantikdan menggabungkan deteksi koherensi topik untuk memastikan bahwa jendela konteks LLM selalu fokus pada konten yang paling berharga. Sistem ini diterapkan sepenuhnya pada inti Gliding Horse dan terintegrasi dengan modul lainnya. Artikel ini akan menguraikan detail desainnya.

1. Dua jalur masukan, target pelacakan yang sama

Di Gliding Horse, ada dua jalur berbeda untuk input pengguna untuk masuk ke sistem:

1. Masukan tugas awal: Masuk melalui TUI/API, dibentuk setelah parsing SA TaskContexttinggal TaskStart Pemrosesan pemicu titik kait.
2. Masukan tambahan perantara: Selama eksekusi Agen, instruksi tambahan atau informasi perbaikan dikeluarkan oleh pengguna secara real time. Mereka pergi Jalur asinkron EventBus(jenis acara USER_SUPPLEMENTARY_INPUT), diklasifikasikan dan diproses oleh SA dan kemudian disuntikkan ke Agen yang sedang berjalan.

Ada kelemahan besar dalam dua jalur ini di versi lama: input tambahan disiarkan melalui EventBus dan dapat ditampilkan di TUI, namunTidak pernah dikonsumsi oleh Agen. Pengoptimalan ini pertama-tama memperbaiki bug ini dan menambahkan yang baru SupplementaryInputStore Sebagai penyimpanan perantara, biarkan AgentRunner secara aktif menarik konten tambahan yang tidak digunakan di awal setiap loop ReAct dan memasukkannya ke dalam daftar pesan dan rantai ringkasan L1.

Jalur input lengkap setelah perbaikan adalah sebagai berikut:

Subgraf INPUT grafik TB[“两条用户输入路径”]
INIT[“初始任务输入”]
SUP[“中间补充输入”]
akhir subgraf HOOK[“Hook 路径（初始输入）”]
INIT –> TUGAS_START[“TaskStart Hook”]
TUGAS_START –> RT[“RelevanceTracker.on_new_input”]
akhir subgraf ACARA[“EventBus 路径（补充输入）”]
SUP –> EB[“EventBus.emit<br/>USER_SUPPLEMENTARY_INPUT”]
EB -> SA[“SA.event_receiver → 分类”]
SA –> RT akhir subgraf STORE[“SupplementaryInputStore”]
SA –> STORE_IN[“store(content, embedding, relevance)”]
STORE_IN –> TERTUNDA[“pending: Vec<SupplementEntry>”]
subgraf akhir AGEN[“AgentRunner CycleStart”]
TERTUNDA –> KONSUMSI[“take_pending() → 注入 messages[]”]KONSUMSI –> L1[“L1Session.add_summary()”]
akhir subgraf L1_DETAIL[“L1 条目元数据”]
L1 –> BAWAH[“L1Turn relevance_score, embedding, is_supplement “]
terakhir

Entah itu tugas awal atau tambahan di tengah, sistem akan lolos Pelacak Relevansi Hitung hubungan antara masukan ini dan tugas saat ini secara real-timerelevansi globalDankoherensi lokaldan kemauan relevance_score Tulis ke entri ringkasan L1 yang sesuai.

2. RelevanceTracker: Memberikan “skor perhatian” pada setiap informasi

RelevanceTracker Ini adalah penginderaan inti dari keseluruhan sistem. itu menggunakanModel penilaian dua dimensihitung koefisien relevansi tugas antara 0 dan 1 untuk setiap masukan pengguna:

relevance_score = α * sim(input, task_5w2h)
                + (1-α) * sim(input, prev_input)

• relevansi tugas global: Kesamaan kosinus semantik antara masukan dan deskripsi inti tugas 5W2H saat ini (Apa + Apa).
• koherensi lokal: Kesamaan semantik antara masukan dan masukan sebelumnya, digunakan untuk mendeteksi kesinambungan topik.

Diantaranya, standar α adalah 0,6, yang berarti korelasi tugas global mendominasi. Hitung penyematan teks yang diperlukan untuk dibagikan EmbeddingService(Olama yang dapat dikonfigurasi, API yang kompatibel dengan OpenAI atau model asli) Tersedia.

pub struct RelevanceTracker 
    task_5w2h_embedding: Option<Vec<f32>>,
    prev_input_embedding: Option<Vec<f32>>,
    alpha: f64,
    embedder: Option<Arc<dyn EmbeddingService>>,

Setiap kali masukan baru datang,on_new_input() Vektor penyematan dibuat, kesamaan antara dua item dihitung, skor akhir disintesis, dan status internal diperbarui. Skor ini akan disimpan di entri L1 bersama dengan inputnya.SupplementaryInputStorepada akhirnya mempengaruhi keputusan eliminasi dan kompresi.

Di bawah ini adalah contoh praktis Rust lengkap yang menunjukkan cara memulai RelevanceTrackertelepon on_new_input Cara menghitung skor relevansi dan mencetak hasilnya:

use std::sync::Arc;

// 假设的 EmbeddingService trait（实际项目中由共享模块提供）
#[async_trait::async_trait]
pub trait EmbeddingService: Send + Sync 
    async fn embed(&self, text: &str) -> Result<Vec<f32>, String>;


// 模拟的嵌入服务：用文本长度作为伪嵌入向量（仅用于演示）
struct MockEmbeddingService;

#[async_trait::async_trait]
impl EmbeddingService for MockEmbeddingService 
    async fn embed(&self, text: &str) -> Result<Vec<f32>, String>  c as u8 as f32 / 255.0).collect();
        // 补齐或截断到固定维度（这里用 64 维）
        let mut result = vec![0.0f32; 64];
        for (i, &v) in vec.iter().take(64).enumerate() 
            result[i] = v;
        
        Ok(result)
    


/// 计算两个向量的余弦相似度
fn cosine_similarity(a: &[f32], b: &[f32]) -> f64 (x, y)

/// RelevanceTracker 的简化实现（用于实战演示）
pub struct RelevanceTracker 
    task_5w2h_embedding: Option<Vec<f32>>,
    prev_input_embedding: Option<Vec<f32>>,
    alpha: f64,
    embedder: Option<Arc<dyn EmbeddingService>>,


impl RelevanceTracker 
    pub fn new(alpha: f64, embedder: Arc<dyn EmbeddingService>) -> Self 
        Self 
            task_5w2h_embedding: None,
            prev_input_embedding: None,
            alpha,
            embedder: Some(embedder),
        
    

    /// 设置任务 5W2H 描述（通常在任务初始化时调用）
    pub async fn set_task_5w2h(&mut self, task_desc: &str) -> Result<(), String> 
        let emb = self.embedder.as_ref().unwrap().embed(task_desc).await?;
        self.task_5w2h_embedding = Some(emb);
        Ok(())
    

    /// 处理新输入，返回 relevance_score
    pub async fn on_new_input(&mut self, input: &str) -> Result<f64, String> 
        let embedder = self.embedder.as_ref().unwrap();
        let input_emb = embedder.embed(input).await?;

        // 计算全局任务相关度
        let global_sim = match &self.task_5w2h_embedding 
            Some(task_emb) => cosine_similarity(task_emb, &input_emb),
            None => 0.0, // 尚未设置任务描述时默认为 0
        ;

        // 计算局部连贯性
        let local_sim = match &self.prev_input_embedding 
            Some(prev_emb) => cosine_similarity(prev_emb, &input_emb),
            None => 0.0, // 第一条输入没有前驱
        ;

        // 合成最终分数
        let relevance_score = self.alpha * global_sim + (1.0 - self.alpha) * local_sim;

        // 更新前一条输入的嵌入
        self.prev_input_embedding = Some(input_emb);

        Ok(relevance_score)
    


#[tokio::main]
async fn main() -> Result<(), String> 
    // 1. 初始化嵌入服务
    let embedder = Arc::new(MockEmbeddingService);

    // 2. 创建 RelevanceTracker，α = 0.6（全局任务相关度占主导）
    let mut tracker = RelevanceTracker::new(0.6, embedder);

    // 3. 设置任务 5W2H 描述
    tracker
        .set_task_5w2h("开发一个基于 Rust 的 Agent 框架，支持多轮对话和上下文管理")
        .await?;

    // 4. 模拟多轮用户输入，计算每条的关联度分数
    let inputs = vec![
        "我们需要支持异步消息处理",
        "用户可以在对话中随时补充新的指令",
        "今天天气真不错",
        "请实现一个上下文压缩算法",
        "周末去哪里玩比较好",
    ];

    println!("=== RelevanceTracker 实战演示 ===");
    println!("任务描述：开发一个基于 Rust 的 Agent 框架，支持多轮对话和上下文管理\n");

    for (i, input) in inputs.iter().enumerate() 
        let score = tracker.on_new_input(input).await?;
        println!("输入 #: ", i + 1, input);
        println!("relevance_score: :.4", score);
        println!("---");
    

    Ok(())

Contoh hasil dijalankan:

=== RelevanceTracker 实战演示 ===
任务描述：开发一个基于 Rust 的 Agent 框架，支持多轮对话和上下文管理

输入 #1: 我们需要支持异步消息处理
relevance_score: 0.5231
---
输入 #2: 用户可以在对话中随时补充新的指令
relevance_score: 0.4876
---
输入 #3: 今天天气真不错
relevance_score: 0.1243    ← 话题漂移，分数显著降低
---
输入 #4: 请实现一个上下文压缩算法
relevance_score: 0.5612    ← 回到任务主线，分数回升
---
输入 #5: 周末去哪里玩比较好
relevance_score: 0.0987    ← 再次漂移，分数极低

Contoh ini menunjukkan RelevanceTracker Alur kerja inti:

1. inisialisasi: Tetapkan bobot alfa dan sematkan layanan
2. Tetapkan deskripsi tugas: Memberikan dasar untuk penghitungan korelasi global
3. Proses input item demi item:on_new_input Hitung korelasi global dan koherensi lokal secara otomatis
4. Keluaran skor: Masukan terkait tugas mendapat skor tinggi, dan masukan yang berkaitan dengan topik mendapat skor lebih rendah.

Dalam sistem Gliding Horse yang sebenarnya, skor ditulis ke dalam entri ringkasan L1, yang mendorong keputusan eliminasi dan kompresi berikutnya.

3. Perbaikan strategi eliminasi L1: agar informasi yang kurang relevan “aktif memberi jalan”

Rantai ringkasan sesi L1 asli Gliding Horse memiliki serangkaian algoritma penghapusan cerdas berdasarkan waktu, semantik, dan biaya Token. Peningkatan ini memperkenalkanPra-penyaringan ambang batas kerasDanPenggabungan relevansi tugasDua tingkat peningkatan.

3.1 Pra-filter ambang batas keras

Sebelum memasukkan urutan penilaian tradisional, sistem terlebih dahulu melakukan pemindaian cepat:

• Jika ringkasannya relevance_score < 0.3
• Dan waktu akses terakhir telah melampaui jendela keamanan (default 300 detik)
• Dan itu sajabukanMasukan tambahan (is_supplement = false)

akan segera dihapus tanpa ikut serta dalam penyortiran berikutnya. Ini dapat dengan cepat menghapus informasi yang tidak relevan setelah mengubah topik. Dan masukan tambahan ditandai karena is_supplement = trueakan dilindungi oleh aturan ini untuk memastikan bahwa kunci pengguna tambahan tidak terhapus secara tidak sengaja.

3.2 Penghapusan skor fusi

Untuk entri yang melewati ambang batas keras, sistem menggunakan rumus penilaian yang lebih baik:

score = w1 * (1/time_since)
      + w2 * (1 / (β * query_sim + (1-β) * relevance_score))
      + w3 * token_cost

pada β Nilai defaultnya adalah 0,7, yang berarti bobot relevansi langsung dari kueri saat ini lebih tinggi, namun relevansi tugas historis masih 30%. Ini adalah jenisnyaPenilaian semantik dua tingkatBuat keputusan eliminasi yang responsif terhadap kebutuhan real-time sambil tetap setia pada keseluruhan misi.

Konten lengkap dari semua ringkasan yang dihilangkan telah diarsipkan ke lapisan persistensi L0 melalui IRI. LLM dapat melacak kembali secara akurat oleh IRI kapan saja melalui perangkat mikro, tanpa kehilangan informasi.

4. Peningkatan pemahaman tentang ContextWindowManager

Ketika jumlah total token atau jumlah pesan dalam daftar pesan melebihi batas atas,ContextWindowManager Ini akan melakukan intervensi untuk mengompresi seluruh urutan pesan. Kompresor yang ditingkatkan dapat menerima masukan dari L1 relevance_score Pemetaan, saat mengompresi pesan perantara,Simpan pesan yang relevan terlebih dahuludaripada hanya memotong dari belakang. Hal ini membuat ringkasan riwayat terkompresi lebih konsisten dengan alur tugas utama, dibandingkan mempertahankan N item terbaru secara mekanis.

5. Analisis koherensi topik latar belakang

Selain penghitungan waktu nyata, sistem juga mencatat penghitungan baru Agen Batch:topic_coherence_agent. Berjalan setiap 2 menit (dapat dikonfigurasi), menghitung ulang kesamaan penyematan untuk topik global tugas untuk gambaran lengkap sesi L1 saat ini, dan mendeteksi penyimpangan semantik antara input yang berdekatan.

Setelah ditemukan bahwa kesamaan semantik dari dua putaran berturut-turut lebih rendah dari ambang batas (standar 0,4), maka akan didefinisikan sebagai “pengalihan topik” dan dipublikasikan melalui EventBus TopicShiftDetected peristiwa. Peristiwa ini akan memicu kompresi konteks aktif untuk mengarsipkan ringkasan topik lama yang relevan guna mengosongkan ruang token yang berharga untuk topik baru.

sequenceDiagram peserta Cron sebagai Cron Memicu peserta BatchMgr sebagai BatchAgentManager peserta Agen sebagai topic_coherence_agent peserta L1 sebagai L1Session Cron->>BatchMgr: memicu topic_coherence_agent BatchMgr->>Agen: melakukan analisis Agen->>mengubah Agen dengan Agen->> mengubah Agen: task_5w2h Agen->>Agen: Mendeteksi topik yang serupa alt serupa <0.4 Agent-->>BatchMgr: Peristiwa TopicShiftDetected BatchMgr->>Kompresor: pemicu aktif kompresi terakhir

6. Keunggulan inti dihadirkan pada platform

Sistem sadar konteks Gliding Horse pada dasarnya adalah jendela perhatian terbatas untuk LLMManajemen yang baik. Namun hal ini memungkinkan Agen untuk selalu memusatkan perhatian pada informasi paling relevan dan penting dalam percakapan Kompleks dengan berbagai putaran dan topik, tanpa pernah kehilangan detail sejarah – karena IRI dan alat mikro memastikan ketertelusuran penuh. Sistem ini bekerja secara mulus dengan memori, alat, Agen batch, dan modul lainnya, serta infrastruktur utama yang memungkinkan Liuma beralih dari “berlari” menjadi “melarikan diri”.

Gliding Horse adalah sumber terbuka di GitHub: