Ontology MCP

Overview Schema Related Servers Score Discussions

mcp_gemini_create_image

Generate images from text prompts using Gemini, returning both text and visuals. Features include SynthID watermarking, interactive editing, and mixed text-image outputs. Use explicit requests like "create image" for best results.

Instructions

Gemini 모델을 사용하여 텍스트 프롬프트에서 이미지를 생성합니다. 텍스트와 이미지를 함께 반환합니다. 주요 특징: 1) 생성된 모든 이미지에는 SynthID 워터마크 포함 2) 대화식 이미지 수정 가능 3) 텍스트와 이미지가 혼합된 출력 생성 가능. 최상의 성능을 위해 EN, es-MX, ja-JP, zh-CN, hi-IN 언어를 사용하세요. 이미지 생성이 항상 트리거되지 않을 수 있으므로 "이미지 생성", "이미지 제공" 등의 표현을 명시적으로 요청하세요.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`fileName`	No	저장할 이미지 파일 이름 (확장자 제외)
`model`	No	사용할 Gemini 모델 ID (예: gemini-2.0-flash-exp-image-generation)	gemini-2.0-flash-exp-image-generation
`prompt`	Yes	이미지 생성을 위한 텍스트 프롬프트. 이미지를 명시적으로 요청하려면 "이미지 생성", "이미지 제공" 등의 표현을 포함하세요.
`saveDir`	No	이미지를 저장할 디렉토리	./temp

Implementation Reference

src/tools/index.ts:19-1555 (registration)

The tools array exports all MCP tools including 'mcp_gemini_create_image' registration with full definition (name, description, inputSchema, handler).

export const tools = [
  {
    name: 'mcp_sparql_execute_query',
    description: 'SPARQL 쿼리를 실행하고 결과를 반환합니다',
    inputSchema: {
      type: 'object',
      properties: {
        query: {
          type: 'string',
          description: '실행할 SPARQL 쿼리'
        },
        repository: {
          type: 'string',
          description: '쿼리를 실행할 리포지토리 이름'
        },
        endpoint: {
          type: 'string',
          description: 'SPARQL 엔드포인트 URL'
        },
        format: {
          type: 'string',
          enum: ['json', 'xml', 'csv', 'tsv'],
          description: '결과 형식(json, xml, csv, tsv)'
        },
        explain: {
          type: 'boolean',
          description: '쿼리 실행 계획 반환 여부'
        }
      },
      required: ['query']
    },
    async handler(args: ExecuteQueryArgs): Promise<ToolResponse> {
      try {
        const result = await sparqlService.executeQuery(args.query, args.repository, args.format);
        
        // 결과를 서식화하여 반환
        return {
          content: [{
            type: 'text',
            text: typeof result === 'object' ? JSON.stringify(result, null, 2) : result.toString()
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `쿼리 실행 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_sparql_update',
    description: 'SPARQL 업데이트 쿼리를 실행하여 데이터를 수정합니다. INSERT DATA, DELETE DATA, INSERT-WHERE, DELETE-WHERE 등의 SPARQL 1.1 Update 문법을 지원합니다. 새로운 트리플 추가, 기존 트리플 삭제, 조건부 데이터 변경 등 다양한 그래프 수정 작업을 수행할 수 있습니다.',
    inputSchema: {
      type: 'object',
      properties: {
        query: {
          type: 'string',
          description: '실행할 SPARQL 업데이트 쿼리 (예: INSERT DATA { <subject> <predicate> <object> })'
        },
        repository: {
          type: 'string',
          description: '업데이트 쿼리를 실행할 리포지토리 이름'
        },
        endpoint: {
          type: 'string',
          description: 'SPARQL 엔드포인트 URL'
        }
      },
      required: ['query']
    },
    async handler(args: UpdateQueryArgs): Promise<ToolResponse> {
      try {
        if (args.endpoint) {
          const service = new SparqlService({
            endpoint: args.endpoint,
            defaultRepository: args.repository || ''
          });
          const result = await service.updateQuery(args.query, args.repository);
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(result, null, 2)
            }]
          };
        } else {
          const result = await sparqlService.updateQuery(args.query, args.repository);
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(result, null, 2)
            }]
          };
        }
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `업데이트 쿼리 실행 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_sparql_list_repositories',
    description: 'GraphDB 서버의 모든 리포지토리를 나열합니다',
    inputSchema: {
      type: 'object',
      properties: {
        endpoint: {
          type: 'string',
          description: 'SPARQL 엔드포인트 URL'
        }
      },
      required: []
    },
    async handler(args: ListRepositoriesArgs): Promise<ToolResponse> {
      try {
        if (args.endpoint) {
          const service = new SparqlService({ endpoint: args.endpoint });
          const repositories = await service.listRepositories();
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(repositories, null, 2)
            }]
          };
        } else {
          const repositories = await sparqlService.listRepositories();
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(repositories, null, 2)
            }]
          };
        }
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `리포지토리 목록 조회 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_sparql_list_graphs',
    description: '지정된 리포지토리의 모든 명명된 그래프를 나열합니다',
    inputSchema: {
      type: 'object',
      properties: {
        repository: {
          type: 'string',
          description: '그래프를 조회할 리포지토리 이름'
        },
        endpoint: {
          type: 'string',
          description: 'SPARQL 엔드포인트 URL'
        }
      },
      required: []
    },
    async handler(args: ListGraphsArgs): Promise<ToolResponse> {
      try {
        if (args.endpoint) {
          const service = new SparqlService({
            endpoint: args.endpoint,
            defaultRepository: args.repository || ''
          });
          const graphs = await service.listGraphs(args.repository);
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(graphs, null, 2)
            }]
          };
        } else {
          const graphs = await sparqlService.listGraphs(args.repository);
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(graphs, null, 2)
            }]
          };
        }
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `그래프 목록 조회 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_sparql_get_resource_info',
    description: '지정된 URI에 대한 모든 속성과 값을 조회합니다',
    inputSchema: {
      type: 'object',
      properties: {
        uri: {
          type: 'string',
          description: '조회할 리소스의 URI'
        },
        repository: {
          type: 'string',
          description: '조회할 리포지토리 이름'
        },
        endpoint: {
          type: 'string',
          description: 'SPARQL 엔드포인트 URL'
        }
      },
      required: ['uri']
    },
    async handler(args: GetResourceInfoArgs): Promise<ToolResponse> {
      try {
        if (args.endpoint) {
          const service = new SparqlService({
            endpoint: args.endpoint,
            defaultRepository: args.repository || ''
          });
          const resourceInfo = await service.getResourceInfo(args.uri, args.repository);
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(resourceInfo, null, 2)
            }]
          };
        } else {
          const resourceInfo = await sparqlService.getResourceInfo(args.uri, args.repository);
          return {
            content: [{
              type: 'text',
              text: JSON.stringify(resourceInfo, null, 2)
            }]
          };
        }
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `리소스 정보 조회 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_ollama_run',
    description: 'Ollama 모델을 실행하여 응답을 생성합니다',
    inputSchema: {
      type: 'object',
      properties: {
        name: {
          type: 'string',
          description: '실행할 모델 이름'
        },
        prompt: {
          type: 'string',
          description: '모델에 전송할 프롬프트'
        },
        timeout: {
          type: 'number',
          description: '타임아웃(밀리초 단위, 기본값: 60000)',
          minimum: 1000
        }
      },
      required: ['name', 'prompt']
    },
    async handler(args: any): Promise<ToolResponse> {
      const result = await ollamaService.runModel(args);
      return {
        content: [
          {
            type: 'text' as const,
            text: result
          }
        ]
      };
    }
  },
  {
    name: 'mcp_ollama_show',
    description: 'Ollama 모델의 정보를 표시합니다',
    inputSchema: {
      type: 'object',
      properties: {
        name: {
          type: 'string',
          description: '정보를 조회할 모델 이름'
        }
      },
      required: ['name']
    },
    async handler(args: any): Promise<ToolResponse> {
      const result = await ollamaService.showModel(args);
      return {
        content: [
          {
            type: 'text' as const,
            text: result
          }
        ]
      };
    }
  },
  {
    name: 'mcp_ollama_pull',
    description: 'Ollama 레지스트리에서 모델을 다운로드합니다',
    inputSchema: {
      type: 'object',
      properties: {
        name: {
          type: 'string',
          description: '다운로드할 모델 이름'
        }
      },
      required: ['name']
    },
    async handler(args: any): Promise<ToolResponse> {
      const result = await ollamaService.pullModel(args);
      return {
        content: [
          {
            type: 'text' as const,
            text: result
          }
        ]
      };
    }
  },
  {
    name: 'mcp_ollama_list',
    description: '사용 가능한 Ollama 모델 목록을 조회합니다',
    inputSchema: {
      type: 'object',
      properties: {}
    },
    async handler(args: any): Promise<ToolResponse> {
      const result = await ollamaService.listModels();
      return {
        content: [
          {
            type: 'text' as const,
            text: result
          }
        ]
      };
    }
  },
  {
    name: 'mcp_ollama_rm',
    description: 'Ollama 모델을 삭제합니다',
    inputSchema: {
      type: 'object',
      properties: {
        name: {
          type: 'string',
          description: '삭제할 모델 이름'
        }
      },
      required: ['name']
    },
    async handler(args: any): Promise<ToolResponse> {
      const result = await ollamaService.removeModel(args);
      return {
        content: [
          {
            type: 'text' as const,
            text: result
          }
        ]
      };
    }
  },
  {
    name: 'mcp_ollama_chat_completion',
    description: 'OpenAI 호환 채팅 완성 API를 사용하여 응답을 생성합니다',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 Ollama 모델 이름'
        },
        messages: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              role: {
                type: 'string',
                enum: ['system', 'user', 'assistant']
              },
              content: {
                type: 'string'
              }
            },
            required: ['role', 'content']
          },
          description: '대화 메시지 배열'
        },
        temperature: {
          type: 'number',
          description: '샘플링 온도(0-2)',
          minimum: 0,
          maximum: 2
        },
        timeout: {
          type: 'number',
          description: '타임아웃(밀리초 단위, 기본값: 60000)',
          minimum: 1000
        }
      },
      required: ['model', 'messages']
    },
    async handler(args: any): Promise<ToolResponse> {
      const result = await ollamaService.chatCompletion(args);
      return {
        content: [
          {
            type: 'text' as const,
            text: result
          }
        ]
      };
    }
  },
  {
    name: 'mcp_ollama_status',
    description: 'Ollama 서버 상태 확인',
    inputSchema: {
      type: 'object',
      properties: {
        random_string: {
          type: 'string',
          description: 'Dummy parameter for no-parameter tools'
        }
      },
      required: ['random_string']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await ollamaService.getStatus();
        return {
          content: [{
            type: 'text',
            text: result
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Status 확인 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_http_request',
    description: 'HTTP 요청을 보내고 응답을 반환합니다. GET, POST, PUT, DELETE 등 다양한 HTTP 메소드를 사용할 수 있으며, 헤더와 데이터를 설정할 수 있습니다.',
    inputSchema: {
      type: 'object',
      properties: {
        url: {
          type: 'string',
          description: '요청할 URL'
        },
        method: {
          type: 'string',
          enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
          description: 'HTTP 메소드 (기본값: GET)'
        },
        headers: {
          type: 'object',
          description: '요청 헤더 (예: {"Content-Type": "application/json", "Authorization": "Bearer token"})'
        },
        data: {
          type: 'object',
          description: '요청 바디 데이터'
        },
        params: {
          type: 'object',
          description: 'URL 파라미터 (예: ?key=value)'
        },
        timeout: {
          type: 'number',
          description: '타임아웃(밀리초 단위, 기본값: 30000)'
        }
      },
      required: ['url']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await httpService.request(args);
        return {
          content: [{
            type: 'text',
            text: result
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `HTTP 요청 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_openai_chat',
    description: 'OpenAI ChatGPT API를 사용하여 텍스트 완성을 생성합니다',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 모델 (예: gpt-4, gpt-3.5-turbo)'
        },
        messages: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              role: {
                type: 'string',
                enum: ['system', 'user', 'assistant']
              },
              content: {
                type: 'string'
              }
            },
            required: ['role', 'content']
          },
          description: '대화 메시지 배열'
        },
        temperature: {
          type: 'number',
          description: '샘플링 온도(0-2)',
          minimum: 0,
          maximum: 2
        },
        max_tokens: {
          type: 'number',
          description: '생성할 최대 토큰 수'
        }
      },
      required: ['model', 'messages']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await openaiService.chatCompletion(args);
        return {
          content: [{
            type: 'text',
            text: result
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `OpenAI 채팅 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_openai_image',
    description: 'OpenAI DALL-E API를 사용하여 이미지를 생성합니다. 생성된 이미지 파일 경로를 반환하며, 이 경로는 반드시 사용자에게 알려주어야 합니다.',
    inputSchema: {
      type: 'object',
      properties: {
        prompt: {
          type: 'string',
          description: '이미지를 생성할 프롬프트'
        },
        model: {
          type: 'string',
          description: '사용할 모델 (예: dall-e-3, dall-e-2)'
        },
        n: {
          type: 'number',
          description: '생성할 이미지 수',
          minimum: 1,
          maximum: 10
        },
        size: {
          type: 'string',
          description: '이미지 크기',
          enum: ['256x256', '512x512', '1024x1024', '1792x1024', '1024x1792']
        },
        quality: {
          type: 'string',
          description: '이미지 품질 (dall-e-3만 해당)',
          enum: ['standard', 'hd']
        },
        style: {
          type: 'string',
          description: '이미지 스타일 (dall-e-3만 해당)',
          enum: ['vivid', 'natural']
        },
        saveDir: {
          type: 'string',
          description: '이미지를 저장할 디렉토리'
        },
        fileName: {
          type: 'string',
          description: '저장할 파일 이름 (확장자 제외)'
        }
      },
      required: ['prompt']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await openaiService.generateImage(args);
        return {
          content: [{
            type: 'text',
            text: result
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `OpenAI 이미지 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_openai_tts',
    description: 'OpenAI TTS API를 사용하여 텍스트를 음성으로 변환합니다. 생성된 오디오 파일 경로를 반환하며, 이 경로는 반드시 사용자에게 알려주어야 합니다.',
    inputSchema: {
      type: 'object',
      properties: {
        text: {
          type: 'string',
          description: '음성으로 변환할 텍스트'
        },
        model: {
          type: 'string',
          description: '사용할 모델 (예: tts-1, tts-1-hd)'
        },
        voice: {
          type: 'string',
          description: '음성 종류',
          enum: ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer']
        },
        speed: {
          type: 'number',
          description: '음성 속도(0.25-4.0)',
          minimum: 0.25,
          maximum: 4.0
        },
        saveDir: {
          type: 'string',
          description: '음성 파일을 저장할 디렉토리'
        },
        fileName: {
          type: 'string',
          description: '저장할 파일 이름 (확장자 제외)'
        }
      },
      required: ['text']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await openaiService.textToSpeech(args);
        return {
          content: [{
            type: 'text',
            text: result
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `OpenAI TTS 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_openai_transcribe',
    description: 'OpenAI Whisper API를 사용하여 음성을 텍스트로 변환합니다. 변환된 텍스트를 반환합니다.',
    inputSchema: {
      type: 'object',
      properties: {
        audioPath: {
          type: 'string',
          description: '변환할 오디오 파일 경로'
        },
        model: {
          type: 'string',
          description: '사용할 모델 (예: whisper-1)'
        },
        language: {
          type: 'string',
          description: '오디오 언어 (예: ko, en, ja)'
        },
        prompt: {
          type: 'string',
          description: '인식을 도울 힌트 텍스트'
        }
      },
      required: ['audioPath']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await openaiService.speechToText(args);
        return {
          content: [{
            type: 'text',
            text: result
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `OpenAI Whisper 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_openai_embedding',
    description: 'OpenAI Embeddings API를 사용하여 텍스트 임베딩을 생성합니다',
    inputSchema: {
      type: 'object',
      properties: {
        text: {
          type: ['string', 'array'],
          description: '임베딩을 생성할 텍스트 또는 텍스트 배열'
        },
        model: {
          type: 'string',
          description: '사용할 모델 (예: text-embedding-3-small, text-embedding-3-large)'
        },
        dimensions: {
          type: 'number',
          description: '임베딩 차원 수 (API가 지원하는 경우)'
        }
      },
      required: ['text']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await openaiService.generateEmbeddings(args);
        return {
          content: [{
            type: 'text',
            text: result
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `OpenAI 임베딩 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_generate_text',
    description: 'Gemini AI 모델을 사용하여 텍스트를 생성합니다.',
    inputSchema: {
      type: 'object',
      required: ['model', 'prompt'],
      properties: {
        model: {
          type: 'string',
          description: '사용할 Gemini 모델 ID (예: gemini-pro, gemini-1.5-pro 등)',
        },
        prompt: {
          type: 'string',
          description: '텍스트 생성을 위한 프롬프트',
        },
        temperature: {
          type: 'number',
          description: '생성 랜덤성 정도 (0.0 - 2.0)',
          default: 0.7,
        },
        max_tokens: {
          type: 'number',
          description: '생성할 최대 토큰 수',
          default: 1024,
        },
        topK: {
          type: 'number',
          description: '각 위치에서 고려할 최상위 토큰 수',
          default: 40,
        },
        topP: {
          type: 'number',
          description: '확률 질량의 상위 비율을 선택하는 임계값',
          default: 0.95,
        },
      },
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await geminiService.generateText(args);
        return {
          content: [{
            type: 'text',
            text: result.text
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 텍스트 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_chat_completion',
    description: 'Gemini AI 모델을 사용하여 채팅 대화를 완성합니다.',
    inputSchema: {
      type: 'object',
      required: ['model', 'messages'],
      properties: {
        model: {
          type: 'string',
          description: '사용할 Gemini 모델 ID (예: gemini-pro, gemini-1.5-pro 등)',
        },
        messages: {
          type: 'array',
          description: '대화 메시지 목록',
          items: {
            type: 'object',
            required: ['role', 'content'],
            properties: {
              role: {
                type: 'string',
                description: '메시지 작성자 역할 (system, user, assistant)',
                enum: ['system', 'user', 'assistant'],
              },
              content: {
                type: 'string',
                description: '메시지 내용',
              },
            },
          },
        },
        temperature: {
          type: 'number',
          description: '생성 랜덤성 정도 (0.0 - 2.0)',
          default: 0.7,
        },
        max_tokens: {
          type: 'number',
          description: '생성할 최대 토큰 수',
          default: 1024,
        },
        topK: {
          type: 'number',
          description: '각 위치에서 고려할 최상위 토큰 수',
          default: 40,
        },
        topP: {
          type: 'number',
          description: '확률 질량의 상위 비율을 선택하는 임계값',
          default: 0.95,
        },
      },
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await geminiService.chatCompletion(args);
        return {
          content: [{
            type: 'text',
            text: result.message.content
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 채팅 완성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_list_models',
    description: '사용 가능한 Gemini 모델 목록을 조회합니다.',
    inputSchema: {
      type: 'object',
      properties: {},
    },
    async handler(): Promise<ToolResponse> {
      try {
        const models = await geminiService.listModels();
        return {
          content: [{
            type: 'text',
            text: JSON.stringify(models, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 모델 목록 조회 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_generate_images',
    description: 'Google Imagen 모델을 사용하여 이미지를 생성합니다. 곧 mcp_gemini_generate_image 도구로 대체될 예정입니다.',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 모델 ID (예: imagen-3.0-generate-002)',
          default: 'imagen-3.0-generate-002',
        },
        prompt: {
          type: 'string',
          description: '이미지 생성을 위한 텍스트 프롬프트',
        },
        numberOfImages: {
          type: 'number',
          description: '생성할 이미지 수 (1-4)',
          default: 1,
          minimum: 1,
          maximum: 4,
        },
        size: {
          type: 'string',
          description: '생성할 이미지 크기',
          default: '1024x1024',
        },
        saveDir: {
          type: 'string',
          description: '이미지를 저장할 디렉토리',
          default: './temp',
        },
        fileName: {
          type: 'string',
          description: '저장할 이미지 파일 이름 (확장자 제외)',
          default: `imagen-${Date.now()}`,
        },
      },
      required: ['prompt']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        // 기존 호환성을 위해 generateImage 함수 호출
        const result = await geminiService.generateImage(args);
        return {
          content: [{
            type: 'text',
            text: JSON.stringify(result, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 이미지 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_generate_image',
    description: 'Google Gemini 또는 Imagen 모델을 사용하여 이미지를 생성합니다. 모델 이름에 따라 적절한 API가 자동으로 선택됩니다. 생성된 이미지 파일 경로를 반환하며, 이 경로는 반드시 사용자에게 알려주어야 합니다.',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 모델 ID (예: imagen-3.0-generate-002, gemini-2.0-flash-exp-image-generation)',
          default: 'imagen-3.0-generate-002',
        },
        prompt: {
          type: 'string',
          description: '이미지 생성을 위한 텍스트 프롬프트',
        },
        numberOfImages: {
          type: 'number',
          description: '생성할 이미지 수 (1-4, Imagen 모델 전용)',
          default: 1,
          minimum: 1,
          maximum: 4,
        },
        aspectRatio: {
          type: 'string',
          description: '이미지 가로세로 비율 (Imagen 모델 전용)',
          default: '1:1',
          enum: ['1:1', '3:4', '4:3', '9:16', '16:9']
        },
        personGeneration: {
          type: 'string',
          description: '사람 이미지 생성 허용 여부 (Imagen 모델 전용)',
          default: 'ALLOW_ADULT',
          enum: ['DONT_ALLOW', 'ALLOW_ADULT']
        },
        size: {
          type: 'string',
          description: '생성할 이미지 크기',
          default: '1024x1024',
        },
        saveDir: {
          type: 'string',
          description: '이미지를 저장할 디렉토리',
          default: './temp',
        },
        fileName: {
          type: 'string',
          description: '저장할 이미지 파일 이름 (확장자 제외)',
        },
        imageData: {
          type: 'string',
          description: '이미지 편집 시 사용할 Base64로 인코딩된 이미지 데이터 (Gemini 모델 전용)',
        },
        imageMimeType: {
          type: 'string',
          description: '이미지 MIME 타입 (Gemini 모델 전용)',
          default: 'image/png',
        },
        responseModalities: {
          type: 'array',
          description: '응답에 포함할 모달리티 (Gemini 모델 전용)',
          default: ["TEXT", "IMAGE"],
          items: {
            type: 'string',
            enum: ["TEXT", "IMAGE"]
          }
        }
      },
      required: ['prompt']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await geminiService.generateImage(args);
        
        // HTML 형식으로 결과 반환
        let htmlContent = `
<!DOCTYPE html>
<html>
<head>
  <title>Gemini 이미지 생성 결과</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 20px; }
    .container { max-width: 800px; margin: 0 auto; }
    .image-container { margin-top: 20px; }
    .image-item { margin-bottom: 20px; }
    img { max-width: 100%; border: 1px solid #ddd; }
    pre { background-color: #f5f5f5; padding: 10px; border-radius: 5px; overflow-x: auto; }
  </style>
</head>
<body>
  <div class="container">
    <h1>Gemini 이미지 생성 결과</h1>
    <p><strong>모델:</strong> ${result.model}</p>
    <p><strong>프롬프트:</strong> ${result.prompt}</p>
    
    <div class="image-container">`;
        
        if (result.images && result.images.length > 0) {
          result.images.forEach((imgPath: string, index: number) => {
            // 파일 경로에서 파일 이름만 추출
            const fileName = imgPath.split(/[\/\\]/).pop();
            htmlContent += `
      <div class="image-item">
        <h3>이미지 ${index + 1}</h3>
        <img src="${imgPath}" alt="생성된 이미지 ${index + 1}">
        <p>파일 경로: ${imgPath}</p>
      </div>`;
          });
        } else {
          htmlContent += `
      <p>생성된 이미지가 없습니다.</p>`;
        }
        
        if (result.text && result.text.length > 0) {
          htmlContent += `
    <div class="text-container">
      <h2>생성된 텍스트</h2>`;
          
          result.text.forEach((text: string, index: number) => {
            htmlContent += `
      <div class="text-item">
        <pre>${text}</pre>
      </div>`;
          });
          
          htmlContent += `
    </div>`;
        }
        
        htmlContent += `
  </div>
</body>
</html>`;
        
        return {
          content: [{
            type: 'text',
            text: htmlContent
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `이미지 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_generate_videos',
    description: 'Google Veo 모델을 사용하여 비디오를 생성합니다. 생성된 비디오 파일 경로를 반환하며, 이 경로는 반드시 사용자에게 알려주어야 합니다.',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 모델 ID (예: veo-2.0-generate-001)',
          default: 'veo-2.0-generate-001',
        },
        prompt: {
          type: 'string',
          description: '비디오 생성을 위한 텍스트 프롬프트',
        },
        image: {
          type: 'object',
          description: '비디오의 첫 프레임으로 사용할 이미지 (선택 사항)',
          properties: {
            imageBytes: {
              type: 'string',
              description: 'Base64로 인코딩된 이미지 데이터',
            },
            mimeType: {
              type: 'string',
              description: '이미지 MIME 타입 (예: image/png)',
            },
          },
        },
        numberOfVideos: {
          type: 'number',
          description: '생성할 비디오 수 (1-2)',
          default: 1,
          minimum: 1,
          maximum: 2,
        },
        aspectRatio: {
          type: 'string',
          description: '비디오의 가로세로 비율',
          default: '16:9',
          enum: ['16:9', '9:16'],
        },
        personGeneration: {
          type: 'string',
          description: '사람 생성 허용 설정',
          default: 'dont_allow',
          enum: ['dont_allow', 'allow_adult'],
        },
        durationSeconds: {
          type: 'number',
          description: '비디오 길이(초)',
          default: 5,
          minimum: 5,
          maximum: 8,
        },
        saveDir: {
          type: 'string',
          description: '비디오를 저장할 디렉토리',
          default: './temp',
        },
        fileName: {
          type: 'string',
          description: '저장할 비디오 파일 이름 (확장자 제외)',
          default: `veo-${Date.now()}`,
        },
      },
      required: ['prompt']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await geminiService.generateVideos(args);
        return {
          content: [{
            type: 'text',
            text: `비디오가 성공적으로 생성되었습니다. 생성된 비디오 파일: ${JSON.stringify(result.videos)}\n총 ${result.count}개의 비디오가 생성되었습니다.`
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 비디오 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_generate_multimodal_content',
    description: 'Gemini 모델을 사용하여 텍스트와 이미지를 포함한 멀티모달 콘텐츠를 생성합니다. 생성된 텍스트와 이미지 파일 경로를 반환하며, 이 정보는 반드시 사용자에게 알려주어야 합니다.',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 Gemini 모델 ID (예: gemini-2.0-flash-exp-image-generation)',
          default: 'gemini-2.0-flash',
        },
        contents: {
          type: 'array',
          description: '입력 콘텐츠 (텍스트나 이미지)',
          items: {
            type: 'object',
            properties: {
              text: {
                type: 'string',
                description: '텍스트 콘텐츠',
              },
              inlineData: {
                type: 'object',
                description: '인라인 이미지 데이터',
                properties: {
                  mimeType: {
                    type: 'string',
                    description: '이미지 MIME 타입 (예: image/png)',
                  },
                  data: {
                    type: 'string',
                    description: 'Base64로 인코딩된 이미지 데이터',
                  },
                },
              },
            },
          },
        },
        responseModalities: {
          type: 'array',
          description: '응답에 포함할 모달리티 (텍스트, 이미지)',
          default: ['text', 'image'],
          items: {
            type: 'string',
            enum: ['text', 'image'],
          },
        },
        temperature: {
          type: 'number',
          description: '생성 랜덤성 정도 (0.0 - 2.0)',
          default: 0.7,
        },
        max_tokens: {
          type: 'number',
          description: '생성할 최대 토큰 수',
          default: 1024,
        },
        saveDir: {
          type: 'string',
          description: '생성된 이미지를 저장할 디렉토리',
          default: './temp',
        },
        fileName: {
          type: 'string',
          description: '저장할 이미지 파일 이름 (확장자 제외)',
          default: `gemini-multimodal-${Date.now()}`,
        },
      },
      required: ['contents']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const result = await geminiService.generateMultimodalContent(args);
        let responseText = "";
        
        if (result.text && result.text.length > 0) {
          responseText += `생성된 텍스트:\n${result.text.join('\n\n')}\n\n`;
        }
        
        if (result.images && result.images.length > 0) {
          responseText += `생성된 이미지 파일: ${JSON.stringify(result.images)}\n총 ${result.images.length}개의 이미지가 생성되었습니다.`;
        }
        
        return {
          content: [{
            type: 'text',
            text: responseText
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 멀티모달 콘텐츠 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_imagen_generate',
    description: 'Google Imagen 3 모델을 사용하여 텍스트 프롬프트에서 고품질 이미지를 생성합니다. Imagen 3은 포토리얼리즘, 예술적 디테일, 특정 예술 스타일(인상주의, 애니메이션 등)에 탁월합니다. 생성된 이미지에는 항상 SynthID 워터마크가 포함됩니다. 현재 영어 프롬프트만 지원됩니다.',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 Imagen 모델 ID (예: imagen-3.0-generate-002)',
          default: 'imagen-3.0-generate-002',
        },
        prompt: {
          type: 'string',
          description: '이미지 생성을 위한 텍스트 프롬프트. 영어로 작성하세요.',
        },
        numberOfImages: {
          type: 'number',
          description: '생성할 이미지 수 (1-4)',
          default: 1,
          minimum: 1,
          maximum: 4,
        },
        aspectRatio: {
          type: 'string',
          description: '이미지 가로세로 비율',
          default: '1:1',
          enum: ['1:1', '3:4', '4:3', '9:16', '16:9']
        },
        personGeneration: {
          type: 'string',
          description: '사람 이미지 생성 허용 여부 (DONT_ALLOW: 사람 이미지 생성 차단, ALLOW_ADULT: 성인 이미지만 생성 허용)',
          default: 'ALLOW_ADULT',
          enum: ['DONT_ALLOW', 'ALLOW_ADULT']
        },
        saveDir: {
          type: 'string',
          description: '이미지를 저장할 디렉토리',
          default: './temp',
        },
        fileName: {
          type: 'string',
          description: '저장할 이미지 파일 이름 (확장자 제외)',
        }
      },
      required: ['prompt']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        // generateImage 메서드를 사용하지만, Imagen 모델로 고정
        const modelName = args.model || 'imagen-3.0-generate-002';
        if (!modelName.includes('imagen')) {
          throw new Error('이 도구는 Imagen 모델만 지원합니다. 모델 이름에 "imagen"이 포함되어야 합니다.');
        }
        
        const result = await geminiService.generateImage({
          ...args,
          model: modelName
        });
        
        return {
          content: [{
            type: 'text',
            text: JSON.stringify(result, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Imagen 이미지 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_create_image',
    description: 'Gemini 모델을 사용하여 텍스트 프롬프트에서 이미지를 생성합니다. 텍스트와 이미지를 함께 반환합니다. 주요 특징: 1) 생성된 모든 이미지에는 SynthID 워터마크 포함 2) 대화식 이미지 수정 가능 3) 텍스트와 이미지가 혼합된 출력 생성 가능. 최상의 성능을 위해 EN, es-MX, ja-JP, zh-CN, hi-IN 언어를 사용하세요. 이미지 생성이 항상 트리거되지 않을 수 있으므로 "이미지 생성", "이미지 제공" 등의 표현을 명시적으로 요청하세요.',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 Gemini 모델 ID (예: gemini-2.0-flash-exp-image-generation)',
          default: 'gemini-2.0-flash-exp-image-generation',
        },
        prompt: {
          type: 'string',
          description: '이미지 생성을 위한 텍스트 프롬프트. 이미지를 명시적으로 요청하려면 "이미지 생성", "이미지 제공" 등의 표현을 포함하세요.',
        },
        saveDir: {
          type: 'string',
          description: '이미지를 저장할 디렉토리',
          default: './temp',
        },
        fileName: {
          type: 'string',
          description: '저장할 이미지 파일 이름 (확장자 제외)',
        }
      },
      required: ['prompt']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const modelName = args.model || 'gemini-2.0-flash-exp-image-generation';
        
        if (!modelName.includes('gemini')) {
          throw new Error('이 도구는 Gemini 모델만 지원합니다. 모델 이름에 "gemini"가 포함되어야 합니다.');
        }
        
        const result = await geminiService.generateGeminiImage({
          model: modelName,
          prompt: args.prompt,
          saveDir: args.saveDir || './temp',
          fileName: args.fileName
        });
        
        return {
          content: [{
            type: 'text',
            text: JSON.stringify(result, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 이미지 생성 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  },
  {
    name: 'mcp_gemini_edit_image',
    description: 'Gemini 모델을 사용하여 기존 이미지를 편집합니다. 텍스트 프롬프트와 Base64로 인코딩된 이미지 데이터가 필요합니다. 제한사항: 1) 오디오/동영상 입력 미지원 2) 이미지 생성이 항상 트리거되지 않음(명시적으로 "이미지 업데이트", "이미지 편집" 등 요청 필요) 3) 모델이 가끔 생성을 중단할 수 있음. 이미지에 텍스트를 생성할 때는 먼저 텍스트를 생성한 다음 텍스트가 포함된 이미지를 요청하는 것이 효과적입니다. 멀티턴 이미지 편집(채팅)이 가능하며, 컨텍스트를 유지하면서 이미지를 수정할 수 있습니다.',
    inputSchema: {
      type: 'object',
      properties: {
        model: {
          type: 'string',
          description: '사용할 Gemini 모델 ID (예: gemini-2.0-flash-exp-image-generation)',
          default: 'gemini-2.0-flash-exp-image-generation',
        },
        prompt: {
          type: 'string',
          description: '이미지 편집을 위한 텍스트 프롬프트. 명시적으로 "이미지 업데이트", "이미지 편집" 등의 표현을 포함하세요.',
        },
        imageData: {
          type: 'string',
          description: 'Base64로 인코딩된 이미지 데이터. fs.readFileSync(imagePath).toString("base64")로 파일에서 얻을 수 있습니다.',
        },
        imageMimeType: {
          type: 'string',
          description: '이미지 MIME 타입 (예: image/png, image/jpeg)',
          default: 'image/png',
        },
        saveDir: {
          type: 'string',
          description: '편집된 이미지를 저장할 디렉토리',
          default: './temp',
        },
        fileName: {
          type: 'string',
          description: '저장할 이미지 파일 이름 (확장자 제외)',
        }
      },
      required: ['prompt', 'imageData']
    },
    async handler(args: any): Promise<ToolResponse> {
      try {
        const modelName = args.model || 'gemini-2.0-flash-exp-image-generation';
        
        if (!modelName.includes('gemini')) {
          throw new Error('이 도구는 Gemini 모델만 지원합니다. 모델 이름에 "gemini"가 포함되어야 합니다.');
        }
        
        if (!args.imageData) {
          throw new Error('이미지 데이터가 필요합니다. 유효한 Base64로 인코딩된 이미지 데이터를 제공하세요.');
        }
        
        const result = await geminiService.editGeminiImage({
          model: modelName,
          prompt: args.prompt,
          imageData: args.imageData,
          imageMimeType: args.imageMimeType || 'image/png',
          saveDir: args.saveDir || './temp',
          fileName: args.fileName
        });
        
        return {
          content: [{
            type: 'text',
            text: JSON.stringify(result, null, 2)
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Gemini 이미지 편집 오류: ${error instanceof Error ? error.message : String(error)}`
          }]
        };
      }
    }
  }
];

src/tools/index.ts:1424-1480 (handler)

Handler function for 'mcp_gemini_create_image' tool that validates input, calls geminiService.generateGeminiImage, and formats response.

{
  name: 'mcp_gemini_create_image',
  description: 'Gemini 모델을 사용하여 텍스트 프롬프트에서 이미지를 생성합니다. 텍스트와 이미지를 함께 반환합니다. 주요 특징: 1) 생성된 모든 이미지에는 SynthID 워터마크 포함 2) 대화식 이미지 수정 가능 3) 텍스트와 이미지가 혼합된 출력 생성 가능. 최상의 성능을 위해 EN, es-MX, ja-JP, zh-CN, hi-IN 언어를 사용하세요. 이미지 생성이 항상 트리거되지 않을 수 있으므로 "이미지 생성", "이미지 제공" 등의 표현을 명시적으로 요청하세요.',
  inputSchema: {
    type: 'object',
    properties: {
      model: {
        type: 'string',
        description: '사용할 Gemini 모델 ID (예: gemini-2.0-flash-exp-image-generation)',
        default: 'gemini-2.0-flash-exp-image-generation',
      },
      prompt: {
        type: 'string',
        description: '이미지 생성을 위한 텍스트 프롬프트. 이미지를 명시적으로 요청하려면 "이미지 생성", "이미지 제공" 등의 표현을 포함하세요.',
      },
      saveDir: {
        type: 'string',
        description: '이미지를 저장할 디렉토리',
        default: './temp',
      },
      fileName: {
        type: 'string',
        description: '저장할 이미지 파일 이름 (확장자 제외)',
      }
    },
    required: ['prompt']
  },
  async handler(args: any): Promise<ToolResponse> {
    try {
      const modelName = args.model || 'gemini-2.0-flash-exp-image-generation';
      
      if (!modelName.includes('gemini')) {
        throw new Error('이 도구는 Gemini 모델만 지원합니다. 모델 이름에 "gemini"가 포함되어야 합니다.');
      }
      
      const result = await geminiService.generateGeminiImage({
        model: modelName,
        prompt: args.prompt,
        saveDir: args.saveDir || './temp',
        fileName: args.fileName
      });
      
      return {
        content: [{
          type: 'text',
          text: JSON.stringify(result, null, 2)
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: 'text',
          text: `Gemini 이미지 생성 오류: ${error instanceof Error ? error.message : String(error)}`
        }]
      };
    }
  }

src/tools/index.ts:1427-1450 (schema)

Input schema defining parameters for the mcp_gemini_create_image tool: prompt (required), model, saveDir, fileName.

inputSchema: {
  type: 'object',
  properties: {
    model: {
      type: 'string',
      description: '사용할 Gemini 모델 ID (예: gemini-2.0-flash-exp-image-generation)',
      default: 'gemini-2.0-flash-exp-image-generation',
    },
    prompt: {
      type: 'string',
      description: '이미지 생성을 위한 텍스트 프롬프트. 이미지를 명시적으로 요청하려면 "이미지 생성", "이미지 제공" 등의 표현을 포함하세요.',
    },
    saveDir: {
      type: 'string',
      description: '이미지를 저장할 디렉토리',
      default: './temp',
    },
    fileName: {
      type: 'string',
      description: '저장할 이미지 파일 이름 (확장자 제외)',
    }
  },
  required: ['prompt']
},

src/services/gemini-service.ts:736-816 (helper)

Core implementation: generateGeminiImage method in GeminiService that makes API request to Gemini, extracts images/text from response, saves images to disk, returns file paths.

async generateGeminiImage({
  model,
  prompt,
  saveDir = './temp',
  fileName = `gemini-${Date.now()}`,
}: {
  model: string;
  prompt: string;
  saveDir?: string;
  fileName?: string;
}) {
  try {
    if (!model.includes('gemini')) {
      throw new Error('이 메서드는 Gemini 모델만 지원합니다. 모델 이름에 "gemini"가 포함되어야 합니다.');
    }
    
    const config = this.getRequestConfig();
    const url = `${this.baseUrl}/models/${model}:generateContent`;

    // responseModalities 필드 제거 - API가 해당 필드를 인식하지 않음
    const response = await axios.post(
      url,
      {
        contents: [
          {
            parts: [
              {
                text: prompt,
              },
            ],
          },
        ],
      },
      config
    );

    // 파일 시스템 모듈 임포트
    const fs = await import('fs');
    const path = await import('path');

    // 저장 디렉토리가 없으면 생성
    if (!fs.existsSync(saveDir)) {
      fs.mkdirSync(saveDir, { recursive: true });
    }

    // 응답 처리
    const parts = response.data.candidates?.[0]?.content?.parts || [];
    const result: {
      text: string[];
      images: string[];
    } = {
      text: [],
      images: [],
    };

    for (let i = 0; i < parts.length; i++) {
      const part = parts[i];
      
      if (part.text) {
        result.text.push(part.text);
      } else if (part.inlineData) {
        const imageData = part.inlineData.data;
        const buffer = Buffer.from(imageData, 'base64');
        const filePath = path.join(saveDir, `${fileName}-${i + 1}.png`);
        
        fs.writeFileSync(filePath, buffer);
        result.images.push(filePath);
      }
    }

    return {
      model: model,
      prompt: prompt,
      text: result.text,
      images: result.images,
      count: result.images.length,
    };
  } catch (error) {
    throw this.formatError(error);
  }
}

src/index.ts:26-53 (registration)

MCP server capabilities registration lists mcp_gemini_create_image (disabled: false).

mcp_sparql_execute_query: true,
mcp_sparql_update: true,
mcp_sparql_list_repositories: true,
mcp_sparql_list_graphs: true,
mcp_sparql_get_resource_info: true,
mcp_ollama_run: true,
mcp_ollama_show: true,
mcp_ollama_pull: true,
mcp_ollama_list: true,
mcp_ollama_rm: true,
mcp_ollama_chat_completion: true,
mcp_ollama_status: true,
mcp_http_request: true,
mcp_openai_chat: true,
mcp_openai_image: true,
mcp_openai_tts: true,
mcp_openai_transcribe: true,
mcp_openai_embedding: true,
mcp_gemini_generate_text: true,
mcp_gemini_chat_completion: true,
mcp_gemini_list_models: true,
mcp_gemini_generate_images: false,
mcp_gemini_generate_image: false,
mcp_gemini_generate_videos: false,
mcp_gemini_generate_multimodal_content: false,
mcp_imagen_generate: false,
mcp_gemini_create_image: false,
mcp_gemini_edit_image: false

Tool Definition Quality

A3.8/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does well by describing key behavioral traits: SynthID watermarking on all generated images, capability for interactive image modification, ability to generate mixed text-image outputs, and the important caveat that image generation isn't always triggered automatically. This provides substantial behavioral context beyond basic functionality.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is moderately concise but could be better structured. It starts with the core purpose, then lists features in a numbered format, and ends with usage recommendations. While informative, the numbered feature list feels somewhat disconnected from the flow, and some sentences could be more tightly integrated. Every sentence adds value, but the organization could be improved.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of an image generation tool with no annotations and no output schema, the description does a reasonably complete job. It covers the core functionality, key behavioral characteristics, and important usage considerations. However, it doesn't describe the output format (what exactly is returned beyond '텍스트와 이미지를 함께 반환합니다'), which would be helpful given the lack of output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 100% schema description coverage, the baseline is 3. The description doesn't add significant parameter semantics beyond what's already in the schema. It mentions the importance of explicit image requests in prompts, which relates to the 'prompt' parameter, but this is already covered in the schema's description. No additional parameter context is provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Gemini 모델을 사용하여 텍스트 프롬프트에서 이미지를 생성합니다' (Generates images from text prompts using Gemini model). It specifies the verb (생성/creates) and resource (이미지/images). However, it doesn't explicitly differentiate from sibling tools like 'mcp_gemini_generate_image' or 'mcp_gemini_edit_image', which appear to have similar functions.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool: for generating images from text prompts using Gemini. It offers specific guidance on language preferences ('EN, es-MX, ja-JP, zh-CN, hi-IN') and explicit prompting techniques ('이미지 생성', '이미지 제공'). However, it doesn't explicitly mention when NOT to use it or name alternative tools for different scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Related Tools

generate_image_from_text
@sungmin-koo-ai/GeminiImageMCP
generateImage
@bowwowxx/GeminiMcpServer
generateImageD
@sanxfxteam/gemini-mcp-server
generate_image_from_text
@qhdrl12/mcp-server-gemini-image-generator
mcp_imagen_generateA
@bigdata-coss/agent_mcp
imagen4
@RamboRogers/fal-image-video-mcp

Latest Blog Posts

Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security
Open Source Has a Bot Problem
By punkpeye on March 19, 2026.
open source

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/bigdata-coss/agent_mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server