MAGG

Instructions

Implementation Reference

• magg/server/manager.py:587-601 (handler)

  Handler method for the 'magg_kit_info' tool. Calls kit_manager.get_kit_details(name) and returns a formatted MaggResponse.

          self,
          name: Annotated[str, Field(description="Kit name to get information about")],
  ) -> MaggResponse:
      """Get detailed information about a specific kit."""
      try:
          info = self.kit_manager.get_kit_details(name)
  
          if info:
              return MaggResponse.success(info)
          else:
              return MaggResponse.error(f"Kit '{name}' not found")
  
      except Exception as e:
          return MaggResponse.error(f"Failed to get kit info: {str(e)}")

• magg/server/server.py:48-64 (registration)

  Registration of all Magg tools including 'magg_kit_info' via self.mcp.tool() in the loop after this list. self_prefix_ is 'magg_'.

  tools = [
      (self.add_server, f"{self_prefix_}add_server", None),
      (self.remove_server, f"{self_prefix_}remove_server", None),
      (self.list_servers, f"{self_prefix_}list_servers", None),
      (self.enable_server, f"{self_prefix_}enable_server", None),
      (self.disable_server, f"{self_prefix_}disable_server", None),
      (self.search_servers, f"{self_prefix_}search_servers", None),
      (self.smart_configure, f"{self_prefix_}smart_configure", None),
      (self.analyze_servers, f"{self_prefix_}analyze_servers", None),
      (self.status, f"{self_prefix_}status", None),
      (self.check, f"{self_prefix_}check", None),
      (self.reload_config_tool, f"{self_prefix_}reload_config", None),
      (self.load_kit, f"{self_prefix_}load_kit", None),
      (self.unload_kit, f"{self_prefix_}unload_kit", None),
      (self.list_kits, f"{self_prefix_}list_kits", None),
      (self.kit_info, f"{self_prefix_}kit_info", None),
  ]

• magg/kit.py:306-350 (helper)

  Core helper method implementing the logic to retrieve kit details, either from loaded kits or by discovering and loading from file.

  def get_kit_details(self, kit_name: str) -> dict[str, Any] | None:
      """Get detailed information about a specific kit.
  
      Returns:
          Kit information dict or None if not found
      """
      loaded_kits = self.kits
      if kit_name in loaded_kits:
          kit_config = loaded_kits[kit_name]
          return {
              'loaded': True,
              'name': kit_config.name,
              'description': kit_config.description,
              'author': kit_config.author,
              'version': kit_config.version,
              'keywords': kit_config.keywords,
              'links': kit_config.links,
              'servers': {
                  name: server.model_dump(mode="json", exclude_unset=True, exclude_none=True, exclude_defaults=True)
                  for name, server in kit_config.servers.items()
              }
          }
  
      available_kits = self.discover_kits()
      if kit_name in available_kits:
          kit_path = available_kits[kit_name]
          kit_config = self.load_kit(kit_path)
          if kit_config:
              return {
                  'loaded': False,
                  'path': str(kit_path),
                  'name': kit_config.name,
                  'description': kit_config.description,
                  'author': kit_config.author,
                  'version': kit_config.version,
                  'keywords': kit_config.keywords,
                  'links': kit_config.links,
                  'servers': {
                      name: server.model_dump(mode="json", exclude_unset=True, exclude_none=True, exclude_defaults=True)
                      for name, server in kit_config.servers.items()
                  }
              }
  
      return None

• magg/settings.py:23-35 (schema)

  Pydantic model used for kit metadata in configuration, part of the output structure.

  class KitInfo(BaseModel):
      """Information about a loaded kit."""
      model_config = {
          "extra": "allow",
          "validate_assignment": True,
      }
  
      name: str = Field(..., description="Kit name")
      description: str | None = Field(None, description="Kit description")
      path: str | None = Field(None, description="Path to kit file (if file-based)")
      source: str | None = Field(None, description="Source of the kit (file, inline, etc)")

• magg/kit.py:15-58 (helper)

  Pydantic model for parsing kit configuration files, used by get_kit_details to extract details.

  class KitConfig(BaseSettings):
      """Configuration for a kit - a bundle of related MCP servers."""
      model_config = SettingsConfigDict(
          extra="allow",
          validate_assignment=True,
      )
  
      name: str = Field(..., description="Unique kit name")
      description: str = Field("", description="What this kit provides")
      author: str | None = Field(None, description="Kit author/maintainer")
      version: str | None = Field(None, description="Kit version")
      keywords: list[str] = Field(default_factory=list, description="Keywords for discovery")
      links: dict[str, str] = Field(default_factory=dict, description="Related links (homepage, docs, etc)")
  
      servers: dict[str, ServerConfig] = Field(
          default_factory=dict,
          description="Servers included in this kit"
      )
  
      @field_validator('servers', mode='before')
      def validate_servers(cls, v: dict[str, Any]) -> dict[str, ServerConfig]:
          """Convert raw server data to ServerConfig objects."""
          if not isinstance(v, dict):
              return {}
  
          servers = {}
          for name, server_data in v.items():
              try:
                  if isinstance(server_data, ServerConfig):
                      servers[name] = server_data
                  else:
                      if isinstance(server_data, dict):
                          server_data = server_data.copy()
                          server_data.pop('kits', None)  # Remove any kits field, only allowed in config.json
  
                      server_data['name'] = name
                      servers[name] = ServerConfig(**server_data)
              except Exception as e:
                  logger.error("Error loading server %r in kit: %s", name, e)
                  continue
  
          return servers