terraphim_mcp_server 1.0.0

Model Context Protocol (MCP) server for Terraphim AI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

mod support;

use anyhow::Result;
use rmcp::{model::CallToolRequestParam, service::ServiceExt, transport::TokioChildProcess};
use serde_json::json;
use std::process::Stdio;
use tokio::process::Command;

/// Test that our bug reporting knowledge graph terms are available in autocomplete
#[tokio::test]
async fn test_kg_bug_reporting_terms_available() -> Result<()> {
    println!("🔍 Testing knowledge graph bug reporting terms availability");

    let mut cmd = Command::new(support::mcp_server_binary()?);
    cmd.stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .arg("--profile")
        .arg("desktop");

    let transport = TokioChildProcess::new(cmd)?;
    let service = ().serve(transport).await?;

    // Build autocomplete index
    let _build_result = service
        .call_tool(CallToolRequestParam {
            name: "build_autocomplete_index".into(),
            arguments: json!({
                "role": "Terraphim Engineer"
            })
            .as_object()
            .cloned(),
        })
        .await?;

    // Test autocomplete for "steps to reproduce" terms
    println!("🔧 Testing autocomplete for 'steps to reproduce' terms...");
    let steps_autocomplete = service
        .call_tool(CallToolRequestParam {
            name: "autocomplete_terms".into(),
            arguments: json!({
                "query": "steps to reproduce",
                "limit": 10,
                "role": "Terraphim Engineer"
            })
            .as_object()
            .cloned(),
        })
        .await?;

    println!("✅ Steps autocomplete: {:?}", steps_autocomplete.content);

    // Test autocomplete for "expected behavior" terms
    println!("🎯 Testing autocomplete for 'expected behavior' terms...");
    let expected_autocomplete = service
        .call_tool(CallToolRequestParam {
            name: "autocomplete_terms".into(),
            arguments: json!({
                "query": "expected behavior",
                "limit": 10,
                "role": "Terraphim Engineer"
            })
            .as_object()
            .cloned(),
        })
        .await?;

    println!(
        "✅ Expected behavior autocomplete: {:?}",
        expected_autocomplete.content
    );

    // Test autocomplete for "payroll system" terms
    println!("💰 Testing autocomplete for 'payroll system' terms...");
    let payroll_autocomplete = service
        .call_tool(CallToolRequestParam {
            name: "autocomplete_terms".into(),
            arguments: json!({
                "query": "payroll",
                "limit": 10,
                "role": "Terraphim Engineer"
            })
            .as_object()
            .cloned(),
        })
        .await?;

    println!(
        "✅ Payroll autocomplete: {:?}",
        payroll_autocomplete.content
    );

    // Test autocomplete for "data consistency" terms
    println!("🔄 Testing autocomplete for 'data consistency' terms...");
    let data_autocomplete = service
        .call_tool(CallToolRequestParam {
            name: "autocomplete_terms".into(),
            arguments: json!({
                "query": "data consistency",
                "limit": 10,
                "role": "Terraphim Engineer"
            })
            .as_object()
            .cloned(),
        })
        .await?;

    println!(
        "✅ Data consistency autocomplete: {:?}",
        data_autocomplete.content
    );

    // Test autocomplete for general "quality assurance" terms
    println!("🛡️ Testing autocomplete for 'quality assurance' terms...");
    let qa_autocomplete = service
        .call_tool(CallToolRequestParam {
            name: "autocomplete_terms".into(),
            arguments: json!({
                "query": "quality assurance",
                "limit": 10,
                "role": "Terraphim Engineer"
            })
            .as_object()
            .cloned(),
        })
        .await?;

    println!(
        "✅ Quality assurance autocomplete: {:?}",
        qa_autocomplete.content
    );

    println!("🎉 All knowledge graph term verification tests completed!");

    Ok(())
}