[For Beginners] Getting Started with Personal Knowledge Management Using Claude Code × Obsidian × Vertex AI

			
			import os
import logging
import vertexai
from vertexai.generative_models import GenerativeModel, Part
from dotenv import load_dotenv
import ffmpeg

# Loading .env file
load_dotenv()

# ---------- Environment Variables ----------
PROJECT_ID = os.getenv("PROJECT_ID")
REGION = os.getenv("REGION")
FILE_NAME = os.getenv("FILE_NAME")  # Example: "meeting_audio.mp4" or "meeting_audio.mp3"
OUTPUT_DIR = "output"  # Output destination
MODEL_NAME = "gemini-2.5-pro"
GOOGLE_APPLICATION_CREDENTIALS = os.getenv("GOOGLE_APPLICATION_CREDENTIALS")
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = GOOGLE_APPLICATION_CREDENTIALS

# ---------- Logging ----------
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(message)s")
logger = logging.getLogger(__name__)

# Initialize Vertex AI
vertexai.init(project=PROJECT_ID, location=REGION)

def convert_mp4_to_mp3(mp4_path: str, mp3_path: str) -> None:
    """Convert MP4 file to MP3"""
    logger.info("Starting conversion from MP4 to MP3: %s -> %s", mp4_path, mp3_path)
    try:
        (
            ffmpeg.input(mp4_path)
            .output(mp3_path)
            .global_args("-loglevel", "quiet")
            .run(overwrite_output=True)
        )
        logger.info("MP4 to MP3 conversion completed")
    except Exception as e:
        logger.error("Error occurred during MP4 conversion: %s", e)
        raise

def transcribe_audio(audio_path: str) -> str:
    """Transcribe audio file to text"""
    logger.info("Starting transcription: %s", audio_path)

    model = GenerativeModel(MODEL_NAME)

    # Determine MIME type based on file extension
    if audio_path.lower().endswith('.mp4'):
        mime_type = "video/mp4"
    elif audio_path.lower().endswith('.mp3'):
        mime_type = "audio/mp3"
    else:
        raise ValueError(f"Unsupported file format: {audio_path}")

    with open(audio_path, "rb") as f:
        audio_part = Part.from_data(f.read(), mime_type=mime_type)

    prompt = (
        "Please transcribe the following audio.\n"
        "1. Start a new line whenever the speaker changes.\n"
        "2. Add punctuation where possible.\n"
    )

    response = model.generate_content([audio_part, prompt])
    logger.info("Transcription completed")
    return response.text

if __name__ == "__main__":
    try:
        # Separate filename and extension
        input_file_path = os.path.join("input", FILE_NAME)
        file_name_without_ext, file_extension = os.path.splitext(FILE_NAME)

        # Check if input file exists
        if not os.path.exists(input_file_path):
            raise FileNotFoundError(f"Input file not found: {input_file_path}")

        audio_file = None
        temp_mp3_file = None

        if file_extension.lower() == ".mp4":
            # For MP4 files, convert to MP3
            temp_mp3_file = os.path.join("input", f"{file_name_without_ext}_converted.mp3")
            convert_mp4_to_mp3(input_file_path, temp_mp3_file)
            audio_file = temp_mp3_file
        elif file_extension.lower() == ".mp3":
            # For MP3 files, use as is
            audio_file = input_file_path
        else:
            raise ValueError(f"Unsupported file format: {file_extension}")

        # Execute transcription
        transcript = transcribe_audio(audio_file)

        # Save output (using filename without extension)
        os.makedirs(OUTPUT_DIR, exist_ok=True)
        out_path = os.path.join(OUTPUT_DIR, f"{file_name_without_ext}_transcript.txt")
        with open(out_path, "w", encoding="utf-8") as f:
            f.write(transcript)
        logger.info("Transcription text saved: %s", out_path)

        # Delete temporary file
        if temp_mp3_file and os.path.exists(temp_mp3_file):
            os.remove(temp_mp3_file)
            logger.info("Temporary file deleted: %s", temp_mp3_file)

    except Exception as e:
        logger.exception("Error occurred during processing: %s", e)
        raise
```:::

`.prettierrc` is used to set up automatic formatting configuration for markdown files.

```txt: .prettierrc
{
  "tabWidth": 4,
  "useTabs": false,
  "proseWrap": "preserve",
  "printWidth": 120,
  "endOfLine": "lf"
}

		

			
			# macOS/Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

		

			
			# Navigate to project directory
cd audio_video_to_text

# Create virtual environment (automatically installs Python 3.13)
uv venv --python 3.13

# Activate virtual environment
# macOS/Linux
source .venv/bin/activate
# Windows
.venv\Scripts\activate

# Install dependencies
uv pip install -r requirements.txt

		

			
			PROJECT_ID=your-gcp-project-id
REGION=your-region
GOOGLE_APPLICATION_CREDENTIALS=path/to/your/service-account-key.json
FILE_NAME=eng_record.mp3

		

			
			@obsidian-claude-feedback-sample % npm install

added 1 package, and audited 2 packages in 706ms

1 package is looking for funding
  run `npm fund` for details

found 0 vulnerabilities 

		

			
			@obsidian-claude-feedback-sample % npm list
obsidian-claude-feedback-sample@1.0.0 /git/obsidian-claude-feedback-sample
└── prettier@3.6.2

		

			
			cd audio_video_to_text
python audio_video_to_text.py

		

			
			@audio_video_to_text % python audio_video_to_text.py
2025-07-09 22:41:02,151 - Transcription started: input/eng_record.mp3
2025-07-09 22:42:15,686 - Transcription completed
2025-07-09 22:42:15,688 - Transcription text saved: output/eng_record_transcript.txt