Function SetServerByOpenapi

mcp-server/server.go:163–276

(sid, name, version, content string)

}

func SetServerByOpenapi(sid, name, version, content string) error {
	mcpInfo, err := ConvertMCPFromOpenAPI3Data([]byte(content))
	if err != nil {
		return fmt.Errorf("convert mcp from openapi3 data error: %w", err)
	}
	tools := make([]ITool, 0, len(mcpInfo.Apis))
	for _, a := range mcpInfo.Apis {
		toolOptions := make([]mcp.ToolOption, 0, len(a.Params)+2)
		toolOptions = append(toolOptions, mcp.WithDescription(a.Description))
		params := make(map[string]*Param)
		for _, v := range a.Params {
			if v.In == "header" && v.Name == "Authorization" {
				continue
			}
			params[v.Name] = NewParam(Position(v.In), v.Required, v.Description)
			options := make([]mcp.PropertyOption, 0, 2)
			if v.Required {
				options = append(options, mcp.Required())
			}
			options = append(options, mcp.Description(v.Description))
			toolOptions = append(toolOptions, mcp.WithString(v.Name, options...))
		}
		if a.Body != nil {
			type Schema struct {
				Type       string                 `mapstructure:"type"`
				Properties map[string]interface{} `mapstructure:"properties"`
				Items      interface{}            `mapstructure:"items"`
				Required   interface{}            `mapstructure:"required"`
			}
			var tmp Schema
			err = mapstructure.Decode(a.Body, &tmp)
			if err != nil {
				return err
			}
			required := map[string]struct{}{}
			switch t := tmp.Required.(type) {
			case []interface{}:
				for _, v := range t {
					i, ok := v.(string)
					if !ok {
						continue
					}
					required[i] = struct{}{}
				}
			}
			for k, v := range tmp.Properties {
				description := ""
				typ := "string"
				isRequired := false
				if _, ok := required[k]; ok {
					isRequired = true
				}
				var props map[string]interface{}
				var items interface{}
				switch t := v.(type) {
				case map[string]interface{}:
					if m, ok := t["type"]; ok {
						n, ok := m.(string)