clojure-mcp 文档

{:tools-config {:dispatch_agent {:model :openai/my-o3}
                :architect {:model :anthropic/my-claude-3}
                :code_critique {:model :openai/my-gpt-4o}
                :bash {:default-timeout-ms 60000
                       :working-dir "/opt/project"
                       :bash-over-nrepl false}}

 ;; 定义上面引用的模型
 :models {:openai/my-o3 {:model-name "o3-mini"
                      :temperature 0.2
                      :api-key [:env "OPENAI_API_KEY"]}
          :openai/my-gpt-4o {:model-name "gpt-4o"
                          :temperature 0.3
                          :api-key [:env "OPENAI_API_KEY"]}
          :anthropic/my-claude-3 {:model-name "claude-3-haiku-20240307"
                                  :api-key [:env "ANTHROPIC_API_KEY"]}}}

(config/get-tools-config nrepl-client-map)
;; => {:dispatch_agent {:model :openai/o3}, :architect {...}}

(config/get-tool-config nrepl-client-map :dispatch_agent)
;; => {:model :openai/o3}

(require '[clojure-mcp.agent.langchain.model :as model])

;; 使用默认的 :model 键
(model/get-tool-model nrepl-client-map :dispatch_agent)

;; 使用自定义配置键
(model/get-tool-model nrepl-client-map :code_critique :primary-model)
(model/get-tool-model nrepl-client-map :code_critique :fallback-model)

使用附加的 ClojureMCP 文档, 创建一个最小化的自定义 MCP 服务器, 包含:
- 仅只读工具: read_file, glob_files, fs_grep, 和 directory_tree
- 无写入功能
- 一个强调代码探索和分析的自定义提示
- 在端口 3000 上启动

根据提供的 ClojureMCP 文档, 为学习 Clojure 生成一个自定义 MCP 服务器:
- 仅包含: clojure_eval, read_file, 和一个自定义的 "explain_code" 工具
- 添加一个以学习为中心的提示, 鼓励分步解释
- 将 "resources/clojure-tutorials/" 中的所有文件作为资源包含进来
- 添加一个包含常见 Clojure 习语和模式的自定义资源

使用 ClojureMCP 文档, 创建一个专注于文档的 MCP 服务器:
- 包含工具: read_file, glob_files, fs_grep, 和 file_write (仅限 .md 文件)
- 添加一个自定义工具 "generate_docs", 用于从 Clojure 代码创建文档
- 将 "docs/" 目录中的所有 markdown 文件作为资源包含进来
- 添加一个专门用于技术写作和文档的提示
- 将文件操作限制为仅 markdown 和文本文件

使用附加的文档, 为代码审查创建一个自定义的 ClojureMCP 服务器:
- 工具: read_file, fs_grep, glob_files, code_critique, 和一个自定义的 "suggest_refactoring" 工具
- 添加专注于 Clojure 最佳实践和代码质量的提示
- 将 "resources/style-guides/" 中的样式指南作为资源包含进来
- 创建一个检查常见 Clojure 反模式的自定义工具

根据提供的文档, 为 TDD 工作流生成一个 ClojureMCP 服务器:
- 包含: clojure_eval, read_file, file_write, 和自定义的 "run_tests" 和 "generate_test" 工具
- 添加一个以 TDD 为中心的提示, 鼓励先编写测试
- 创建一个从函数定义生成测试桩的自定义工具
- 将测试模板作为资源包含进来

使用 ClojureMCP 文档, 创建一个用于数据分析的服务器:
- 工具: clojure_eval, read_file, 和用于 CSV/JSON 处理的自定义工具
- 添加一个自定义的 "visualize_data" 工具, 用于生成 ASCII 图表
- 将数据分析库的文档作为资源包含进来
- 创建专注于数据探索和洞察的提示

根据 ClojureMCP 文档, 为 [你的领域] 创建一个自定义服务器:
- 仅包含与 [你的领域] 相关的工具
- 添加包装 [你的领域] 操作的自定义工具
- 将 "[你的领域]/templates/" 中的所有文件作为提示包含进来
- 从 "[你的领域]/documentation/" 添加资源
- 创建理解 [你的领域] 术语的领域特定提示

使用 ClojureMCP 文档, 创建一个将我现有的 Clojure 函数作为工具的服务器:
- 将这些函数转换为 MCP 工具: [在此粘贴你的函数]
- 对复杂工具使用 multimethod 方法
- 对简单工具使用简单的 map 方法
- 包含适当的验证和错误处理

生成一个与外部服务集成的 ClojureMCP 服务器:
- 创建一个调用我的 REST API 的自定义工具, URL 为 [URL]
- 添加一个与我的数据库交互的工具 (只读)
- 包含身份验证处理
- 添加适当的错误处理和重试机制

使用文档创建一个高度受限的 ClojureMCP 服务器:
- 仅将特定目录列入文件操作的白名单
- 禁用所有写操作, 除了在 "/tmp/mcp-workspace/" 中
- 为所有用户输入添加自定义验证
- 为所有操作包含审计日志
- 将 clojure_eval 限制为安全的函数子集

:models {;; 一个快速, 专注的 GPT-4 配置
         :openai/my-fast-gpt {:model-name "gpt-4o"
                              :temperature 0.3
                              :max-tokens 2048}

         ;; 一个创意写作配置
         :openai/my-creative-gpt {:model-name "gpt-4o"
                                  :temperature 1.5
                                  :max-tokens 8192}

         ;; 一个平衡的 Claude 配置
         :anthropic/my-claude {:model-name "claude-3-5-sonnet-20241022"
                               :temperature 0.7
                               :max-tokens 4096}}

:models {;; OpenAI 推理模型
         :openai/my-o3 {:model-name "o3"
                        :max-tokens 8192
                        :thinking {:effort :high}}

         ;; Anthropic 推理模型
         :anthropic/my-reasoning-claude {:model-name "claude-3-5-sonnet-20241022"
                                         :max-tokens 8192
                                         :thinking {:enabled true
                                                    :return true
                                                    :send true
                                                    :budget-tokens 4096}}

         ;; Google Gemini 推理模型
         :google/my-gemini-reasoning {:model-name "gemini-2.5-pro"
                                      :max-tokens 8192
                                      :thinking {:enabled true
                                                 :effort :medium
                                                 :budget-tokens 8192}}}

:models {;; 带有代码执行的 Google Gemini
         :google/my-gemini-coder {:model-name "gemini-2.5-flash"
                                  :temperature 0.5
                                  :max-tokens 4096
                                  :google {:allow-code-execution true
                                           :include-code-execution-output true}}

         ;; 带有缓存的 Anthropic
         :anthropic/my-cached-claude {:model-name "claude-3-5-sonnet-20241022"
                                      :max-tokens 4096
                                      :anthropic {:cache-system-messages true
                                                  :cache-tools true}}

         ;; 带有组织设置的 OpenAI
         :openai/my-org-gpt {:model-name "gpt-4o"
                             :max-tokens 4096
                             :openai {:organization-id "org-123"
                                      :project-id "proj-456"
                                      :strict-tools true}}}

(require '[clojure-mcp.agent.langchain.model :as model])

;; 直接创建一个模型
(let [model (model/create-model-from-config nrepl-client-map :openai/my-fast-gpt)]
  ;; 使用模型...
  )

;; 在运行时覆盖参数
(let [model (model/create-model-from-config
             nrepl-client-map
             :openai/my-fast-gpt
             {:temperature 0.5})] ; 覆盖 temperature
  ;; 使用模型...
  )

;; 获取一个构建器以进行进一步定制
(let [builder (model/create-model-builder-from-config
               nrepl-client-map
               :anthropic/my-claude)
      model (.build builder)]
  ;; 使用模型...
  )

;; 如果 :openai/gpt-4o 不在你的配置中, 它将使用内置的默认值
(let [model (model/create-model-from-config nrepl-client-map :openai/gpt-4o)]
  ;; 使用内置配置
  )

(ns my-company.read-only-server
  (:require [clojure-mcp.core :as core]
            [clojure-mcp.main :as main]
            ;; 只导入你需要的工具
            [clojure-mcp.tools.directory-tree.tool :as directory-tree-tool]
            [clojure-mcp.tools.unified-read-file.tool :as unified-read-file-tool]
            [clojure-mcp.tools.grep.tool :as new-grep-tool]
            [clojure-mcp.tools.glob-files.tool :as glob-files-tool]
            [clojure-mcp.tools.think.tool :as think-tool]
            [clojure-mcp.tools.eval.tool :as eval-tool]
            [clojure-mcp.tools.project.tool :as project-tool]))

(defn make-read-only-tools [nrepl-client-atom working-directory]
  ;; 只包含只读和评估工具
  [(directory-tree-tool/directory-tree-tool nrepl-client-atom)
   (unified-read-file-tool/unified-read-file-tool nrepl-client-atom)
   (new-grep-tool/grep-tool nrepl-client-atom)
   (glob-files-tool/glob-files-tool nrepl-client-atom)
   (think-tool/think-tool nrepl-client-atom)
   (eval-tool/eval-code nrepl-client-atom)
   (project-tool/inspect-project-tool nrepl-client-atom)])

(defn start-mcp-server [opts]
  (core/build-and-start-mcp-server
   opts
   {:make-tools-fn make-read-only-tools
    :make-prompts-fn main/make-prompts
    :make-resources-fn main/make-resources}))

(ns my-company.mcp-server
  (:require [clojure-mcp.core :as core]
            [clojure-mcp.main :as main]
            [my-company.database-tool :as db-tool]))

(defn make-tools [nrepl-client-atom working-directory]
  ;; 从 main 工具开始, 并添加你自己的
  (conj (main/make-tools nrepl-client-atom working-directory)
        (db-tool/database-query-tool nrepl-client-atom)))

(defn start-mcp-server [opts]
  (core/build-and-start-mcp-server
   opts
   {:make-tools-fn make-tools
    :make-prompts-fn main/make-prompts
    :make-resources-fn main/make-resources}))

(defn make-tools [nrepl-client-atom working-directory]
  (let [standard-tools (main/make-tools nrepl-client-atom working-directory)]
    ;; 查找并修改特定工具
    (map (fn [tool]
           (case (:name tool)
             ;; 将 bash 重命名为更具体的名称
             "bash" (assoc tool
                          :name "shell_command"
                          :description "在项目目录中执行 shell 命令. 用于: git 操作, 运行测试, 文件系统操作.")

             ;; 使文件读取更加突出
             "read_file" (assoc tool
                               :description "先读文件! 编辑前务必使用此工具. 智能读取器, 支持 Clojure 文件的模式匹配.")

             ;; 不鼓励使用 file_edit, 提倡使用 clojure_edit
             "file_edit" (assoc tool
                               :description "简单的文本替换 - 避免用于 Clojure 文件! 请改用 clojure_edit.")

             ;; 返回未修改的
             tool))
         standard-tools)))

(defn prefix-tool-names [prefix tools]
  (map #(update % :name (fn [n] (str prefix "_" n))) tools))

(defn make-tools [nrepl-client-atom working-directory]
  (concat
   ;; 带前缀的标准工具
   (prefix-tool-names "core" (main/make-tools nrepl-client-atom working-directory))

   ;; 带有不同前缀的你的自定义工具
   (prefix-tool-names "custom"
                      [(my-special-tool/special-tool nrepl-client-atom)])))

(ns my-company.custom-mcp-server
  (:require [clojure-mcp.core :as core]
            [clojure-mcp.main :as main]
            [clojure-mcp.resources :as resources]
            [clojure.string :as str]))

(defn customize-for-safety [tool]
  ;; 让所有编辑工具都警告安全问题
  (if (str/includes? (:name tool) "edit")
    (update tool :description
            #(str "⚠️ 小心: 这会修改文件! " %))
    tool))

(defn make-tools [nrepl-client-atom working-directory]
  (->> (main/make-tools nrepl-client-atom working-directory)
       ;; 移除我们不想要的工具
       (remove #(= (:name %) "bash"))  ; 太危险了
       ;; 修改剩余的工具
       (map customize-for-safety)
       ;; 重命名潜在的冲突
       (map (fn [tool]
              (case (:name tool)
                "think" (assoc tool :name "reflect")  ; 避免与其他系统冲突
                tool)))))

(defn make-resources [nrepl-client-atom working-dir]
  (let [standard-resources (main/make-resources nrepl-client-atom working-dir)]
    (concat
     ;; 修改现有资源
     (map (fn [resource]
            (case (:name resource)
              ;; 让项目摘要更突出
              "PROJECT_SUMMARY.md"
              (assoc resource
                     :name "MAIN_PROJECT_CONTEXT"
                     :description "关键: 主要项目文档 - 务必先加载此项!")

              ;; 其他保持原样
              resource))
          standard-resources)

     ;; 添加你自己的
     [(resources/create-file-resource
       "custom://runbook"
       "RUNBOOK.md"
       "应急程序和操作手册"
       "text/markdown"
       (str working-dir "/docs/RUNBOOK.md"))])))

(defn start-mcp-server [opts]
  (core/build-and-start-mcp-server
   opts
   {:make-tools-fn make-tools
    :make-prompts-fn main/make-prompts
    :make-resources-fn make-resources}))

(defn make-dev-tools [nrepl-client-atom working-directory]
  ;; 所有工具, 包括编辑
  (main/make-tools nrepl-client-atom working-directory))

(defn make-prod-tools [nrepl-client-atom working-directory]
  ;; 用于生产调试的只读工具
  [(read-tool/unified-read-file-tool nrepl-client-atom)
   (eval-tool/eval-code nrepl-client-atom)])

(defn start-mcp-server [{:keys [env] :as opts}]
  (let [tools-fn (if (= env "production") make-prod-tools make-dev-tools)]
    (core/build-and-start-mcp-server
     opts
     {:make-tools-fn tools-fn
      :make-prompts-fn main/make-prompts
      :make-resources-fn main/make-resources})))

(defn make-web-app-tools [nrepl-client-atom working-directory]
  ;; Web 开发工具
  (concat
   (main/make-tools nrepl-client-atom working-directory)
   [(http-tool/http-client-tool nrepl-client-atom)]))

(defn make-library-tools [nrepl-client-atom working-directory]
  ;; 库开发工具 - 专注于文档和 API 设计
  (concat
   [(doc-tool/documentation-tool nrepl-client-atom)]
   (main/make-tools nrepl-client-atom working-directory)))

(ns my-company.sse-server
  (:require [clojure-mcp.main :as main]
            [clojure-mcp.sse-core :as sse-core]))

(defn start-sse-mcp-server [opts]
  ;; 使用 SSE 传输代替 stdio
  (sse-core/build-and-start-mcp-server
   opts
   {:make-tools-fn main/make-tools
    :make-prompts-fn main/make-prompts
    :make-resources-fn main/make-resources}))

{:type "object"
 :properties {"param1" {:type "string"
                        :description "Description of param1"}
              "param2" {:type "integer"
                        :description "Description of param2"}}
 :required ["param1"]}  ; 必需参数名称的列表

(fn [exchange params callback]
  ;; 工具实现
  )

(callback result-vector error-boolean)

(defmethod tool-system/tool-name :my-custom-tool [_]
  "my_custom_tool")

(ns my-project.tools.echo.tool
  "返回输入消息的简单 echo 工具."
  (:require
   [clojure-mcp.tool-system :as tool-system]))

;; 创建工具配置的工厂函数
(defn create-echo-tool
  "创建 echo 工具配置."
  []
  {:tool-type :echo})

;; 工具名称 (在 AI 看来)
(defmethod tool-system/tool-name :echo [_]
  "echo")

;; 给 AI 助手的描述
(defmethod tool-system/tool-description :echo [_]
  "返回带可选前缀的输入消息的 Echo 工具.

   参数:
   - message: 要回显的消息 (必需)
   - prefix: 要添加到消息的可选前缀")

;; 输入 schema 验证
(defmethod tool-system/tool-schema :echo [_]
  {:type :object
   :properties {:message {:type :string
                          :description "要回显的消息"}
                :prefix {:type :string
                         :description "消息的可选前缀"}}
   :required [:message]})

;; 输入验证和规范化
(defmethod tool-system/validate-inputs :echo [_ inputs]
  (let [{:keys [message prefix]} inputs]
    (when-not message
      (throw (ex-info "Missing required parameter: message" {:inputs inputs})))

    (when (not (string? message))
      (throw (ex-info "Message must be a string" {:inputs inputs})))

    {:message message
     :prefix (or prefix "")}))

;; 执行工具操作
(defmethod tool-system/execute-tool :echo [_ inputs]
  (let [{:keys [message prefix]} inputs]
    {:echo-result (str prefix message)
     :original-message message
     :had-prefix (not (empty? prefix))}))

;; 为 MCP 协议格式化结果
(defmethod tool-system/format-results :echo [_ result]
  {:result [(str "Echo: " (:echo-result result))]
   :error false})

;; 注册函数
(defn echo-tool
  "返回 echo 工具的注册 map."
  []
  (tool-system/registration-map (create-echo-tool)))

(ns my-project.tools.file-counter.tool
  "用于计算文件中带过滤行数的工具."
  (:require
   [clojure-mcp.tool-system :as tool-system]
   [clojure-mcp.utils.valid-paths :as valid-paths]
   [clojure.java.io :as io]
   [clojure.string :as str]))

;; 带有依赖的工厂函数
(defn create-file-counter-tool
  "创建带有 nREPL 客户端依赖的文件计数器工具."
  [nrepl-client-atom]
  {:tool-type :file-counter
   :nrepl-client-atom nrepl-client-atom})

(defmethod tool-system/tool-name :file-counter [_]
  "file_counter")

(defmethod tool-system/tool-description :file-counter [_]
  "计算文件中带可选过滤的行数.

   参数:
   - path: 文件或目录的路径
   - pattern: 可选的用于匹配行的正则表达式模式
   - include_empty: 是否包含空行 (默认: true)")

(defmethod tool-system/tool-schema :file-counter [_]
  {:type :object
   :properties {:path {:type :string :description "文件或目录的路径"}
                :pattern {:type :string :description "用于匹配行的正则表达式"}
                :include_empty {:type :boolean :description "包含空行"}}
   :required [:path]})

(defmethod tool-system/validate-inputs :file-counter [{:keys [nrepl-client-atom]} inputs]
  (let [{:keys [path pattern include_empty]} inputs
        nrepl-client @nrepl-client-atom]

    ;; 验证路径存在且可访问
    (let [validated-path (valid-paths/validate-path-with-client path nrepl-client)
          file (io/file validated-path)]

      (when-not (.exists file)
        (throw (ex-info "File does not exist" {:path validated-path})))

      ;; 如果提供了正则表达式模式, 则进行验证
      (when pattern
        (try (re-pattern pattern)
             (catch Exception e
               (throw (ex-info "Invalid regex pattern"
                             {:pattern pattern :error (.getMessage e)})))))

      {:path validated-path
       :pattern pattern
       :include-empty (if (nil? include_empty) true include_empty)})))

(defmethod tool-system/execute-tool :file-counter [_ inputs]
  (let [{:keys [path pattern include-empty]} inputs
        file (io/file path)
        regex (when pattern (re-pattern pattern))]

    (if (.isDirectory file)
      ;; 处理目录
      (let [files (->> (file-seq file)
                       (filter #(.isFile %))
                       (filter #(str/ends-with? (.getName %) ".clj")))
            results (for [f files]
                      (let [lines (line-seq (io/reader f))
                            filtered-lines (cond->> lines
                                             (not include-empty) (remove str/blank?)
                                             regex (filter #(re-find regex %)))]
                        {:file (.getPath f)
                         :line-count (count filtered-lines)}))]
        {:type :directory
         :path path
         :total-files (count results)
         :total-lines (reduce + (map :line-count results))
         :file-results results})

      ;; 处理单个文件
      (let [lines (line-seq (io/reader file))
            filtered-lines (cond->> lines
                             (not include-empty) (remove str/blank?)
                             regex (filter #(re-find regex %)))]
        {:type :file
         :path path
         :line-count (count filtered-lines)
         :total-lines (count (line-seq (io/reader file)))}))))

(defmethod tool-system/format-results :file-counter [_ result]
  (case (:type result)
    :file
    {:result [(str "File: " (:path result))
              (str "Matching lines: " (:line-count result))
              (str "Total lines: " (:total-lines result))]
     :error false}

    :directory
    {:result (concat [(str "Directory: " (:path result))
                      (str "Files processed: " (:total-files result))
                      (str "Total matching lines: " (:total-lines result))
                      ""]
                     (map #(str "  " (:file %) ": " (:line-count %) " lines")
                          (:file-results result)))
     :error false}))

(defn file-counter-tool
  "返回文件计数器工具的注册 map."
  [nrepl-client-atom]
  (tool-system/registration-map (create-file-counter-tool nrepl-client-atom)))

(ns my-project.tools.file-counter.core
  "核心文件计数功能."
  (:require
   [clojure.java.io :as io]
   [clojure.string :as str]))

(defn count-lines-in-file
  "在单个文件中计算行数, 带可选过滤."
  [file-path & {:keys [pattern include-empty]
                :or {include-empty true}}]
  (let [file (io/file file-path)
        lines (line-seq (io/reader file))
        regex (when pattern (re-pattern pattern))]

    (when-not (.exists file)
      (throw (ex-info "File not found" {:path file-path})))

    (let [filtered-lines (cond->> lines
                           (not include-empty) (remove str/blank?)
                           regex (filter #(re-find regex %)))]
      {:path file-path
       :line-count (count filtered-lines)
       :total-lines (count lines)})))

(defn count-lines-in-directory
  "计算目录中所有文件的行数."
  [dir-path & opts]
  (let [dir (io/file dir-path)
        files (->> (file-seq dir)
                   (filter #(.isFile %)))]

    (when-not (.exists dir)
      (throw (ex-info "Directory not found" {:path dir-path})))

    {:directory dir-path
     :files (map #(apply count-lines-in-file (.getPath %) opts) files)}))

(ns my-project.tools.file-counter.tool
  "文件计数器的 MCP 工具集成."
  (:require
   [clojure-mcp.tool-system :as tool-system]
   [clojure-mcp.utils.valid-paths :as valid-paths]
   [my-project.tools.file-counter.core :as core]
   [clojure.java.io :as io]))

;; 实现使用 execute-tool 中的核心函数
(defmethod tool-system/execute-tool :file-counter [_ inputs]
  (let [{:keys [path pattern include-empty]} inputs
        file (io/file path)]
    (if (.isDirectory file)
      (core/count-lines-in-directory path
                                     :pattern pattern
                                     :include-empty include-empty)
      (core/count-lines-in-file path
                                :pattern pattern
                                :include-empty include-empty))))

(ns my-project.tools.file-counter.core-test
  (:require
   [clojure.test :refer :all]
   [my-project.tools.file-counter.core :as core]
   [clojure.java.io :as io]))

(deftest test-count-lines
  (let [temp-file (io/file "test-file.txt")]
    (try
      (spit temp-file "line 1\nline 2\n\nline 4")
      (let [result (core/count-lines-in-file (.getPath temp-file))]
        (is (= 4 (:total-lines result)))
        (is (= 4 (:line-count result))))

      (let [result (core/count-lines-in-file (.getPath temp-file)
                                             :include-empty false)]
        (is (= 3 (:line-count result))))

      (finally
        (.delete temp-file)))))

(ns my-project.tools.file-counter.tool-test
  (:require
   [clojure.test :refer :all]
   [clojure-mcp.tool-system :as tool-system]
   [clojure-mcp.config :as config]
   [my-project.tools.file-counter.tool :as tool]
   [clojure.java.io :as io]))

(deftest test-tool-integration
  (let [test-dir (System/getProperty "user.dir")
        mock-client (atom {})
        _ (config/set-config! mock-client :nrepl-user-dir test-dir)
        _ (config/set-config! mock-client :allowed-directories [test-dir])
        tool-config (tool/create-file-counter-tool mock-client)

        ;; 测试验证
        inputs {:path "README.md"}
        validated (tool-system/validate-inputs tool-config inputs)

        ;; 测试执行
        result (tool-system/execute-tool tool-config validated)

        ;; 测试格式化
        formatted (tool-system/format-results tool-config result)]

    (is (string? (:path validated)))
    (is (map? result))
    (is (vector? (:result formatted)))
    (is (false? (:error formatted)))))

(comment
  ;; 在 REPL 中测试
  (require '[my-project.tools.file-counter.tool :as tool])
  (require '[clojure-mcp.tool-system :as tool-system])
  (require '[clojure-mcp.config :as config])

  ;; 创建带有正确配置设置的工具
  (def test-dir (System/getProperty "user.dir"))
  (def mock-client (atom {}))
  (config/set-config! mock-client :nrepl-user-dir test-dir)
  (config/set-config! mock-client :allowed-directories [test-dir])
  (def tool-instance (tool/file-counter-tool mock-client))

  ;; 直接测试工具函数
  (def tool-fn (:tool-fn tool-instance))
  (tool-fn nil {"path" "README.md"}
           (fn [result error]
             (println "Result:" result)
             (println "Error:" error))))

(defmethod tool-system/validate-inputs :my-tool [_ inputs]
  (when-not (:required-param inputs)
    (throw (ex-info "Missing required parameter: required-param"
                    {:inputs inputs
                     :error-details "This parameter is needed for processing"}))))

(defmethod tool-system/validate-inputs :my-tool [_ inputs]
  (let [{:keys [file-path timeout]} inputs]
    ;; 检查必需参数
    (when-not file-path
      (throw (ex-info "Missing file path" {:inputs inputs})))

    ;; 验证类型
    (when (and timeout (not (pos-int? timeout)))
      (throw (ex-info "Timeout must be a positive integer" {:inputs inputs})))

    ;; 规范化并返回
    {:file-path (str file-path)
     :timeout (or timeout 5000)}))

(defmethod tool-system/format-results :my-tool [_ result]
  {:result [(str "Processed: " (:file result))
            (str "Lines: " (:line-count result))]
   :error false})

(defn create-my-tool
  "创建带有可配置选项的工具."
  [nrepl-client-atom & {:keys [timeout max-files]
                        :or {timeout 30000 max-files 100}}]
  {:tool-type :my-tool
   :nrepl-client-atom nrepl-client-atom
   :timeout timeout
   :max-files max-files})

(defmethod tool-system/tool-description :my-tool [_]
  "工具功能的详细描述.

   参数:
   - param1: 第一个参数的描述
   - param2: 第二个参数的描述

   示例:
   - 基本用法: tool({param1: 'value'})
   - 高级用法: tool({param1: 'value', param2: 'option'})

   注意: 任何重要的使用说明或限制.")

(fn [exchange request callback]
  ;; 资源实现
  )

(callback ["content line 1" "content line 2" ...])

(callback ["This is my resource content"])

{
  "method": "resources/read",
  "params": {
    "uri": "custom://coding-guidelines"
  }
}

(resource-fn exchange request callback)

(def advanced-resource
  {:url "custom://versioned-doc"
   :name "Versioned Documentation"
   :description "可以显示不同版本的文档"
   :mime-type "text/markdown"
   :resource-fn (fn [exchange request callback]
                  ;; 实际上, 请求对象的结构取决于 MCP
                  ;; 实现, 但如果支持, 你可以提取版本信息
                  (let [version "latest" ; 默认版本
                        content (case version
                                  "v1" "# Version 1 Documentation..."
                                  "v2" "# Version 2 Documentation..."
                                  "latest" "# Latest Documentation...")]
                    (callback [content])))})

(def config-resource
  {:url "custom://app-config"
   :name "Application Configuration"
   :description "当前应用程序设置"
   :mime-type "application/json"
   :resource-fn (fn [_ _ callback]
                  (callback [(slurp "config.json")]))})

(defn generate-api-docs [api-endpoints]
  (str "# API Documentation\n\n"
       (str/join "\n\n"
                 (map (fn [{:keys [method path description]}]
                        (format "## %s %s\n%s" method path description))
                      api-endpoints))))

(def api-docs-resource
  {:url "custom://api-docs"
   :name "API Documentation"
   :description "自动生成的 API 文档"
   :mime-type "text/markdown"
   :resource-fn (fn [_ _ callback]
                  (let [endpoints [{:method "GET" :path "/users"
                                   :description "列出所有用户"}
                                  {:method "POST" :path "/users"
                                   :description "创建一个新用户"}]
                        docs (generate-api-docs endpoints)]
                    (callback [docs])))})

(defn read-files [file-paths]
  (map #(try (slurp %)
             (catch Exception e (str "Error reading " % ": " (.getMessage e))))
       file-paths))

(def combined-docs-resource
  {:url "custom://all-docs"
   :name "All Documentation"
   :description "来自多个文件的合并文档"
   :mime-type "text/plain"
   :resource-fn (fn [_ _ callback]
                  (let [files ["README.md" "CONTRIBUTING.md" "LICENSE"]
                        contents (read-files files)
                        combined (str/join "\n\n---\n\n" contents)]
                    (callback [combined])))})

{:name        "arg-name"           ; String: 参数标识符
 :description "Argument description" ; String: 人类可读的描述
 :required?   true}                 ; Boolean: 参数是否必需

(fn [exchange request-args callback]
  ;; 提示实现
  )

(callback {:description "Description of the result"
           :messages    [{:role :user :content "Message content"}
                         {:role :assistant :content "Response content"}]})

{
  "method": "prompts/get",
  "params": {
    "name": "sync_namespace",
    "arguments": {
      "namespace": "myapp.core"
    }
  }
}

;; 你的 prompt-fn 接收到:
;; request-args = {"namespace" "myapp.core"}

(defn test-prompt-parameters []
  (let [test-callback (fn [result]
                        (println "\nResult:")
                        (println result))]

    ;; 测试 1: 提供了所有必需的参数
    (println "Test 1: Valid parameters")
    ((:prompt-fn refactoring-lesson-prompt)
     nil
     {"code_snippet" "(defn add [a b] (+ a b))"
      "focus_area" "performance"}
     test-callback)

    ;; 测试 2: 省略了可选参数 (使用默认值)
    (println "\nTest 2: Optional parameter omitted")
    ((:prompt-fn refactoring-lesson-prompt)
     nil
     {"code_snippet" "(defn add [a b] (+ a b))"}
     test-callback)

    ;; 测试 3: 缺少必需参数 (错误情况)
    (println "\nTest 3: Missing required parameter")
    ((:prompt-fn refactoring-lesson-prompt)
     nil
     {"focus_area" "readability"}
     test-callback)))

(def coding-standards
  {:name "coding_standards"
   :description "特定于项目的编码标准"
   :arguments []
   :prompt-fn (fn [_ _ callback]
                (callback
                 {:description "编码标准"
                  :messages [{:role :system
                              :content "将这些编码标准应用于所有代码..."}]}))})

(defn template-prompt [template-string]
  (fn [_ request-args callback]
    (let [filled (reduce (fn [s [k v]]
                          (str/replace s (str "{{" k "}}") (str v)))
                        template-string
                        request-args)]
      (callback
       {:description "已填充的模板"
        :messages [{:role :user :content filled}]}))))

(def bug-report-prompt
  {:name "bug_report"
   :description "生成一个 bug 报告"
   :arguments [{:name "component" :description "受影响的组件" :required? true}
               {:name "error" :description "错误消息" :required? true}]
   :prompt-fn (template-prompt "Bug in {{component}}: {{error}}\nPlease investigate.")})

(def adaptive-helper
  {:name "adaptive_helper"
   :description "根据用户专业水平提供帮助"
   :arguments [{:name "topic" :description "要解释的主题" :required? true}
               {:name "level" :description "专业水平: beginner, intermediate, expert" :required? false}]
   :prompt-fn (fn [_ request-args callback]
                (let [topic (get request-args "topic")
                      level (get request-args "level" "intermediate")
                      intro (case level
                              "beginner" "让我用简单的术语解释一下:"
                              "expert" "这是一个详细的技术解释:"
                              "让我提供一个全面的概述:")]
                  (callback
                   {:description (str "关于 " topic " 的帮助")
                    :messages [{:role :user
                                :content (str intro "\n解释 " topic)}]})))})

:resources {"deps.edn" {:description "项目依赖配置"
                        :file-path "deps.edn"}}

:resources {"deps.edn" {:description "项目依赖"
                        :file-path "deps.edn"}

            "build.clj" {:description "构建配置脚本"
                         :file-path "build.clj"}

            "CHANGELOG.md" {:description "项目变更日志和版本历史"
                            :file-path "CHANGELOG.md"}

            "API.md" {:description "API 文档"
                      :file-path "doc/API.md"}}

:resources {"custom-data" {:description "自定义数据文件"
                           :file-path "data/custom.dat"
                           :url "special://my-custom-data"
                           :mime-type "application/octet-stream"}}

:resources {"README.md" {:description "增强的项目文档"
                         :file-path "doc/README-extended.md"}

            "PROJECT_SUMMARY.md" {:description "详细的项目摘要"
                                  :file-path ".clojure-mcp/PROJECT_SUMMARY.md"}}

:file-path "doc/guide.md"        ; 解析为 <project-root>/doc/guide.md
:file-path ".clojure-mcp/info.md" ; 解析为 <project-root>/.clojure-mcp/info.md

:file-path "/usr/local/share/doc/myapp/manual.md"

:resources {"ARCHITECTURE.md" {:description "系统架构概述"
                               :file-path "doc/ARCHITECTURE.md"}
            "DATABASE.md" {:description "数据库 schema 和迁移"
                          :file-path "doc/DATABASE.md"}}

:resources {"config-dev.edn" {:description "开发配置示例"
                              :file-path "config/dev.edn"}
            "config-prod.edn" {:description "生产配置模板"
                               :file-path "config/prod.edn"}}

:resources {"test-fixtures" {:description "测试 fixture 数据"
                             :file-path "test/fixtures/data.edn"}
            "test-schema" {:description "测试数据库 schema"
                          :file-path "test/resources/schema.sql"}}