@aris-mcp/server 1.0.0

package/dist/index.js

@@ -0,0 +1,825 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+
+// ../core/dist/redact.js
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "ssn",
+  "password",
+  "api_key",
+  "email",
+  "credit",
+  "secret",
+  "token",
+  "authorization"
+]);
+var EMAIL_REGEX = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+var SSN_REGEX = /\b\d{3}-\d{2}-\d{4}\b/g;
+var PHONE_REGEX = /\b(\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g;
+function isSensitiveKey(key) {
+  const lower = key.toLowerCase();
+  for (const sensitive of SENSITIVE_KEYS) {
+    if (lower.includes(sensitive)) {
+      return true;
+    }
+  }
+  return false;
+}
+function redactStringValue(value) {
+  let result = value;
+  result = result.replace(EMAIL_REGEX, "[REDACTED_EMAIL]");
+  result = result.replace(SSN_REGEX, "[REDACTED_SSN]");
+  result = result.replace(PHONE_REGEX, "[REDACTED_PHONE]");
+  return result;
+}
+function walkAndRedact(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => walkAndRedact(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (isSensitiveKey(key)) {
+        result[key] = "[REDACTED]";
+      } else if (typeof value === "string") {
+        result[key] = redactStringValue(value);
+      } else {
+        result[key] = walkAndRedact(value);
+      }
+    }
+    return result;
+  }
+  if (typeof obj === "string") {
+    return redactStringValue(obj);
+  }
+  return obj;
+}
+function redactPII(input) {
+  try {
+    const parsed = JSON.parse(input);
+    const redacted = walkAndRedact(parsed);
+    return JSON.stringify(redacted);
+  } catch {
+    return input;
+  }
+}
+
+// ../core/dist/compress.js
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "is",
+  "at",
+  "of",
+  "on",
+  "and",
+  "a",
+  "to",
+  "in",
+  "for",
+  "it",
+  "this",
+  "that",
+  "with",
+  "from",
+  "by",
+  "an",
+  "be",
+  "as",
+  "are",
+  "was",
+  "were",
+  "been",
+  "has",
+  "have",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "can",
+  "may",
+  "might"
+]);
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function extractKeywords(query) {
+  const words = query.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter((w) => w.length > 0 && !STOP_WORDS.has(w));
+  return new Set(words);
+}
+function splitSentences(text) {
+  return text.split(/(?<=[.?!])\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function scoreSentence(sentence, keywords) {
+  const words = sentence.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/);
+  let score = 0;
+  for (const word of words) {
+    if (keywords.has(word)) {
+      score++;
+    }
+  }
+  return score;
+}
+function compressContext(query, context) {
+  const originalTokens = estimateTokens(context);
+  const keywords = extractKeywords(query);
+  let compressed;
+  if (keywords.size === 0) {
+    compressed = context.length > 500 ? context.slice(0, 500) + "..." : context;
+  } else {
+    const sentences = splitSentences(context);
+    const relevant = sentences.filter((sentence) => scoreSentence(sentence, keywords) > 0);
+    if (relevant.length === 0) {
+      compressed = context.length > 500 ? context.slice(0, 500) + "..." : context;
+    } else {
+      compressed = relevant.join(" ");
+    }
+  }
+  const compressedTokens = estimateTokens(compressed);
+  const savedTokens = originalTokens - compressedTokens;
+  const savingsPercent = originalTokens > 0 ? Math.round(savedTokens / originalTokens * 100) : 0;
+  return {
+    original: context,
+    compressed,
+    originalTokens,
+    compressedTokens,
+    savedTokens,
+    savingsPercent
+  };
+}
+
+// ../core/dist/pipeline.js
+var MAX_PROMPT_LENGTH = 1e5;
+var MAX_CONTEXT_LENGTH = 5e5;
+var DEFAULT_TIMEOUT_MS = 3e4;
+function sanitizeContext(context) {
+  let sanitized = context.replace(/<[^>]*>/g, "");
+  const injectionPatterns = [
+    /\[SYSTEM\]/gi,
+    /\[INST\]/gi,
+    /\[\/INST\]/gi,
+    /<<SYS>>/gi,
+    /<\/SYS>/gi,
+    /\[IMPORTANT\]/gi,
+    /\{system\}/gi,
+    /###\s*(?:system|instruction|admin)\s*:/gi,
+    /(?:^|\n)system\s*:\s*/gi,
+    /BEGIN SYSTEM PROMPT/gi,
+    /END SYSTEM PROMPT/gi,
+    /IGNORE PREVIOUS INSTRUCTIONS/gi,
+    /IGNORE ALL PREVIOUS/gi,
+    /YOU ARE NOW/gi,
+    /NEW INSTRUCTIONS:/gi,
+    /OVERRIDE:/gi
+  ];
+  for (const pattern of injectionPatterns) {
+    sanitized = sanitized.replace(pattern, "");
+  }
+  return sanitized;
+}
+var ArisPipeline = class {
+  llm;
+  cache;
+  enableRedaction;
+  enableCompression;
+  debug;
+  constructor(config) {
+    this.llm = config.llmProvider;
+    this.cache = config.cache;
+    this.enableRedaction = config.enableRedaction ?? true;
+    this.enableCompression = config.enableCompression ?? true;
+    this.debug = config.debug ?? false;
+  }
+  async process(query, context, options) {
+    if (query.length > MAX_PROMPT_LENGTH) {
+      throw new Error(`Prompt exceeds maximum length of ${MAX_PROMPT_LENGTH} characters (got ${query.length})`);
+    }
+    if (context && context.length > MAX_CONTEXT_LENGTH) {
+      throw new Error(`Context exceeds maximum length of ${MAX_CONTEXT_LENGTH} characters (got ${context.length})`);
+    }
+    const sanitizedContext = context ? sanitizeContext(context) : "";
+    const originalTokens = estimateTokens(query + sanitizedContext);
+    const externalSignal = options?.signal;
+    const timeoutController = new AbortController();
+    let timeoutId;
+    if (!externalSignal) {
+      timeoutId = setTimeout(() => timeoutController.abort(), DEFAULT_TIMEOUT_MS);
+    }
+    const signal = externalSignal ?? timeoutController.signal;
+    try {
+      if (signal.aborted) {
+        throw new Error("Operation aborted");
+      }
+      const cacheKey = this.cache ? `aris:pipeline:${this.cache.hashRequest(query + sanitizedContext)}` : "";
+      if (this.cache && cacheKey) {
+        const cached = await this.cache.get(cacheKey);
+        if (cached) {
+          try {
+            const parsed = JSON.parse(cached);
+            this.log("Cache hit");
+            return { ...parsed, cached: true };
+          } catch {
+          }
+        }
+      }
+      let processedQuery = query;
+      let processedContext = sanitizedContext;
+      let redacted = false;
+      if (this.enableRedaction) {
+        processedQuery = redactPII(processedQuery);
+        if (processedContext) {
+          processedContext = redactPII(processedContext);
+        }
+        redacted = true;
+        this.log("PII redaction applied");
+      }
+      let compressed = false;
+      if (this.enableCompression && processedContext) {
+        const compression = compressContext(processedQuery, processedContext);
+        processedContext = compression.compressed;
+        compressed = true;
+        this.log(`Compression: ${compression.savedTokens} tokens saved (${compression.savingsPercent}%)`);
+      }
+      const prompt = processedContext ? `Context:
+${processedContext}
+
+Query: ${processedQuery}` : processedQuery;
+      const processedTokens = estimateTokens(prompt);
+      if (signal.aborted) {
+        throw new Error("Operation aborted");
+      }
+      this.log(`Sending to ${this.llm.name}`);
+      const llmResponse = await this.llm.send(prompt, { signal });
+      const savedTokens = originalTokens - processedTokens;
+      const savingsPercent = originalTokens > 0 ? Math.round(savedTokens / originalTokens * 100) : 0;
+      const result = {
+        response: llmResponse.content,
+        model: llmResponse.model,
+        originalTokens,
+        processedTokens,
+        savedTokens,
+        savingsPercent,
+        cached: false,
+        redacted,
+        compressed,
+        usage: llmResponse.usage
+      };
+      if (this.cache && cacheKey) {
+        await this.cache.set(cacheKey, JSON.stringify(result));
+        this.log("Response cached");
+      }
+      return result;
+    } finally {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  log(message) {
+    if (this.debug) {
+      process.stderr.write(`[aris:pipeline] ${message}
+`);
+    }
+  }
+};
+
+// ../core/dist/providers/openrouter.js
+var DEFAULT_MODEL = "minimax/minimax-m2.5";
+var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
+var OpenRouterProvider = class {
+  name = "openrouter";
+  apiKey;
+  model;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.model = config.model ?? DEFAULT_MODEL;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+  }
+  async send(prompt, options) {
+    const model = options?.model ?? this.model;
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "HTTP-Referer": "https://aris.dev",
+        "X-Title": "Aris MCP"
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: options?.maxTokens ?? 4096,
+        temperature: options?.temperature ?? 0.7
+      }),
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenRouter API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content ?? "";
+    return {
+      content,
+      model: data.model ?? model,
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens
+      } : void 0
+    };
+  }
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../core/dist/providers/ollama.js
+var DEFAULT_MODEL2 = "llama3";
+var DEFAULT_BASE_URL2 = "http://localhost:11434";
+var OllamaProvider = class {
+  name = "ollama";
+  model;
+  baseUrl;
+  constructor(config = {}) {
+    this.model = config.model ?? DEFAULT_MODEL2;
+    this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL2;
+  }
+  async send(prompt, options) {
+    const model = options?.model ?? this.model;
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: "user", content: prompt }],
+        stream: false,
+        options: {
+          num_predict: options?.maxTokens ?? 4096,
+          temperature: options?.temperature ?? 0.7
+        }
+      }),
+      signal: options?.signal
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Ollama API error (${response.status}): ${errorText}`);
+    }
+    const data = await response.json();
+    const promptTokens = data.prompt_eval_count ?? 0;
+    const completionTokens = data.eval_count ?? 0;
+    return {
+      content: data.message?.content ?? "",
+      model: data.model ?? model,
+      usage: {
+        promptTokens,
+        completionTokens,
+        totalTokens: promptTokens + completionTokens
+      }
+    };
+  }
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/tags`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../core/dist/cache.js
+import { createHash } from "crypto";
+import { Redis } from "ioredis";
+var ArisCache = class {
+  redis;
+  constructor(redisUrl) {
+    this.redis = new Redis(redisUrl ?? "redis://localhost:6379", {
+      lazyConnect: true,
+      retryStrategy: (times) => {
+        if (times > 3)
+          return null;
+        return Math.min(times * 200, 2e3);
+      }
+    });
+    this.redis.on("error", (err) => {
+      process.stderr.write(`[ArisCache] Redis connection error: ${err.message}
+`);
+    });
+    this.redis.connect().catch((err) => {
+      process.stderr.write(`[ArisCache] Failed to connect to Redis: ${err.message}
+`);
+    });
+  }
+  async get(key) {
+    try {
+      return await this.redis.get(key);
+    } catch (err) {
+      console.warn(`[ArisCache] get failed: ${err.message}`);
+      return null;
+    }
+  }
+  async set(key, value, ttlSeconds = 600) {
+    try {
+      await this.redis.set(key, value, "EX", ttlSeconds);
+    } catch (err) {
+      console.warn(`[ArisCache] set failed: ${err.message}`);
+    }
+  }
+  hashRequest(body) {
+    return createHash("sha256").update(body).digest("hex");
+  }
+  async ping() {
+    try {
+      const result = await this.redis.ping();
+      return result === "PONG";
+    } catch {
+      return false;
+    }
+  }
+  async checkThrottle(maxJoules = 5e3) {
+    try {
+      const value = await this.redis.get("aris_system_joules");
+      if (value === null)
+        return false;
+      const joules = parseFloat(value);
+      return joules > maxJoules;
+    } catch (err) {
+      console.warn(`[ArisCache] checkThrottle failed: ${err.message}`);
+      return false;
+    }
+  }
+  async disconnect() {
+    try {
+      await this.redis.quit();
+    } catch {
+    }
+  }
+};
+
+// src/config.ts
+function envBool(value, defaultValue) {
+  if (value === void 0) return defaultValue;
+  return value.toLowerCase() === "true";
+}
+function loadConfig() {
+  const llmProvider = process.env.ARIS_LLM_PROVIDER ?? "openrouter";
+  const llmApiKey = process.env.ARIS_LLM_API_KEY;
+  const ollamaUrl = process.env.ARIS_OLLAMA_URL ?? "http://localhost:11434";
+  if (llmProvider === "openrouter" && !llmApiKey) {
+    throw new Error(
+      "ARIS_LLM_API_KEY is required when ARIS_LLM_PROVIDER is 'openrouter'"
+    );
+  }
+  return {
+    endpoint: process.env.ARIS_ENDPOINT,
+    llmProvider,
+    llmApiKey,
+    llmModel: process.env.ARIS_LLM_MODEL,
+    ollamaUrl,
+    redisUrl: process.env.ARIS_REDIS_URL,
+    enableRedaction: envBool(process.env.ARIS_ENABLE_REDACTION, true),
+    enableCompression: envBool(process.env.ARIS_ENABLE_COMPRESSION, true),
+    debug: envBool(process.env.ARIS_DEBUG, false)
+  };
+}
+
+// src/tools.ts
+import { z } from "zod";
+var ToolName = {
+  OPTIMIZE: "aris_optimize",
+  HEALTH: "aris_health",
+  COMPRESS: "aris_compress"
+};
+var OptimizeInputSchema = z.object({
+  prompt: z.string().min(1, "Prompt must not be empty").max(1e5, "Prompt must be under 100,000 characters").describe(
+    "The user prompt to optimize and send through the Aris pipeline. This is the main instruction or question for the LLM."
+  ),
+  context: z.string().max(5e5, "Context must be under 500,000 characters").optional().describe(
+    "Optional background context to compress before including with the prompt. Long documents, code snippets, or reference material that will be filtered to only the sentences relevant to the prompt."
+  )
+});
+var CompressInputSchema = z.object({
+  query: z.string().min(1, "Query must not be empty").max(1e5, "Query must be under 100,000 characters").describe(
+    "The query used to determine which sentences in the context are relevant. Only sentences matching keywords from this query are retained."
+  ),
+  context: z.string().min(1, "Context must not be empty").max(5e5, "Context must be under 500,000 characters").describe(
+    "The context text to compress. Sentences not relevant to the query will be removed to reduce token usage."
+  )
+});
+var TOOL_DESCRIPTIONS = {
+  [ToolName.OPTIMIZE]: "Run a prompt through the full Aris optimization pipeline.\n\nPurpose: Reduces token usage by redacting PII, compressing context to only relevant sentences, and caching repeated requests before sending to the configured LLM (OpenRouter or Ollama).\n\nGuidelines:\n- Use when you need an LLM response but want to minimize token cost.\n- Provide context separately from the prompt for best compression.\n- The pipeline applies PII redaction, context compression, cache lookup, LLM inference, and cache storage in sequence.\n\nLimitations:\n- Prompt must be under 100K characters; context under 500K characters.\n- LLM call has a 30-second timeout.\n- Compression is keyword-based, not semantic.\n\nReturns: The LLM response text followed by pipeline statistics (original tokens, processed tokens, savings percentage, cache hit status).",
+  [ToolName.HEALTH]: "Check the health and configuration of the Aris pipeline.\n\nPurpose: Verify that the LLM provider is reachable, the cache is connected, and report which pipeline features are enabled.\n\nGuidelines:\n- Call this before aris_optimize if you suspect connectivity issues.\n- No parameters required.\n\nLimitations:\n- Only checks connectivity, not quota or billing status.\n\nReturns: JSON object with LLM provider status, cache status, and feature flags (redaction, compression).",
+  [ToolName.COMPRESS]: "Compress context text without making an LLM call.\n\nPurpose: Extract only the sentences from context that are relevant to a given query, reducing token count for downstream use.\n\nGuidelines:\n- Use when you want to pre-process context before your own LLM call.\n- The query drives keyword extraction; context is filtered by keyword match.\n\nLimitations:\n- Query must be under 100K characters; context under 500K characters.\n- Uses keyword matching, not semantic similarity.\n- If no keywords match, returns the first 500 characters of context.\n\nReturns: The compressed text followed by compression statistics (original tokens, compressed tokens, savings percentage)."
+};
+var TOOL_DEFINITIONS = [
+  {
+    name: ToolName.OPTIMIZE,
+    description: TOOL_DESCRIPTIONS[ToolName.OPTIMIZE],
+    inputSchema: {
+      type: "object",
+      properties: {
+        prompt: {
+          type: "string",
+          description: "The user prompt to optimize and send through the Aris pipeline",
+          maxLength: 1e5
+        },
+        context: {
+          type: "string",
+          description: "Optional background context to compress before including with the prompt",
+          maxLength: 5e5
+        }
+      },
+      required: ["prompt"]
+    }
+  },
+  {
+    name: ToolName.HEALTH,
+    description: TOOL_DESCRIPTIONS[ToolName.HEALTH],
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: ToolName.COMPRESS,
+    description: TOOL_DESCRIPTIONS[ToolName.COMPRESS],
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The query to use for relevance-based compression",
+          maxLength: 1e5
+        },
+        context: {
+          type: "string",
+          description: "The context text to compress",
+          maxLength: 5e5
+        }
+      },
+      required: ["query", "context"]
+    }
+  }
+];
+
+// src/index.ts
+function log(message) {
+  process.stderr.write(`[aris-mcp] ${message}
+`);
+}
+function createLLMProvider(config) {
+  if (config.llmProvider === "ollama") {
+    return new OllamaProvider({
+      baseUrl: config.ollamaUrl,
+      model: config.llmModel
+    });
+  }
+  return new OpenRouterProvider({
+    apiKey: config.llmApiKey,
+    model: config.llmModel
+  });
+}
+async function main() {
+  let config;
+  try {
+    config = loadConfig();
+  } catch (err) {
+    log(`Configuration error: ${err.message}`);
+    process.exit(1);
+  }
+  log(`Provider: ${config.llmProvider}`);
+  log(`Redaction: ${config.enableRedaction ? "enabled" : "disabled"}`);
+  log(`Compression: ${config.enableCompression ? "enabled" : "disabled"}`);
+  log(`Cache: ${config.redisUrl ? "enabled" : "disabled"}`);
+  const llmProvider = createLLMProvider(config);
+  let cache;
+  if (config.redisUrl) {
+    cache = new ArisCache(config.redisUrl);
+    log("Redis cache initialized");
+  }
+  const pipeline = new ArisPipeline({
+    llmProvider,
+    cache,
+    enableRedaction: config.enableRedaction,
+    enableCompression: config.enableCompression,
+    debug: config.debug
+  });
+  const server = new McpServer(
+    {
+      name: "aris-mcp",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.tool(
+    ToolName.OPTIMIZE,
+    TOOL_DESCRIPTIONS[ToolName.OPTIMIZE],
+    {
+      prompt: z2.string().min(1, "Prompt must not be empty").max(1e5, "Prompt must be under 100,000 characters").describe(
+        "The user prompt to optimize and send through the Aris pipeline. This is the main instruction or question for the LLM."
+      ),
+      context: z2.string().max(5e5, "Context must be under 500,000 characters").optional().describe(
+        "Optional background context to compress before including with the prompt. Long documents, code snippets, or reference material that will be filtered to only the sentences relevant to the prompt."
+      )
+    },
+    async ({ prompt, context }, { sendNotification }) => {
+      try {
+        await sendNotification({
+          method: "notifications/progress",
+          params: {
+            progressToken: "aris_optimize",
+            progress: 0,
+            total: 100,
+            message: "Starting Aris optimization pipeline..."
+          }
+        });
+        await sendNotification({
+          method: "notifications/progress",
+          params: {
+            progressToken: "aris_optimize",
+            progress: 20,
+            total: 100,
+            message: "Applying PII redaction and context compression..."
+          }
+        });
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3e4);
+        let result;
+        try {
+          result = await pipeline.process(prompt, context, {
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeout);
+        }
+        await sendNotification({
+          method: "notifications/progress",
+          params: {
+            progressToken: "aris_optimize",
+            progress: 100,
+            total: 100,
+            message: "Pipeline complete."
+          }
+        });
+        const summary = [
+          result.response,
+          "",
+          "--- Aris Pipeline Stats ---",
+          `Model: ${result.model}`,
+          `Original tokens: ${result.originalTokens}`,
+          `Processed tokens: ${result.processedTokens}`,
+          `Tokens saved: ${result.savedTokens} (${result.savingsPercent}%)`,
+          `Cached: ${result.cached}`,
+          `Redacted: ${result.redacted}`,
+          `Compressed: ${result.compressed}`
+        ];
+        if (result.usage) {
+          summary.push(
+            `LLM usage - prompt: ${result.usage.promptTokens}, completion: ${result.usage.completionTokens}, total: ${result.usage.totalTokens}`
+          );
+        }
+        return {
+          content: [{ type: "text", text: summary.join("\n") }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const errorText = message.includes("aborted") ? "Pipeline timed out after 30 seconds" : `Pipeline error: ${message}`;
+        return {
+          content: [{ type: "text", text: errorText }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    ToolName.HEALTH,
+    TOOL_DESCRIPTIONS[ToolName.HEALTH],
+    {},
+    async () => {
+      try {
+        const llmHealthy = await llmProvider.healthCheck();
+        const cacheHealthy = cache ? await cache.ping() : null;
+        const status = {
+          llm: {
+            provider: config.llmProvider,
+            model: config.llmModel ?? "(default)",
+            healthy: llmHealthy
+          },
+          cache: {
+            enabled: !!cache,
+            healthy: cacheHealthy,
+            url: config.redisUrl ? "(configured)" : "(not configured)"
+          },
+          features: {
+            redaction: config.enableRedaction,
+            compression: config.enableCompression
+          },
+          debug: config.debug
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(status, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Health check error: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    ToolName.COMPRESS,
+    TOOL_DESCRIPTIONS[ToolName.COMPRESS],
+    {
+      query: z2.string().min(1, "Query must not be empty").max(1e5, "Query must be under 100,000 characters").describe(
+        "The query used to determine which sentences in the context are relevant. Only sentences matching keywords from this query are retained."
+      ),
+      context: z2.string().min(1, "Context must not be empty").max(5e5, "Context must be under 500,000 characters").describe(
+        "The context text to compress. Sentences not relevant to the query will be removed to reduce token usage."
+      )
+    },
+    async ({ query, context }) => {
+      try {
+        const result = compressContext(query, context);
+        const summary = [
+          "Compressed context:",
+          result.compressed,
+          "",
+          "--- Compression Stats ---",
+          `Original tokens: ${result.originalTokens}`,
+          `Compressed tokens: ${result.compressedTokens}`,
+          `Tokens saved: ${result.savedTokens} (${result.savingsPercent}%)`
+        ];
+        return {
+          content: [{ type: "text", text: summary.join("\n") }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Compression error: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log("Aris MCP server running on stdio");
+  const shutdown = async () => {
+    log("Shutting down...");
+    try {
+      if (cache) {
+        await cache.disconnect();
+      }
+      await server.close();
+    } catch (err) {
+      log(`Error during shutdown: ${err.message}`);
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+main().catch((err) => {
+  log(`Fatal error: ${err.message}`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@aris-mcp/server",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "aris-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "llm",
+    "aris",
+    "optimization"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:bundle": "tsup",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "node --test --test-timeout=60000 dist/**/*.test.js",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build:bundle"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "ioredis": "^5.6.1",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "tsup": "^8.5.1",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}