{
  "mcpServers": {
    "quantum": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

# Streamable HTTP (recommended for remote servers)
quarkus.langchain4j.mcp.helix.transport-type=streamable-http
quarkus.langchain4j.mcp.helix.url=http://helix-mcp.example.com/mcp

# STDIO (for local subprocess servers, e.g. npm-based MCP servers)
quarkus.langchain4j.mcp.brain.transport-type=stdio
quarkus.langchain4j.mcp.brain.command=npx,-y,@brain/mcp-server

# Optional: pass environment variables to the STDIO subprocess
quarkus.langchain4j.mcp.brain.environment.API_KEY=${EXTERNAL_API_KEY}

import io.quarkiverse.langchain4j.mcp.runtime.McpToolBox;
import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.UserMessage;
import io.quarkiverse.langchain4j.RegisterAiService;

@RegisterAiService
public interface MyAiService {

    @SystemMessage("You are a helpful assistant.")
    @McpToolBox("helix")
    String chat(@UserMessage String userMessage);
}

@McpToolBox({"helix", "brain"})
String chat(@UserMessage String userMessage);

@McpToolBox
String chat(@UserMessage String userMessage);

import dev.langchain4j.mcp.client.McpClient;
import io.quarkiverse.langchain4j.mcp.runtime.McpClientName;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;

@ApplicationScoped
public class McpClientService {

    @Inject
    @McpClientName("helix")
    McpClient helixClient;

    public void useClient() {
        // List tools exposed by the MCP server
        var tools = helixClient.listTools();

        // Execute a tool by name with JSON arguments
        var args = com.fasterxml.jackson.databind.node.JsonNodeFactory.instance.objectNode().put("key", "value");
        var request = dev.langchain4j.mcp.client.protocol.McpCallToolRequest.builder()
            .name("some_tool_name")
            .arguments(args)
            .build();
        var result = helixClient.executeTool(request);

        // List and read resources (if the server exposes resources)
        var resources = helixClient.listResources();
        var content = helixClient.readResource("some://resource-uri");
    }
}

quarkus.langchain4j.mcp.expose-resources-as-tools=true

{
  "tool": "query_find",
  "arguments": {
    "rootType": "Location",
    "query": "status:ACTIVE && city:Atlanta",
    "page": { "limit": 10, "skip": 0 }
  }
}

curl -sS -X POST \
  -H 'Content-Type: application/json' \
  localhost:8080/api/agent/execute \
  -d '{
    "tool": "query_find",
    "arguments": {
      "rootType": "Location",
      "query": "status:ACTIVE && city:Atlanta"
    }
  }'

import com.e2eq.framework.api.agent.RunAsPrincipalResolver;
import com.e2eq.framework.model.securityrules.PrincipalContext;
import jakarta.enterprise.context.ApplicationScoped;
import java.util.Optional;

@ApplicationScoped
public class MyRunAsPrincipalResolver implements RunAsPrincipalResolver {

    @Override
    public Optional<PrincipalContext> resolvePrincipalContext(String realm, String userId) {
        // Look up user and build PrincipalContext
        // Return Optional.empty() to fall back to caller's context
    }
}

curl -sS -X POST \
  -H 'Content-Type: application/json' \
  'localhost:8080/api/agent/config?realm=acme-corp' \
  -d '{
    "refName": "supply-chain-assistant",
    "name": "Supply Chain Assistant",
    "llmConfigRef": "claude-sonnet",
    "context": [
      { "order": 1, "role": "system", "content": "You are a supply-chain analyst. Help users query orders, track shipments, and monitor inventory." }
    ],
    "enabledTools": ["query_rootTypes", "query_plan", "query_find", "query_count"]
  }'

{
  "mcpServers": {
    "quantum": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

{
  "mcpServers": {
    "quantum-mcp": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

{
  "mcpServers": {
    "quantum-mcp": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

> Use query_rootTypes to list available entity types

Claude calls query_rootTypes and returns:
  Location, Order, CodeList, UserProfile, ...

> Find all active locations in the West region

Claude calls query_find with:
  rootType: "Location"
  query: "status:ACTIVE && region:West"
  limit: 10

Returns matching Location entities.

{
  "mcpServers": {
    "quantum": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

<dependency>
    <groupId>com.end2endlogic</groupId>
    <artifactId>quantum-mcp-server</artifactId>
    <version>${quantum.version}</version>
</dependency>

# --- Authentication ---
auth.provider=custom
quarkus.smallrye-jwt.enabled=true
mp.jwt.verify.publickey.location=publicKey.pem
mp.jwt.verify.issuer=https://myapp.example.com/issuer
mp.jwt.verify.audiences=my-api-client
auth.jwt.secret=${JWT_SECRET:dev-secret-change-in-prod}
auth.jwt.expiration=60
auth.jwt.refresh-expiration=120

# --- Per-tenant agent configuration ---
# The "default" realm: agent runs as a service user, limited to read-only tools
quantum.agent.tenant.default.runAsUserId=agent-svc@mycompany.com
quantum.agent.tenant.default.enabledTools=query_rootTypes,query_plan,query_find,query_count
quantum.agent.tenant.default.maxFindLimit=200

# The "acme-corp" realm: full CRUDL access
quantum.agent.tenant.acme-corp.runAsUserId=bot@acme-corp.com
quantum.agent.tenant.acme-corp.enabledTools=query_rootTypes,query_plan,query_find,query_count,query_save,query_delete

mvn quarkus:dev

{
  "mcpServers": {
    "supply-chain": {
      "url": "http://localhost:8080/mcp"
    }
  }
}

{
  "mcpServers": {
    "supply-chain": {
      "url": "http://localhost:8080/mcp"
    }
  }
}