CtrlK
CommunityDocumentationLog inGet started
Tessl Logo

tessl/maven-com-embabel-agent--embabel-agent-mcpserver

Discover and Export available Agent(s) as MCP Servers

Overview
Eval results
Files

imports.mddocs/advanced/

Complete Import Reference

Comprehensive organized import reference for embabel-agent-mcpserver, categorized by use case and functionality.

Table of Contents

  • Quick Reference
  • Tool Export
  • Publishers
  • Server Management
  • Registries
  • Factories
  • Domain Types
  • Configuration
  • Extensions
  • Spring AI Integration
  • MCP Protocol
  • Embabel Framework
  • Spring Framework
  • Reactive Programming
  • JSON Processing

Quick Reference

Essential Imports for Common Tasks

Basic Tool Publisher: { .api }

// Minimal imports for a simple tool publisher
import com.embabel.agent.mcpserver.McpExportToolCallbackPublisher
import org.springframework.ai.tool.ToolCallback
import org.springframework.stereotype.Service

Tool Export from ToolObject: { .api }

// Export tools from Embabel ToolObject
import com.embabel.agent.mcpserver.McpToolExport
import com.embabel.agent.api.common.ToolObject

Resource Publisher (Sync): { .api }

// Synchronous resource publisher
import com.embabel.agent.mcpserver.sync.McpResourcePublisher
import com.embabel.agent.mcpserver.sync.SyncResourceSpecificationFactory
import io.modelcontextprotocol.server.McpServerFeatures
import org.springframework.stereotype.Service

Resource Publisher (Async): { .api }

// Asynchronous resource publisher
import com.embabel.agent.mcpserver.async.McpAsyncResourcePublisher
import io.modelcontextprotocol.server.McpServerFeatures.AsyncResourceSpecification
import io.modelcontextprotocol.spec.McpSchema
import org.springframework.stereotype.Service
import reactor.core.publisher.Mono

Tool Export

Core Tool Export

// Main tool export interface
import com.embabel.agent.mcpserver.McpToolExport

// Factory methods (companion object)
// McpToolExport.fromToolObject(toolObject)
// McpToolExport.fromToolObjects(toolObjects, namingStrategy)
// McpToolExport.fromLlmReference(llmReference, namingStrategy)
// McpToolExport.fromLlmReferences(llmReferences, namingStrategy)

Naming Strategies

// String transformation interface
import com.embabel.agent.mcpserver.StringTransformer

// Usage:
// StringTransformer.IDENTITY  // No transformation
// StringTransformer { "prefix_$it" }  // Lambda

Tool Objects

// Embabel tool container
import com.embabel.agent.api.common.ToolObject

// Parameters:
// - objects: List<Any>
// - namingStrategy: StringTransformer?
// - filter: ((String) -> Boolean)?

LLM References

// Embabel agent reference
import com.embabel.agent.api.common.LlmReference

// Represents an Embabel agent with goals

Publishers

Tool Publishers

// Mode-agnostic tool publisher (works in both sync and async)
import com.embabel.agent.mcpserver.McpExportToolCallbackPublisher

// Interface methods:
// - val toolCallbacks: List<ToolCallback>
// - fun infoString(verbose: Boolean?, indent: Int): String

Resource Publishers (Sync Mode)

// Synchronous resource publisher
import com.embabel.agent.mcpserver.sync.McpResourcePublisher

// Interface methods:
// - fun resources(): List<McpServerFeatures.SyncResourceSpecification>
// - fun infoString(verbose: Boolean?, indent: Int): String

Resource Publishers (Async Mode)

// Asynchronous resource publisher
import com.embabel.agent.mcpserver.async.McpAsyncResourcePublisher

// Interface methods:
// - fun resources(): List<McpServerFeatures.AsyncResourceSpecification>
// - fun infoString(verbose: Boolean?, indent: Int): String

Prompt Publishers (Sync Mode)

// Synchronous prompt publisher
import com.embabel.agent.mcpserver.sync.McpPromptPublisher

// Interface methods:
// - fun prompts(): List<McpServerFeatures.SyncPromptSpecification>
// - fun infoString(verbose: Boolean?, indent: Int): String

Prompt Publishers (Async Mode)

// Asynchronous prompt publisher
import com.embabel.agent.mcpserver.async.McpAsyncPromptPublisher

// Interface methods:
// - fun prompts(): List<McpServerFeatures.AsyncPromptSpecification>
// - fun infoString(verbose: Boolean?, indent: Int): String

Server Management

Server Strategy

// Core server strategy interface
import com.embabel.agent.mcpserver.McpServerStrategy

// Interface methods:
// - fun addToolCallback(toolCallback: ToolCallback): Mono<Void>
// - fun removeToolCallback(toolName: String): Mono<Void>
// - fun getServerInfo(): Mono<ServerInfo>
// - fun getExecutionMode(): McpExecutionMode
// - fun checkHealth(): Mono<ServerHealthStatus>

Strategy Implementations

// Synchronous server strategy
import com.embabel.agent.mcpserver.sync.SyncServerStrategy

// Asynchronous server strategy
import com.embabel.agent.mcpserver.async.AsyncServerStrategy

// Note: Typically injected as McpServerStrategy interface

Registries

Tool Registry

// Core tool registry interface
import com.embabel.agent.mcpserver.ToolRegistry

// Interface methods:
// - fun register(toolCallback: ToolCallback): Mono<Void>
// - fun unregister(toolName: String): Mono<Void>
// - fun findToolCallback(toolName: String): Mono<ToolCallback>
// - fun listToolCallbacks(): Mono<List<ToolCallback>>
// - fun containsTool(toolName: String): Mono<Boolean>

Registry Implementations

// Default in-memory registry (internal)
// Custom implementations should implement ToolRegistry interface

Factories

Resource Factories (Sync Mode)

// Synchronous resource specification factory
import com.embabel.agent.mcpserver.sync.SyncResourceSpecificationFactory

// Factory methods:
// SyncResourceSpecificationFactory.staticSyncResourceSpecification(
//     uri: String,
//     name: String,
//     description: String,
//     content: String,
//     mimeType: String
// )
//
// SyncResourceSpecificationFactory.syncResourceSpecification(
//     uri: String,
//     name: String,
//     description: String,
//     resourceLoader: (McpSyncServerExchange) -> String,
//     mimeType: String
// )

Prompt Factories (Sync Mode)

// Synchronous prompt factory
import com.embabel.agent.mcpserver.sync.McpPromptFactory

// Usage:
// val factory = McpPromptFactory()
// factory.syncPromptSpecificationForType(goal, inputType)

Prompt Factories (Async Mode)

// Asynchronous prompt factory
import com.embabel.agent.mcpserver.async.McpAsyncPromptFactory

// Usage:
// val factory = McpAsyncPromptFactory()
// factory.asyncPromptSpecificationForType(goal, inputType)

Prompt Goal Types

// Goal definition interfaces
import com.embabel.common.core.types.Named
import com.embabel.common.core.types.Described

// Usage:
// val goal = object : Named, Described {
//     override val name = "goalName"
//     override val description = "Goal description"
// }

Domain Types

Server Information

// Server metadata
import com.embabel.agent.mcpserver.domain.ServerInfo

// Properties:
// - name: String
// - version: String
// - executionMode: McpExecutionMode
// - capabilities: List<McpCapability>

Execution Mode

// Execution mode enumeration
import com.embabel.agent.mcpserver.domain.McpExecutionMode

// Values:
// - McpExecutionMode.SYNC
// - McpExecutionMode.ASYNC

Health Status

// Server health status
import com.embabel.agent.mcpserver.domain.ServerHealthStatus

// Properties:
// - isHealthy: Boolean
// - message: String
// - details: Map<String, Any>

Capabilities

// Server capabilities
import com.embabel.agent.mcpserver.domain.McpCapability

// Values:
// - McpCapability.TOOLS
// - McpCapability.RESOURCES
// - McpCapability.PROMPTS

Configuration

Configuration Classes

// Base configuration class
import com.embabel.agent.mcpserver.config.AbstractMcpServerConfiguration

// Sync mode configuration
import com.embabel.agent.mcpserver.sync.config.McpSyncServerConfiguration

// Async mode configuration
import com.embabel.agent.mcpserver.async.config.McpAsyncServerConfiguration

// Note: These are auto-configured, rarely need direct import

Configuration Properties

// Spring Boot configuration properties
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.context.annotation.Configuration

// Example:
// @Configuration
// @ConfigurationProperties(prefix = "mcp.server")
// data class McpServerConfig(...)

Conditional Configuration

// Conditional bean registration
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass

// Profile-based configuration
import org.springframework.context.annotation.Profile

// Example:
// @ConditionalOnProperty(value = ["spring.ai.mcp.server.type"], havingValue = "SYNC")
// @Profile("production")

Extensions

Extension Functions

// Tool callback extensions
import com.embabel.agent.mcpserver.extensions.toolNames
import com.embabel.agent.mcpserver.extensions.filterByPrefix
import com.embabel.agent.mcpserver.extensions.groupByPrefix
import com.embabel.agent.mcpserver.extensions.hasToolNamed

// String extensions
import com.embabel.agent.mcpserver.extensions.toToolName
import com.embabel.agent.mcpserver.extensions.isPrefixOf

// Publisher extensions
import com.embabel.agent.mcpserver.extensions.toolCount
import com.embabel.agent.mcpserver.extensions.resourceCount

// Reactive extensions
import com.embabel.agent.mcpserver.extensions.extractNames
import com.embabel.agent.mcpserver.extensions.toNamesList

// Validation extensions
import com.embabel.agent.mcpserver.extensions.isValid
import com.embabel.agent.mcpserver.extensions.hasSchema

// Usage:
// val names = toolCallbacks.toolNames()
// val apiTools = toolCallbacks.filterByPrefix("api_")

Spring AI Integration

Tool Callback Interface

// Spring AI tool callback interface
import org.springframework.ai.tool.ToolCallback

// Interface methods:
// - fun getName(): String
// - fun getDescription(): String
// - fun call(functionArguments: String): String
// - fun getInputTypeSchema(): String?

Tool Execution

// Tool execution context (if available)
import org.springframework.ai.tool.ToolContext
import org.springframework.ai.tool.ToolExecutor

// Note: These may vary based on Spring AI version

MCP Protocol

Server Features

// MCP server features
import io.modelcontextprotocol.server.McpServerFeatures

// Types:
// - McpServerFeatures.SyncResourceSpecification
// - McpServerFeatures.AsyncResourceSpecification
// - McpServerFeatures.SyncPromptSpecification
// - McpServerFeatures.AsyncPromptSpecification

MCP Schema

// MCP protocol schema types
import io.modelcontextprotocol.spec.McpSchema

// Types:
// - McpSchema.Resource
// - McpSchema.ReadResourceResult
// - McpSchema.TextResourceContents
// - McpSchema.BlobResourceContents
// - McpSchema.Prompt
// - McpSchema.PromptMessage
// - McpSchema.GetPromptResult

Server Exchange

// Sync server exchange
import io.modelcontextprotocol.server.McpSyncServerExchange

// Async server exchange
import io.modelcontextprotocol.server.McpAsyncServerExchange

// Used in resource loaders

Server Implementations

// Sync server
import io.modelcontextprotocol.server.McpSyncServer

// Async server
import io.modelcontextprotocol.server.McpAsyncServer

// Note: Managed by library, rarely need direct import

Embabel Framework

Agent Annotations

// Agent class annotation
import com.embabel.agent.api.common.Agent

// Goal method annotation
import com.embabel.agent.api.common.Goal

// Example:
// @Agent
// class MyAgent {
//     @Goal(name = "doSomething", description = "Does something")
//     fun doSomething(input: Input): Output { ... }
// }

Agent Types

// Agent reference
import com.embabel.agent.api.common.LlmReference

// Tool object container
import com.embabel.agent.api.common.ToolObject

// Goal definition
import com.embabel.agent.api.common.GoalDefinition

// Agent autonomy levels
import com.embabel.agent.api.common.Autonomy

Named and Described

// Core type interfaces
import com.embabel.common.core.types.Named
import com.embabel.common.core.types.Described

// Used for creating goal objects:
// val goal = object : Named, Described {
//     override val name = "goalName"
//     override val description = "Description"
// }

Spring Framework

Core Annotations

// Component scanning
import org.springframework.stereotype.Service
import org.springframework.stereotype.Component
import org.springframework.stereotype.Repository
import org.springframework.stereotype.Controller

// Bean configuration
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Primary

// Dependency injection
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Value
import org.springframework.beans.factory.annotation.Qualifier

// Component scanning
import org.springframework.context.annotation.ComponentScan

Lifecycle Annotations

// Bean lifecycle
import javax.annotation.PostConstruct
import javax.annotation.PreDestroy

// Example:
// @PostConstruct
// fun init() { ... }
//
// @PreDestroy
// fun cleanup() { ... }

Scheduling

// Scheduled tasks
import org.springframework.scheduling.annotation.Scheduled
import org.springframework.scheduling.annotation.EnableScheduling

// Example:
// @Scheduled(fixedRate = 60000)
// fun periodicTask() { ... }

Environment

// Environment access
import org.springframework.core.env.Environment

// Usage:
// @Autowired
// private lateinit var environment: Environment
//
// val value = environment.getProperty("key", "default")

Reactive Programming

Reactor Core

// Reactive types
import reactor.core.publisher.Mono
import reactor.core.publisher.Flux

// Basic operators
import reactor.core.publisher.Mono.*  // just, empty, error, defer
import reactor.core.publisher.Flux.*  // fromIterable, range, interval

// Schedulers
import reactor.core.scheduler.Schedulers

// Schedulers:
// - Schedulers.immediate()
// - Schedulers.single()
// - Schedulers.parallel()
// - Schedulers.boundedElastic()

Operators

// Transformation
// map, flatMap, flatMapMany, transform

// Filtering
// filter, take, skip, distinct

// Combination
// zip, merge, concat

// Error handling
// onErrorReturn, onErrorResume, onErrorMap, retry, retryWhen

// Side effects
// doOnNext, doOnError, doOnSuccess, doOnSubscribe, doFinally

// Timing
// timeout, delay, delayElements

// Backpressure
// onBackpressureBuffer, onBackpressureDrop, onBackpressureLatest

Time and Duration

// Duration class
import java.time.Duration

// Usage:
// Duration.ofSeconds(30)
// Duration.ofMillis(100)
// Duration.ofMinutes(5)

JSON Processing

Jackson Core

// Object mapper
import com.fasterxml.jackson.databind.ObjectMapper

// Serialization features
import com.fasterxml.jackson.databind.SerializationFeature

// Deserialization features
import com.fasterxml.jackson.databind.DeserializationFeature

// Example:
// val objectMapper = ObjectMapper()
// objectMapper.disable(SerializationFeature.INDENT_OUTPUT)

Jackson Annotations

// Property description
import com.fasterxml.jackson.annotation.JsonPropertyDescription

// Property naming
import com.fasterxml.jackson.annotation.JsonProperty

// Ignore properties
import com.fasterxml.jackson.annotation.JsonIgnore
import com.fasterxml.jackson.annotation.JsonIgnoreProperties

// Type information
import com.fasterxml.jackson.annotation.JsonTypeInfo
import com.fasterxml.jackson.annotation.JsonSubTypes

// Example:
// data class Input(
//     @JsonPropertyDescription("Field description")
//     @JsonProperty("field_name")
//     val fieldName: String
// )

JSON Schema

// JSON schema generation (if using separate library)
import com.fasterxml.jackson.module.jsonSchema.JsonSchema
import com.fasterxml.jackson.module.jsonSchema.JsonSchemaGenerator

// Usage varies by implementation

Complete Example: All Common Imports

Comprehensive Tool Publisher with All Features: { .api }

package com.example.mcp

// Core MCP Server
import com.embabel.agent.mcpserver.McpToolExport
import com.embabel.agent.mcpserver.McpExportToolCallbackPublisher
import com.embabel.agent.mcpserver.McpServerStrategy
import com.embabel.agent.mcpserver.ToolRegistry
import com.embabel.agent.mcpserver.StringTransformer

// Sync Mode
import com.embabel.agent.mcpserver.sync.McpResourcePublisher
import com.embabel.agent.mcpserver.sync.McpPromptPublisher
import com.embabel.agent.mcpserver.sync.SyncResourceSpecificationFactory
import com.embabel.agent.mcpserver.sync.McpPromptFactory

// Async Mode (if needed)
import com.embabel.agent.mcpserver.async.McpAsyncResourcePublisher
import com.embabel.agent.mcpserver.async.McpAsyncPromptPublisher
import com.embabel.agent.mcpserver.async.McpAsyncPromptFactory

// Domain Types
import com.embabel.agent.mcpserver.domain.McpExecutionMode
import com.embabel.agent.mcpserver.domain.ServerInfo
import com.embabel.agent.mcpserver.domain.ServerHealthStatus
import com.embabel.agent.mcpserver.domain.McpCapability

// Extensions
import com.embabel.agent.mcpserver.extensions.toolNames
import com.embabel.agent.mcpserver.extensions.filterByPrefix
import com.embabel.agent.mcpserver.extensions.isValid

// Spring AI
import org.springframework.ai.tool.ToolCallback

// Embabel Framework
import com.embabel.agent.api.common.ToolObject
import com.embabel.agent.api.common.LlmReference
import com.embabel.agent.api.common.Agent
import com.embabel.agent.api.common.Goal
import com.embabel.common.core.types.Named
import com.embabel.common.core.types.Described

// MCP Protocol
import io.modelcontextprotocol.server.McpServerFeatures
import io.modelcontextprotocol.server.McpSyncServerExchange
import io.modelcontextprotocol.spec.McpSchema

// Spring Framework
import org.springframework.stereotype.Service
import org.springframework.stereotype.Component
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
import org.springframework.context.annotation.Profile
import javax.annotation.PostConstruct
import javax.annotation.PreDestroy

// Reactive Programming
import reactor.core.publisher.Mono
import reactor.core.publisher.Flux
import reactor.core.scheduler.Schedulers
import java.time.Duration

// JSON Processing
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.annotation.JsonPropertyDescription
import com.fasterxml.jackson.annotation.JsonProperty

// Logging
import org.slf4j.Logger
import org.slf4j.LoggerFactory

@Service
class ComprehensivePublisher(
    @Autowired private val serverStrategy: McpServerStrategy,
    @Autowired private val toolRegistry: ToolRegistry,
    @Value("\${api.version}") private val apiVersion: String
) : McpExportToolCallbackPublisher, McpResourcePublisher {

    override val toolCallbacks: List<ToolCallback>
        get() {
            val toolObject = ToolObject(
                objects = listOf(/* tools */),
                namingStrategy = StringTransformer { "v${apiVersion}_$it" }
            )
            return McpToolExport.fromToolObject(toolObject).toolCallbacks
        }

    override fun resources(): List<McpServerFeatures.SyncResourceSpecification> {
        return listOf(
            SyncResourceSpecificationFactory.staticSyncResourceSpecification(
                uri = "app://docs/api",
                name = "APIDocumentation",
                description = "API documentation",
                content = "# API Documentation",
                mimeType = "text/markdown"
            )
        )
    }

    override fun infoString(verbose: Boolean?, indent: Int): String {
        return "ComprehensivePublisher: ${toolCallbacks.size} tools, ${resources().size} resources"
    }

    companion object {
        private val logger = LoggerFactory.getLogger(ComprehensivePublisher::class.java)
    }
}

Import Organization Best Practices

Recommended Order

  1. MCP Server Core - Main library interfaces and implementations
  2. Mode-Specific - Sync or async specific imports
  3. Domain Types - Domain models and enums
  4. Extensions - Extension functions (if used)
  5. Spring AI - Spring AI tool interfaces
  6. Embabel Framework - Embabel agent types
  7. MCP Protocol - Protocol specifications
  8. Spring Framework - Spring annotations and utilities
  9. Reactive - Reactor types
  10. JSON - Jackson types
  11. Standard Library - Java/Kotlin standard library
  12. Logging - Logging frameworks

IntelliJ IDEA Import Settings

Code Style > Kotlin > Imports

Import Layout:
- com.embabel.agent.mcpserver.*
- io.modelcontextprotocol.*
- org.springframework.*
- reactor.core.*
- com.fasterxml.jackson.*
- java.*
- javax.*
- kotlin.*
- <blank line>
- all other imports

Related Documentation

  • Architecture - Architecture overview
  • Embabel Integration - Framework integration
  • Custom Implementations - Extensions
  • Tool Export API - Tool export details
  • Publishers API - Publisher interfaces
  • Server Strategy API - Strategy interface
  • Getting Started Guide - Initial setup
tessl i tessl/maven-com-embabel-agent--embabel-agent-mcpserver@0.3.1

docs

advanced

architecture.md

custom-implementations.md

embabel-integration.md

error-handling.md

imports.md

performance.md

index.md

tile.json