AI-Agent＋WebSearch

[package]
name = "mcp-free-search"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
reqwest = { version = "0.12", features = ["json"] }
scraper = "0.19" # スクレイピング用
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
url = "2.5"

use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::fs::File;
use std::io::{self, BufRead, Write};
use url::Url;

// --- データ構造定義 ---

#[derive(Deserialize, Debug)]
struct FilterLists {
    whitelist: HashSet<String>,
    blacklist: HashSet<String>,
}

#[derive(Deserialize)]
struct McpRequest {
    jsonrpc: String,
    method: String,
    params: Option<serde_json::Value>,
    id: Option<serde_json::Value>,
}

#[derive(Serialize)]
struct McpResponse {
    jsonrpc: String,
    result: serde_json::Value,
    id: Option<serde_json::Value>,
}

// --- フィルタリングロジック ---

fn is_allowed(url_str: &str, lists: &FilterLists) -> bool {
    let parsed_url = match Url::parse(url_str) {
        Ok(u) => u,
        Err(_) => return false,
    };

    let domain = parsed_url.host_str().unwrap_or("").to_string();

    // 1. ブラックリストチェック (マッチしたら除外)
    if !lists.blacklist.is_empty() && lists.blacklist.iter().any(|d| domain.contains(d)) {
        return false;
    }

    // 2. ホワイトリストチェック (リストが空でなければ、マッチしたものだけ許可)
    if !lists.whitelist.is_empty() {
        return lists.whitelist.iter().any(|d| domain.contains(d));
    }

    true
}

// --- 検索エンジン連携 (例: DuckDuckGo HTMLパース) ---
// ※注意: 大量リクエスト時は一時的にブロックされる可能性があるため、
// 本格運用の場合はローカルに「SearXNG」をDocker等で立てて、そのAPIを叩く形が最も安定します。
async fn search_internet(query: &str, lists: &FilterLists) -> Result<Vec<String>, Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder()
        .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")
        .build()?;

    // DuckDuckGoのHTML版を利用する例
    let url = format!("https://html.duckduckgo.com/html/?q={}", urlencoding::encode(query));
    let res = client.get(&url).send().await?.text().await?;

    let document = scraper::Html::parse_document(&res);
    let selector = scraper::Selector::parse(".result__url").unwrap();

    let mut results = Vec::new();

    for element in document.select(&selector) {
        if let Some(raw_url) = element.text().next() {
            let clean_url = raw_url.trim();
            // フィルタリングの適用
            if is_allowed(clean_url, lists) {
                results.push(clean_url.to_string());
            }
        }
    }

    Ok(results)
}

// --- メインループ (LM Studioとの標準入出力通信) ---

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 外部定義のリストを読み込み (config.json)
    let file = File::open("config.json").into_iter().next()
        .ok_or("config.json が見つかりません。")?;
    let lists: FilterLists = serde_json::from_reader(file)
        .unwrap_or(FilterLists { whitelist: HashSet::new(), blacklist: HashSet::new() });

    let stdin = io::stdin();
    let mut handle = stdin.lock();
    let mut buffer = String::new();

    // LM Studioからのリクエストを一行ずつ処理
    while handle.read_line(&mut buffer)? > 0 {
        let req: McpRequest = match serde_json::from_str(&buffer) {
            Ok(r) => r,
            Err(_) => {
                buffer.clear();
                continue;
            }
        };

        // MCPのメソッド判定
        if req.method == "tools/call" {
            // 例として、LLMから渡されたクエリを取得
            if let Some(params) = req.params {
                if let Some(query) = params.get("arguments").and_then(|a| a.get("query")).and_then(|q| q.as_str()) {

                    // 検索の実行
                    if let Ok(search_results) = search_internet(query, &lists).await {
                        let response = McpResponse {
                            jsonrpc: "2.0".to_string(),
                            result: serde_json::json!({
                                "content": [{
                                    "type": "text",
                                    "text": format!("検索結果: {:?}", search_results)
                                }]
                            }),
                            id: req.id,
                        };
                        println!("{}", serde_json::to_string(&response)?);
                        io::stdout().flush()?;
                    }
                }
            }
        }

        buffer.clear();
    }

    Ok(())
}

{
  "whitelist": [],
  "blacklist": [
    "wikipedia.org",
    "w3schools.com"
  ]
}

cargo build --release

{
  "mcpServers": {
    "free-search-server": {
      "command": "C:/path/to/your/project/target/release/mcp-free-search.exe",
      "args": [],
      "env": {}
    }
  }
}

"postgres-mcp": {
  "command": "npx",
  "args": [
    "-y",
    "@modelcontextprotocol/server-postgres",
    "postgresql://username:password@localhost:5432/mydb"
  ]
}

"sqlite-mcp": {
  "command": "npx",
  "args": [
    "-y",
    "@modelcontextprotocol/server-sqlite",
    "C:\\path\\to\\your\\database.db"
  ]
}