# GraphSlice

> AI code intelligence for C# monorepos — GraphSlice turns a C# solution into a semantic code graph and serves only the context an LLM needs, over the Model Context Protocol (MCP).

Every blog post is available as raw Markdown at the .md URL listed below.

## Summary

GraphSlice compiles a C# solution into a compiler-grade semantic code graph, then serves only the minimal context slice an LLM needs to answer a question — over the Model Context Protocol (MCP). Instead of dumping files or relying on vector search, an AI assistant queries how the software actually fits together: types, methods, inheritance, references, call graphs and dependencies. The result is fewer tokens per query and higher-precision code generation, even on solutions with thousands of types. GraphSlice runs on-premise, so source code never leaves your infrastructure.

## Company

- [GraphSlice](https://graphslice.com/): A product of Renaissance Dad BV — built in Belgium by an independent European team for organizations with strict data-sovereignty requirements. Contact: hello@graphslice.com

## Product

- [Product overview](https://graphslice.com/): What GraphSlice is, who it's for, and how it fits into AI-assisted development.
- [How it works](https://graphslice.com/#how): The four-stage pipeline — Parse, Build, Slice, Serve — that turns a C# solution into servable context slices.

## Features

- Built specifically for C#: true C# semantics — real types, symbols and references, including external packages and BCL boundaries — not shallow syntax trees.
- Smaller context windows: only the relevant slice reaches the model, lowering token usage and raising accuracy even on solutions with thousands of types.
- AI-native: designed for LLM workflows — bring your own MCP client and connect your own LLM.
- Delivered over MCP: any MCP-compatible client can request semantic code context without indexing or uploading your repository.
- Runs on-premise: on-premises, private cloud, or air-gapped — your code never leaves your infrastructure.

## Documentation

## Teardowns

Architecture teardowns: whole C# codebases measured from their compiler graphs, every number recomputed from the code. Each teardown is available as raw Markdown at the .md URL listed below.

- [Jellyfin Architecture, Read From the Compiler](https://graphslice.com/teardowns/jellyfin.md): Jellyfin's architecture measured from its compiler graph: 40 projects, dependency cycles, blast radius, plugin seams and dead-code candidates, every number recomputed from the code.
- [The Teardown Glossary](https://graphslice.com/teardowns/glossary.md): Plain-language definitions of the graph metrics used in GraphSlice architecture teardowns: SCC, blast radius, PageRank for code, fan-in and fan-out, reachability, plugin sockets and more.

## Blog

- [The codebase nobody fully remembers](https://graphslice.com/blog/the-codebase-nobody-remembers.md): Every long-lived .NET shop has one: a solution that works, ships, and quietly outlived everyone who ever understood it. A story about institutional memory and the one participant that never forgot.
- [Are we still talking loops, or did we shift to graphs yet?](https://graphslice.com/blog/loops-or-graphs.md): The godfather of the agentic scene dropped a six-word tweet about loops and graphs, and 2.5 million people looked up. He didn't mean us. Probably. Here's what a graph-shaped question could mean, and why the arrow points our way.
- [Compu-Global-Hyper-Mega-Net (or, how GraphSlice got its name)](https://graphslice.com/blog/Compu-Global-Hyper-Mega-Net.md): Naming a company is the worst part of starting one. Ask Homer Simpson, who got as far as Interslice before losing his nerve and going with Compu-Global-Hyper-Mega-Net...
- [We like Goose](https://graphslice.com/blog/we-like-goose.md): Goose is Block's open-source AI agent. It's a CLI, plus a desktop app that's really just a GUI over the same config, plus a genuinely useful set of MCP servers in the box. Here's why it's the harness we keep reaching for.
- [Why your AI assistant should query your architecture, not your files](https://graphslice.com/blog/why-ai-assistants-should-query-architecture.md): File dumps and embeddings break down on large C# codebases. A semantic code graph gives an LLM the exact dependency paths a question needs — nothing more.
- [What is a context slice?](https://graphslice.com/blog/what-is-a-context-slice.md): A context slice is the minimal subgraph of your codebase that answers one question. Here's how GraphSlice extracts one, and why the boundaries matter.
- [Blog index](https://graphslice.com/blog/): all posts (HTML)
- [RSS feed](https://graphslice.com/blog/feed.xml)

## API

## Community

## Changelog

## Independent Resources