DOCSEARCHbyAlgolia
Submit Docs

ChilliCream GraphQL Platform for .NET

website·Indexed 35 days ago

https://chillicream.com

A platform to build, federate, observe, and evolve GraphQL APIs on .NET. It includes Hot Chocolate, an open-source GraphQL server that turns C# classes into spec-compliant schemas, as well as Fusion, Strawberry Shake, Nitro, and Banana Cake Pop. Features include support for Relay, MCP (Model Context Protocol) for AI agents, OpenAPI adapters, and advanced type system configurations including mutations, subscriptions, and dynamic schemas.

Tokens
291.9K
Snippets
1.4K
Records
1.9K
Agent score
71%

What's inside ChilliCream

  1. Overview of Fusion Subscription Models

    Fusion supports two models for federating GraphQL subscriptions:

    1. Federated Event Streams: The recommended model for scale. Subscriptions are backed by a message broker (NATS, Kafka, Azure Event Hubs, Amazon SQS, or Redis). The gateway subscribes to a broker topic and resolves requested fields across subgraphs using stateless fetches. The gateway holds no per-subscription state.
    2. Subgraph subscriptions over SSE: The simplest model for when a single subgraph owns the event source. The subscription is implemented by a subgraph as a normal GraphQL subscription, and the gateway consumes the stream via Server-Sent Events (SSE).

  2. Overview of Hot Chocolate GraphQL Server for .NET

    Hot Chocolate is a production-ready GraphQL server for .NET designed to build type-safe APIs. It supports C# schema authoring, DataLoader for batching, real-time subscriptions, security, OpenTelemetry, and federation via Fusion. It is distributed under the MIT license and is free for commercial and private use.

  3. Overview of the Nitro Document View

    The Document View in Nitro is a dedicated workspace for interacting with GraphQL APIs. It allows developers to write and execute queries, mutations, and subscriptions, explore the API schema, and manage connection settings.

  4. Overview of Mocha PostgreSQL Transport

    The PostgreSQL transport allows using an existing PostgreSQL database as a message broker. It stores messages, topics, queues, and subscriptions as rows in database tables, utilizing SELECT ... FOR UPDATE SKIP LOCKED for delivery and LISTEN/NOTIFY for real-time signaling. It is ideal for users who want to avoid additional infrastructure, require ACID guarantees between domain writes and message dispatch (outbox pattern), or have message volumes within PostgreSQL's throughput (tens of thousands of messages per second).

  5. Overview of Semantic Introspection for GraphQL

    Semantic Introspection is a proposed extension to GraphQL introspection designed to optimize APIs for LLM agents. It addresses three core requirements for agent-API interaction:

    1. Discoverability: Allows LLMs to find available functionality without loading the entire schema.
    2. Scalability: Enables agents to work with thousands of tools/capabilities without exceeding the LLM's context window.
    3. Precision: Leverages GraphQL's 'no overfetching' nature to reduce context pollution and token costs compared to OpenAPI or MCP (Model Context Protocol).

    Unlike standard introspection, which requires the agent to process the full schema, Semantic Introspection allows the agent to query the server for the most relevant schema members based on a natural language request.

  6. Overview of Strawberry Shake GraphQL Client for .NET

    Strawberry Shake is an open-source, reactive GraphQL client for .NET. It generates strongly typed C# client code based on your GraphQL operations, allowing developers to interact with local and remote data. It is compatible with any spec-compliant GraphQL server, including Hot Chocolate, Apollo Server, and GraphQL Java.

  7. Overview of Fusion 16 Performance and Architecture

    Fusion 16 introduces a brand-new execution engine designed for high-throughput GraphQL gateway performance on .NET. It utilizes a memory model inspired by Rust-style arena allocation, where data is managed as bytes and results are referenced rather than copied. The gateway remains an ASP.NET Core application compatible with .NET 8, 9, and 10, allowing developers to retain control over authentication, configuration, resilience, and observability via Kestrel.

  8. Overview of Fusion Federated GraphQL Gateway

    Fusion is a GraphQL gateway that allows developers to split a single GraphQL API into multiple smaller upstream services (subgraphs) without changing the client-facing endpoint. It implements the GraphQL Composite Schemas specification, providing build-time validation to catch contract conflicts before deployment. The gateway orchestrates requests by routing them to the appropriate subgraphs and merging the results into a single response.

  9. Overview of Hot Chocolate Filtering Extensibility

    The Hot Chocolate filtering system is designed to work with any database supporting IQueryable, but it can be extended for technology-specific operations (e.g., SQL LIKE) or databases that do not support IQueryable. The system is split into two phases:

    1. Schema Building: Filter input types are created based on a convention.
    2. Execution: User-provided data is analyzed and translated into a database query via a provider.

    Filtering logic is divided into fields (context-specific paths) and operations (global logic, such as equality eq, that maintains the same meaning across different fields).

  10. Overview of Nitro Personal Access Tokens (PATs)

    Personal Access Tokens (PATs) are user-bound credentials used for personal automation, local scripts, and bootstrapping Nitro workspaces. A PAT inherits all permissions of the user account across every workspace and API they belong to.

    Key Considerations:

    • Security: Treat PATs like passwords; store them in secret managers and revoke them when no longer needed.
    • PAT vs API Key: Use PATs for broad, user-level permissions (e.g., creating workspaces). Use API keys for narrow, non-user-bound automation like CI/CD or deploy pipelines.
    • Authentication: All nitro pat commands require authentication via nitro login or by passing the --api-key flag.
    • Usage: To use a PAT for non-interactive CLI calls, pass it via the --api-key flag or the NITRO_API_KEY environment variable.

  11. Overview of Nitro MCP Feature Collections

    Nitro acts as a control plane for the Model Context Protocol (MCP), allowing developers to author GraphQL tools and prompts on disk, package them into versioned feature collections, and distribute them to a HotChocolate runtime. The MCP endpoint is served by the GraphQL server or Fusion gateway at /graphql/mcp by default. Nitro provides storage for immutable versions, multi-stage deployment (e.g., dev to production), telemetry (latency, error rates), and validation of GraphQL documents and prompt JSON before publishing.

  12. Overview of Mocha Transports

    A transport in Mocha is the infrastructure layer that connects the application to a message broker. It handles connection management, topology provisioning (exchanges, queues, bindings), and the low-level dispatching and receiving of messages. Because of the transport abstraction, handlers and pipelines remain identical regardless of the underlying broker, allowing developers to swap transport implementations without changing application code.