JSON-нативное время выполнения лямбда-исчисления с метациркулярной оценкой, разработанное как сервер MCP (Model Context Protocol). Позволяет языковым моделям динамически развиваться с помощью метапрограммирования.

Быстрый старт

###Основной пример

Основные понятия

###Проблема

Для чистых моделей языка вычислений требуются вычислительные инструменты, но существующие системы либо обеспечивают фиксированные API, либо неограниченное выполнение кода. В контексте метапрограммирования и самомодификации ни один из них не идеален. Эта программа представляет структуру среднего уровня для безопасных, проверяемых, эволюционируемых вычислений.

В идеальном смысле MCP-PIF можно рассматривать как универсальный метаморфический компьютерный интерфейс, в котором языковая модель выступает в качестве исполнительной функции. Здесь мы предоставляем простой словарь примитивов лямбда-исчисления для доступа только к чистым вычислениям.

###Решение MCP-PIF обеспечивает лямбда-исчисление тремя примитивами метапрограммирования: quote — Относитесь к коду как к данным (предотвращение оценки) eval — динамически исполнять цитируемый код code_of — Проверка исходного кода любого инструмента

MCP-PIF

A JSON-native lambda calculus runtime with metacircular evaluation, designed as an MCP (Model Context Protocol) server. Enables language models to evolve tools dynamically through metaprogramming.

Quick Start

# Build the project
cabal build

# Enable debug mode for detailed evaluation tracing
MCP_DEBUG=1 cabal run mcp-pif
# Debug output (to stderr) shows:
# - Each evaluation step
# - Environment keys at each step
# - Closure creation and application
# - Tool code lookups

Basic Example

// Create a tool
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "evolve",
    "arguments": {
      "name": "square",
      "description": "Squares a number",
      "code": {"lam": "x", "body": {"mul": [{"var": "x"}, {"var": "x"}]}}
    }
  }
}

// Use the tool
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "run",
    "arguments": {
      "tool": "square",
      "input": 7
    }
  }
}
// Returns: 49

// Get help
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "help",
    "arguments": {"category": "lists"}
  }
}
// Returns: Documentation for list primitives

Core Concepts

The Problem

For pure computation language models need computational tools, but existing systems either provide fixed APIs or unrestricted code execution. In the context of metaprogramming and self-modification, neither is ideal. This program presents a middle ground structure for safe, inspectable, evolvable computation.

In the ideal sense, MCP-PIF can be thought of as a generic, metamorphic computer interface where the language model drops-in as an executive function. Here, we provide a simple vocabulary of lambda calculus primitives for access to pure computing only.

The Solution

MCP-PIF provides a lambda calculus with three metaprogramming primitives:

• quote - Treat code as data (prevent evaluation)
• eval - Execute quoted code dynamically
• code_of - Introspect any tool’s source code

This creates a metacircular system where tools can analyze and transform other tools while maintaining deterministic, fuel-bounded execution. It is homoiconic, but constrained.

It’s worth noting quote and eval are not perfectly symmetric:

-- eval cleans the environment:
let cleanEnv = M.filterWithKey (\k _ -> not $ k `elem` ["__tool_name", "__self"]) env

This prevents eval’d code from inheriting the wrong tool context. When eval executes quoted code:

• User variables ARE preserved (lexical scoping maintained)
• System variables are cleaned (__tool_name and __self removed to prevent tool context confusion)
• Tool codes remain available (for code_of introspection)
• __eval_depth counter is added (max depth: 100, prevents infinite eval loops)

The Event Horizon