Scriptor Meets MCP: Real-Time C# Scripting in AI Workflows

Open-Source: https://github.com/coretravis/Scriptor

Introduction

If you’ve ever slammed your keyboard in frustration at File → New Project just to test a few lines of C#, you’re in good company. I built Scriptor to eliminate that boilerplate dance: a CLI tool that compiles and runs C# scripts on the fly, handles NuGet dependencies, and automatically finds your Main, Run, or Execute methods—no project file required.

Recently, I realized Scriptor could play an even bigger role in AI-driven development workflows. By exposing its core functionality via the Model Context Protocol (MCP), you can give language models the power to write, compile, and execute C# code dynamically. Let’s explore why this matters, how it works, and what makes Scriptor uniquely valuable—even in the face of .NET 10’s new file-based apps.

Why You Need Dynamic C# Scripting Today

• Fast Experimentation Spin up code snippets in seconds—no .csproj, no waiting for IDEs.
• Lightweight Automation Tackle quick data‐processing, file I/O, or HTTP tasks without a full solution.
• Shareable Snippets Distribute self-contained .cs files that “just run” anywhere Scriptor is installed.

With Scriptor, you simply write:

scriptor hello.cs

…and watch your script compile and execute immediately.

A Glimpse at Core Features

1. Inline NuGet References

   // #nuget: Newtonsoft.Json
   

   Automatically download, resolve dependencies, and cache packages.

2. Smart Entry-Point Detection Finds Main, Run, or Execute methods—static or instance, sync or async—or override via flags.

3. Multi-Framework Support Target anything from net8.0 down to netcoreapp3.1 or classic net48 with --framework.

4. Isolated Execution Uses collectible AssemblyLoadContexts to prevent memory leaks in long-lived hosts.

5. Verbose Diagnostics Pinpoint compilation errors, package resolution issues, or runtime exceptions with --verbose.

Scriptor vs. .NET 10 File-Based Apps

Microsoft’s .NET 10 Preview 4+ introduces file-based applications—script-style .cs files with #:package or #:sdk directives. On the surface, it feels similar to Scriptor, but under the hood and in real-world workflows, there are key differences:

🎯 Final Take

• Choose .NET 10 file-based apps if you’re already on .NET 10, want zero installs beyond the SDK, and expect to scale into full projects soon.
• Stick with Scriptor when you need broad SDK/framework support, zero hidden files, advanced entry-point control, or explicit assembly isolation.

Introducing Scriptor as an MCP Tool

The Model Context Protocol (MCP) lets language models discover and invoke external “tools” via a JSON API. By wrapping Scriptor in an MCP-compliant service, you can:

1. Generate Code in-chat, then Compile & Run it instantly.
2. Automatically Resolve inline NuGet packages.
3. Fetch & Analyze stdout, stderr, and exit codes back into the model’s context.

MCP Tool Schema Example

{
  "name": "scriptor_run",
  "description": "Compile and execute a C# script with NuGet support",
  "inputs": {
    "script_source":      { "type": "string" },
    "package_directives": { "type": "array", "items": { "type": "string" } },
    "entry_method":       { "type": "string", "default": "auto" },
    "framework":          { "type": "string", "default": "net8.0" },
    "arguments":          { "type": "array", "items": { "type": "string" } }
  },
  "outputs": {
    "stdout":    { "type": "string" },
    "stderr":    { "type": "string" },
    "exit_code": { "type": "integer" }
  }
}

Compelling Use Cases

1. AI-Driven Code Generation & Validation The model proposes snippets, runs them, inspects errors, and iterates—all automatically.

2. Interactive Documentation “Show me an HTTP client example” returns real, executed results instead of placeholders.

3. Automated Refactoring & Testing Generate micro-scripts for file transformations or pattern checks and verify outcomes instantly.

4. Educational Platforms Students type C# in chat; the assistant compiles and runs code, providing immediate feedback.

5. Live Data Exploration Orchestrate API calls, CSV parsing, and custom visualization in one seamless, AI-driven session.

Beyond the Basics: Future Possibilities

• REPL-Style Sessions: Stream code → run → inspect → patch → repeat without context loss.
• Polyglot Pipelines: Combine Scriptor with Python or JS MCP tools for hybrid workflows.
• Stateful Sessions: Keep an in-memory load context alive across multiple invocations.
• Security Policies: Enforce sandbox constraints or require user confirmation for privileged operations.

Getting Started Today

1. Install Scriptor

   dotnet tool install -g Scriptor.Console
   

2. Prototype Your MCP Service

   • Expose an HTTP/gRPC endpoint accepting the above tool schema.
   • Internally invoke scriptor with given source, flags, and directives.
   • Capture and return JSON-formatted results.

3. Integrate with Your LLM Register the tool manifest so your model can discover and call scriptor_run seamlessly.

Conclusion

By combining Scriptor’s pure, flexible C# scripting—complete with broad SDK support and advanced entry-point control—with MCP’s standardized tool interface, you empower AI workflows to write, compile, and execute code in real time. Whether you’re prototyping microservices, teaching C#, automating refactoring, or powering live data explorations, this integration takes C# scripting from manual CLI commands to fully orchestrated, intelligent assistant–driven operations.

Dive into the code and contribute on GitHub: https://github.com/coretravis/Scriptor