NoLang MCP Server

Instructions

Implementation Reference

• nolang_mcp/server.py:82-93 (handler)

  The main handler function for the 'generate_video_with_setting' MCP tool. It receives arguments via VideoGenerationFromSettingArgs and delegates to the _generate_video helper to perform the actual API call based on provided inputs.

  async def generate_video_with_setting(
      args: VideoGenerationFromSettingArgs,
  ) -> VideoGenerationResult:
      return await _generate_video(
          args.video_setting_id,
          args.text,
          args.pdf_path,
          args.pptx_path,
          args.audio_path,
          args.video_path,
          args.image_paths,
      )

• nolang_mcp/server.py:78-81 (registration)

  Registration of the 'generate_video_with_setting' tool using the FastMCP @mcp.tool decorator.

  @mcp.tool(
      name="generate_video_with_setting",
      description="Consumes paid credits. Start video generation using your VideoSetting ID. Provide text, pdf_path, pptx_path, audio_path, video_path, or image_paths as required.",
  )

• nolang_mcp/server.py:34-76 (helper)

  Core helper function implementing the video generation logic by routing to appropriate nolang_api methods based on input types (text, PDF, PPTX, audio, video, images).

  async def _generate_video(
      setting: Union[UUID, str, Dict[str, Any]],
      text: str = "",
      pdf_path: str = "",
      pptx_path: str = "",
      audio_path: str = "",
      video_path: str = "",
      image_paths: str = "",
  ) -> VideoGenerationResult:
      """Generate a video and return a structured response."""
  
      try:
          # PDF analysis mode
          if pdf_path and text:
              result = await nolang_api.generate_video_with_pdf_and_text(setting, pdf_path, text)
          # PDF mode
          elif pdf_path:
              result = await nolang_api.generate_video_with_pdf(setting, pdf_path)
          # PPTX mode
          elif pptx_path:
              result = await nolang_api.generate_video_with_pptx(setting, pptx_path)
          # Audio mode
          elif audio_path:
              result = await nolang_api.generate_video_with_audio(setting, audio_path)
          # Video mode
          elif video_path:
              result = await nolang_api.generate_video_with_video(setting, video_path)
          # Text mode (with/without images)
          elif text:
              image_files = None
              if image_paths:
                  image_files = [p.strip() for p in image_paths.split(",") if p.strip()]
              result = await nolang_api.generate_video_with_text(setting, text, image_files)
          else:
              raise ValueError("At least one of text, pdf_path, pptx_path, audio_path or video_path must be provided")
  
          return VideoGenerationResult(video_id=result.video_id)
      except httpx.HTTPStatusError as e:
          # Surface HTTP errors back to the LLM as a structured object
          raise RuntimeError(format_http_error(e)) from e
      except FileNotFoundError as e:
          raise RuntimeError(str(e)) from e

• nolang_mcp/models.py:173-216 (schema)

  Input schema: VideoGenerationToolArgs (base class with common fields) and VideoGenerationFromSettingArgs (specific video_setting_id field) using Pydantic BaseModel for validation.

  class VideoGenerationToolArgs(BaseModel):
      """Base arguments for video generation tools."""
  
      model_config = ConfigDict(extra="forbid")
  
      text: str = Field(
          default="",
          description="Input text for query modes or slideshow_analysis mode",
      )
      pdf_path: str = Field(
          default="",
          description="PDF file path for slideshow modes",
          examples=["/path/to/presentation.pdf"],
      )
      pptx_path: str = Field(
          default="",
          description="PPTX file path for slideshow modes",
          examples=["/path/to/presentation.pptx"],
      )
      audio_path: str = Field(
          default="",
          description="Audio file path for audio_speech mode",
          examples=["/path/to/audio.mp3"],
      )
      video_path: str = Field(
          default="",
          description="Video file path for audio_video mode",
          examples=["/path/to/video.mp4"],
      )
      image_paths: str = Field(
          default="",
          description="Comma-separated image file paths for query modes",
          examples=["image1.jpg,image2.png,image3.jpeg"],
      )
  
  
  class VideoGenerationFromSettingArgs(VideoGenerationToolArgs):
      """Arguments for generating video from video setting ID."""
  
      video_setting_id: UUID = Field(
          ...,
          description="UUID of VideoSetting to use for generation",
      )

• nolang_mcp/models.py:305-309 (schema)

  Output schema: VideoGenerationResult defining the video_id returned upon successful generation request.

  class VideoGenerationResult(BaseModel):
      model_config = ConfigDict(extra="allow")
  
      video_id: UUID = Field(..., description="Unique identifier for the queued video")