feat: add wait MCP

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

Author: mudler

.github/workflows/image.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        mcp: [duckduckgo, weather, memory, homeassistant, scripts, localrecall, twitter, todo, mailbox]
+        mcp: [duckduckgo, weather, wait, memory, homeassistant, scripts, localrecall, twitter, todo, mailbox]
     permissions:
       packages: write
       contents: read

README.md

@@ -101,6 +101,55 @@ mcp:
     }
 ```
 
+### ⏱️ Wait Server
+
+A simple wait/sleep server that allows AI models to autonomously wait for a specified duration. Useful for waiting for asynchronous operations to complete.
+
+**Features:**
+- Wait for a specified duration in seconds (supports fractional seconds)
+- Context cancellation support for interruption
+- Input validation (positive duration, maximum 1 hour)
+- JSON schema validation for inputs/outputs
+
+**Tool:**
+- `wait` - Wait for a specified duration in seconds
+
+**Input Format:**
+```json
+{
+  "duration": 5.5
+}
+```
+
+**Output Format:**
+```json
+{
+  "message": "Waited for 5.50 seconds"
+}
+```
+
+**Docker Image:**
+```bash
+docker run ghcr.io/mudler/mcps/wait:latest
+```
+
+**LocalAI configuration (to add to the model config):**
+```yaml
+mcp:
+  stdio: |
+    {
+      "mcpServers": {
+        "wait": {
+          "command": "docker",
+          "args": [
+            "run", "-i", "--rm",
+            "ghcr.io/mudler/mcps/wait:master"
+          ]
+        }
+      }
+    }
+```
+
 ### 🧠 Memory Server
 
 A persistent memory storage server that allows AI models to store, retrieve, and manage information across sessions using disk-based full-text search.
@@ -992,6 +1041,7 @@ make dev
 # Build specific server
 make MCP_SERVER=duckduckgo build
 make MCP_SERVER=weather build
+make MCP_SERVER=wait build
 make MCP_SERVER=memory build
 make MCP_SERVER=shell build
 make MCP_SERVER=ssh build
@@ -1054,6 +1104,9 @@ Docker images are automatically built and pushed to GitHub Container Registry:
 - `ghcr.io/mudler/mcps/weather:latest` - Latest Weather server
 - `ghcr.io/mudler/mcps/weather:v1.0.0` - Tagged versions
 - `ghcr.io/mudler/mcps/weather:master` - Development versions
+- `ghcr.io/mudler/mcps/wait:latest` - Latest Wait server
+- `ghcr.io/mudler/mcps/wait:v1.0.0` - Tagged versions
+- `ghcr.io/mudler/mcps/wait:master` - Development versions
 - `ghcr.io/mudler/mcps/memory:latest` - Latest Memory server
 - `ghcr.io/mudler/mcps/memory:v1.0.0` - Tagged versions
 - `ghcr.io/mudler/mcps/memory:master` - Development versions

wait/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+)
+
+type Input struct {
+	Duration float64 `json:"duration" jsonschema:"duration to wait in seconds (supports fractional seconds like 0.5, 1.5)"`
+}
+
+type Output struct {
+	Message string `json:"message" jsonschema:"confirmation message indicating the wait completed"`
+}
+
+const maxDuration = 3600 // 1 hour in seconds
+
+func Wait(ctx context.Context, req *mcp.CallToolRequest, input Input) (
+	*mcp.CallToolResult,
+	Output,
+	error,
+) {
+	// Validate input
+	if input.Duration <= 0 {
+		return nil, Output{}, fmt.Errorf("duration must be positive, got: %f", input.Duration)
+	}
+	if input.Duration > maxDuration {
+		return nil, Output{}, fmt.Errorf("duration exceeds maximum of %d seconds (1 hour), got: %f", maxDuration, input.Duration)
+	}
+
+	// Convert seconds to duration
+	duration := time.Duration(input.Duration * float64(time.Second))
+
+	// Wait with context cancellation support
+	select {
+	case <-ctx.Done():
+		return nil, Output{}, ctx.Err()
+	case <-time.After(duration):
+		message := fmt.Sprintf("Waited for %.2f seconds", input.Duration)
+		return nil, Output{Message: message}, nil
+	}
+}
+
+func main() {
+	// Create a server with a single tool.
+	server := mcp.NewServer(&mcp.Implementation{Name: "wait", Version: "v1.0.0"}, nil)
+	mcp.AddTool(server, &mcp.Tool{Name: "wait", Description: "Wait for a specified duration in seconds"}, Wait)
+	if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
+		log.Fatal(err)
+	}
+}