Remove hard coded strings. Migrate to use IConfiguration

core/Azure.Mcp.Core/src/Areas/Server/Commands/Discovery/ConsolidatedToolDiscoveryStrategy.cs

@@ -7,6 +7,7 @@
 using Azure.Mcp.Core.Areas.Server.Models;
 using Azure.Mcp.Core.Areas.Server.Options;
 using Azure.Mcp.Core.Commands;
+using Azure.Mcp.Core.Configuration;
 using Azure.Mcp.Core.Services.Telemetry;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
@@ -21,11 +22,21 @@ namespace Azure.Mcp.Core.Areas.Server.Commands.Discovery;
 /// <param name="commandFactory">The command factory used to access available command groups.</param>
 /// <param name="options">Options for configuring the service behavior.</param>
 /// <param name="logger">Logger instance for this discovery strategy.</param>
-public sealed class ConsolidatedToolDiscoveryStrategy(CommandFactory commandFactory, IServiceProvider serviceProvider, IOptions<ServiceStartOptions> options, ILogger<ConsolidatedToolDiscoveryStrategy> logger) : BaseDiscoveryStrategy(logger)
+public sealed class ConsolidatedToolDiscoveryStrategy(
+    CommandFactory commandFactory,
+    IServiceProvider serviceProvider,
+    ITelemetryService telemetryService,
+    IOptions<ServiceStartOptions> options,
+    IOptions<AzureMcpServerConfiguration> serverConfigurationOptions,
+    ILogger<CommandFactory> commandFactoryLogger,
+    ILogger<ConsolidatedToolDiscoveryStrategy> logger) : BaseDiscoveryStrategy(logger)
 {
     private readonly CommandFactory _commandFactory = commandFactory;
     private readonly IServiceProvider _serviceProvider = serviceProvider;
+    private readonly ITelemetryService _telemetryService = telemetryService;
     private readonly IOptions<ServiceStartOptions> _options = options;
+    private readonly IOptions<AzureMcpServerConfiguration> _serverConfigurationOptions = serverConfigurationOptions;
+    private readonly ILogger<CommandFactory> _commandFactoryLogger = commandFactoryLogger;
     private CommandFactory? _consolidatedCommandFactory;
 
     /// <summary>
@@ -146,14 +157,12 @@ public CommandFactory CreateConsolidatedCommandFactory()
 #endif
 
         // Create a new CommandFactory with all consolidated areas
-        var telemetryService = _serviceProvider.GetRequiredService<ITelemetryService>();
-        var factoryLogger = _serviceProvider.GetRequiredService<ILogger<CommandFactory>>();
-
         _consolidatedCommandFactory = new CommandFactory(
             _serviceProvider,
             consolidatedAreas,
-            telemetryService,
-            factoryLogger
+            _telemetryService,
+            _serverConfigurationOptions,
+            _commandFactoryLogger
         );
 
         return _consolidatedCommandFactory;

core/Azure.Mcp.Core/src/Areas/Server/Commands/ServiceCollectionExtensions.cs

@@ -8,7 +8,9 @@
 using Azure.Mcp.Core.Areas.Server.Commands.ToolLoading;
 using Azure.Mcp.Core.Areas.Server.Options;
 using Azure.Mcp.Core.Commands;
+using Azure.Mcp.Core.Configuration;
 using Azure.Mcp.Core.Helpers;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -25,8 +27,6 @@ namespace Azure.Mcp.Core.Areas.Server.Commands;
 /// </summary>
 public static class AzureMcpServiceCollectionExtensions
 {
-    private const string DefaultServerName = "Azure MCP Server";
-
     /// <summary>
     /// Adds the Azure MCP server services to the specified <see cref="IServiceCollection"/>.
     /// </summary>
@@ -42,26 +42,51 @@ public static IServiceCollection AddAzureMcpServer(this IServiceCollection servi
         services.AddSingleton(serviceStartOptions);
         services.AddSingleton(Options.Create(serviceStartOptions));
 
-        // Register default tool loader options from service start options
-        var defaultToolLoaderOptions = new ToolLoaderOptions
-        {
-            Namespace = serviceStartOptions.Namespace,
-            ReadOnly = serviceStartOptions.ReadOnly ?? false,
-            InsecureDisableElicitation = serviceStartOptions.InsecureDisableElicitation,
-            Tool = serviceStartOptions.Tool,
-        };
+        // Register MCP runtimes
+        services.AddSingleton<IMcpRuntime, McpRuntime>();
 
-        if (serviceStartOptions.Mode == ModeTypes.NamespaceProxy)
+        ConfigureToolLoadersAndDiscoveryStrategies(services, serviceStartOptions);
+
+        var mcpServerOptions = services.AddOptions<McpServerOptions>()
+            .Configure<IMcpRuntime, IOptions<AzureMcpServerConfiguration>>(
+                (mcpServerOptions, mcpRuntime, serverConfig) =>
+                {
+
+                    var entryAssembly = Assembly.GetEntryAssembly();
+
+                    mcpServerOptions.ProtocolVersion = "2024-11-05";
+                    mcpServerOptions.ServerInfo = new Implementation
+                    {
+                        Name = serverConfig.Value.Name,
+                        Version = serverConfig.Value.Version
+                    };
+
+                    mcpServerOptions.Handlers = new()
+                    {
+                        CallToolHandler = mcpRuntime.CallToolHandler,
+                        ListToolsHandler = mcpRuntime.ListToolsHandler,
+                    };
+
+                    // Add instructions for the server
+                    mcpServerOptions.ServerInstructions = GetServerInstructions();
+                });
+
+        var mcpServerBuilder = services.AddMcpServer();
+
+        if (serviceStartOptions.Transport == TransportTypes.Http)
         {
-            if (defaultToolLoaderOptions.Namespace == null || defaultToolLoaderOptions.Namespace.Length == 0)
-            {
-                defaultToolLoaderOptions = defaultToolLoaderOptions with { Namespace = ["extension"] };
-            }
+            mcpServerBuilder.WithHttpTransport();
+        }
+        else
+        {
+            mcpServerBuilder.WithStdioServerTransport();
         }
 
-        services.AddSingleton(defaultToolLoaderOptions);
-        services.AddSingleton(Options.Create(defaultToolLoaderOptions));
+        return services;
+    }
 
+    internal static void ConfigureToolLoadersAndDiscoveryStrategies(IServiceCollection services, ServiceStartOptions serviceStartOptions)
+    {
         // Register tool loader strategies
         services.AddSingleton<CommandFactoryToolLoader>();
         services.AddSingleton<RegistryToolLoader>();
@@ -77,8 +102,25 @@ public static IServiceCollection AddAzureMcpServer(this IServiceCollection servi
         services.AddSingleton<RegistryDiscoveryStrategy>();
         services.AddSingleton<ConsolidatedToolDiscoveryStrategy>();
 
-        // Register MCP runtimes
-        services.AddSingleton<IMcpRuntime, McpRuntime>();
+        // Register default tool loader options from service start options
+        var defaultToolLoaderOptions = new ToolLoaderOptions
+        {
+            Namespace = serviceStartOptions.Namespace,
+            ReadOnly = serviceStartOptions.ReadOnly ?? false,
+            InsecureDisableElicitation = serviceStartOptions.InsecureDisableElicitation,
+            Tool = serviceStartOptions.Tool,
+        };
+
+        if (serviceStartOptions.Mode == ModeTypes.NamespaceProxy)
+        {
+            if (defaultToolLoaderOptions.Namespace == null || defaultToolLoaderOptions.Namespace.Length == 0)
+            {
+                defaultToolLoaderOptions = defaultToolLoaderOptions with { Namespace = ["extension"] };
+            }
+        }
+
+        services.AddSingleton(defaultToolLoaderOptions);
+        services.AddSingleton(Options.Create(defaultToolLoaderOptions));
 
         // Register MCP discovery strategies based on proxy mode
         if (serviceStartOptions.Mode == ModeTypes.SingleToolProxy)
@@ -207,45 +249,74 @@ public static IServiceCollection AddAzureMcpServer(this IServiceCollection servi
                 return new CompositeToolLoader(toolLoaders, loggerFactory.CreateLogger<CompositeToolLoader>());
             });
         }
+    }
 
-        var mcpServerOptions = services
-            .AddOptions<McpServerOptions>()
-            .Configure<IMcpRuntime>((mcpServerOptions, mcpRuntime) =>
+    /// <summary>
+    /// Using <see cref="IConfiguration"/> configures <see cref="AzureMcpServerConfiguration"/>.
+    /// </summary>
+    /// <param name="services">Service Collection to add configuration logic to.</param>
+    public static void ConfigureMcpServerOptions(this IServiceCollection services)
+    {
+        services.AddOptions<AzureMcpServerConfiguration>()
+            .BindConfiguration(string.Empty)
+            .Configure<IConfiguration, IOptions<ServiceStartOptions>>((options, rootConfiguration, serviceStartOptions) =>
             {
-                var mcpServerOptionsBuilder = services.AddOptions<McpServerOptions>();
-                var entryAssembly = Assembly.GetEntryAssembly();
-                var assemblyName = entryAssembly?.GetName();
-                var serverName = entryAssembly?.GetCustomAttribute<AssemblyTitleAttribute>()?.Title ?? DefaultServerName;
+                var collectTelemetry = rootConfiguration.GetValue<bool?>("AZURE_MCP_COLLECT_TELEMETRY");
+                var isOtelExporterEnabled = rootConfiguration.GetValue<bool?>("AZURE_MCP_ENABLE_OTLP_EXPORTER");
+                var applicationInsightsString = rootConfiguration.GetValue<string?>("APPLICATIONINSIGHTS_CONNECTION_STRING");
 
-                mcpServerOptions.ProtocolVersion = "2024-11-05";
-                mcpServerOptions.ServerInfo = new Implementation
-                {
-                    Name = serverName,
-                    Version = assemblyName?.Version?.ToString() ?? "1.0.0-beta"
-                };
+                var transport = serviceStartOptions.Value.Transport;
+                var isTelemetryEnabledEnvironment = collectTelemetry.HasValue
+                    ? collectTelemetry.Value
+                    : true;
+                var isStdioTransport = string.IsNullOrEmpty(transport)
+                    || string.Equals(transport, TransportTypes.StdIo, StringComparison.OrdinalIgnoreCase);
 
-                mcpServerOptions.Handlers = new()
+                var entryAssembly = Assembly.GetEntryAssembly();
+                if (entryAssembly == null)
                 {
-                    CallToolHandler = mcpRuntime.CallToolHandler,
-                    ListToolsHandler = mcpRuntime.ListToolsHandler,
-                };
+                    throw new InvalidOperationException("Should be a managed assembly as entry assembly.");
+                }
+
+                options.Version = GetServerVersion(entryAssembly);
+                options.ApplicationInsightsConnectionString = applicationInsightsString;
 
-                // Add instructions for the server
-                mcpServerOptions.ServerInstructions = GetServerInstructions();
+                // if transport is not set (default to stdio) or is set to stdio, enable telemetry
+                // telemetry is disabled for HTTP transport
+                options.IsTelemetryEnabled = isTelemetryEnabledEnvironment && isStdioTransport;
+                options.IsOtelExporterEnabled = isOtelExporterEnabled.HasValue
+                    ? isOtelExporterEnabled.Value
+                    : false;
             });
 
-        var mcpServerBuilder = services.AddMcpServer();
+        services.AddSingleton<IValidateOptions<AzureMcpServerConfiguration>, AzureMcpServerConfigurationValidator>();
+    }
 
-        if (serviceStartOptions.Transport == TransportTypes.Http)
+    /// <summary>
+    /// Gets the version information for the server.  Uses logic from Azure SDK for .NET to generate the same version string.
+    /// https://github.com/Azure/azure-sdk-for-net/blob/main/sdk/core/System.ClientModel/src/Pipeline/UserAgentPolicy.cs#L91
+    /// For example, an informational version of "6.14.0-rc.116+54d611f7" will return "6.14.0-rc.116"
+    /// </summary>
+    /// <param name="entryAssembly">The caller assembly to extract name and version information from.</param>
+    /// <returns>A version string.</returns>
+    internal static string GetServerVersion(Assembly entryAssembly)
+    {
+        AssemblyInformationalVersionAttribute? versionAttribute = entryAssembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>();
+        if (versionAttribute == null)
         {
-            mcpServerBuilder.WithHttpTransport();
+            throw new InvalidOperationException(
+                $"{nameof(AssemblyInformationalVersionAttribute)} is required on client SDK assembly '{entryAssembly.FullName}'.");
         }
-        else
+
+        string version = versionAttribute.InformationalVersion;
+
+        int hashSeparator = version.IndexOf('+');
+        if (hashSeparator != -1)
         {
-            mcpServerBuilder.WithStdioServerTransport();
+            version = version.Substring(0, hashSeparator);
         }
 
-        return services;
+        return version;
     }
 
     /// <summary>

core/Azure.Mcp.Core/src/Areas/Server/Commands/ServiceStartCommand.cs

@@ -14,9 +14,11 @@
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Console;
 using Microsoft.Extensions.Options;
 using Microsoft.Identity.Web;
 using OpenTelemetry.Logs;
@@ -55,7 +57,7 @@ public sealed class ServiceStartCommand : BaseCommand<ServiceStartOptions>
     /// </summary>
     public override ToolMetadata Metadata => new() { Destructive = false, ReadOnly = true };
 
-    public static Action<IServiceCollection> ConfigureServices { get; set; } = _ => { };
+    public static Action<IHostApplicationBuilder> ConfigureServices { get; set; } = (_) => { };
 
     public static Func<IServiceProvider, Task> InitializeServicesAsync { get; set; } = _ => Task.CompletedTask;
 
@@ -332,41 +334,39 @@ private IHost CreateHost(ServiceStartOptions serverOptions)
     /// <returns>An IHost instance configured for STDIO transport.</returns>
     private IHost CreateStdioHost(ServiceStartOptions serverOptions)
     {
-        return Host.CreateDefaultBuilder()
-            .ConfigureLogging(logging =>
-            {
-                logging.ClearProviders();
-                logging.ConfigureOpenTelemetryLogger();
-                logging.AddEventSourceLogger();
+        var builder = Host.CreateApplicationBuilder();
 
-                if (serverOptions.Debug)
-                {
-                    // Configure console logger to emit Debug+ to stderr so tests can capture logs from StandardError
-                    logging.AddConsole(options =>
-                    {
-                        options.LogToStandardErrorThreshold = LogLevel.Debug;
-                        options.FormatterName = Microsoft.Extensions.Logging.Console.ConsoleFormatterNames.Simple;
-                    });
-                    logging.AddSimpleConsole(simple =>
-                    {
-                        simple.ColorBehavior = Microsoft.Extensions.Logging.Console.LoggerColorBehavior.Disabled;
-                        simple.IncludeScopes = false;
-                        simple.SingleLine = true;
-                        simple.TimestampFormat = "[HH:mm:ss] ";
-                    });
-                    logging.AddFilter("Microsoft.Extensions.Logging.Console.ConsoleLoggerProvider", LogLevel.Debug);
-                    logging.SetMinimumLevel(LogLevel.Debug);
-                }
-            })
-            .ConfigureServices(services =>
+        var logging = builder.Logging;
+
+        logging.ClearProviders();
+        logging.AddEventSourceLogger();
+
+        if (serverOptions.Debug)
+        {
+            // Configure console logger to emit Debug+ to stderr so tests can capture logs from StandardError
+            logging.AddConsole(options =>
+            {
+                options.LogToStandardErrorThreshold = LogLevel.Debug;
+                options.FormatterName = ConsoleFormatterNames.Simple;
+            });
+            logging.AddSimpleConsole(simple =>
             {
-                // Configure the outgoing authentication strategy.
-                services.AddSingleIdentityTokenCredentialProvider();
+                simple.ColorBehavior = LoggerColorBehavior.Disabled;
+                simple.IncludeScopes = false;
+                simple.SingleLine = true;
+                simple.TimestampFormat = "[HH:mm:ss] ";
+            });
+            logging.AddFilter("Microsoft.Extensions.Logging.Console.ConsoleLoggerProvider", LogLevel.Debug);
+            logging.SetMinimumLevel(LogLevel.Debug);
+        }
+
+        // Configure the outgoing authentication strategy.
+        builder.Services.AddSingleIdentityTokenCredentialProvider();
+
+        ConfigureServices(builder);
+        ConfigureMcpServer(builder.Services, serverOptions);
 
-                ConfigureServices(services);
-                ConfigureMcpServer(services, serverOptions);
-            })
-            .Build();
+        return builder.Build();
     }
 
     /// <summary>
@@ -380,7 +380,6 @@ private IHost CreateHttpHost(ServiceStartOptions serverOptions)
 
         // Configure logging
         builder.Logging.ClearProviders();
-        builder.Logging.ConfigureOpenTelemetryLogger();
         builder.Logging.AddEventSourceLogger();
         builder.Logging.AddConsole();
 
@@ -465,7 +464,7 @@ private IHost CreateHttpHost(ServiceStartOptions serverOptions)
         });
 
         // Configure services
-        ConfigureServices(services); // Our static callback hook
+        ConfigureServices(builder); // Our static callback hook
         ConfigureMcpServer(services, serverOptions);
 
         WebApplication app = builder.Build();
@@ -555,7 +554,6 @@ private IHost CreateIncomingAuthDisabledHttpHost(ServiceStartOptions serverOptio
 
         // Configure logging
         builder.Logging.ClearProviders();
-        builder.Logging.ConfigureOpenTelemetryLogger();
         builder.Logging.AddEventSourceLogger();
         builder.Logging.AddConsole();
 
@@ -579,7 +577,7 @@ private IHost CreateIncomingAuthDisabledHttpHost(ServiceStartOptions serverOptio
         });
 
         // Configure services
-        ConfigureServices(services); // Our static callback hook
+        ConfigureServices(builder); // Our static callback hook
         ConfigureMcpServer(services, serverOptions);
 
         // We still use the multi-user, HTTP context-aware caching strategy here

core/Azure.Mcp.Core/src/Azure.Mcp.Core.csproj

@@ -1,6 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <IsAotCompatible>true</IsAotCompatible>
+    <!-- Enable strongly typed binding for IConfiguration to support AOT and trimming. -->
+    <EnableConfigurationBindingGenerator>true</EnableConfigurationBindingGenerator>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>