memo（memo 音频）

SenseAudio Voice Memo Transcriber

Transform voice memos into organized, searchable text with automatic categorization and key information extraction.

What This Skill Does

• Transcribe voice memos to text with high accuracy
• Convert casual speech to structured written format
• Extract key information (dates, tasks, contacts)
• Organize memos by topic or category
• Generate summaries and action items

Prerequisites

Install required Python packages:

pip install requests

Implementation Guide

Step 1: Transcribe Voice Memo

import requests

def transcribe_voice_memo(audio_file):
    url = "https://api.senseaudio.cn/v1/audio/transcriptions"

    headers = {"Authorization": f"Bearer {API_KEY}"}
    files = {"file": open(audio_file, "rb")}
    data = {
        "model": "sense-asr",  # Standard model: full features, good for voice memos
        "response_format": "json"
    }

    response = requests.post(url, headers=headers, files=files, data=data)
    return response.json()["text"]

Step 2: Clean and Structure Text

Convert casual speech to readable text:

import re

def clean_transcription(text):
    # Remove filler words
    fillers = ["um", "uh", "like", "you know", "basically", "actually"]
    for filler in fillers:
        text = re.sub(rf'\b{filler}\b', '', text, flags=re.IGNORECASE)

    # Fix spacing
    text = re.sub(r'\s+', ' ', text).strip()

    # Capitalize sentences
    sentences = text.split('. ')
    text = '. '.join(s.capitalize() for s in sentences)

    return text

Step 3: Extract Key Information

import re
from datetime import datetime

def extract_info(text):
    info = {
        "dates": [],
        "tasks": [],
        "contacts": [],
        "keywords": []
    }

    # Extract dates
    date_patterns = [
        r'\b(?:tomorrow|today|yesterday)\b',
        r'\b(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b',
        r'\b\d{1,2}/\d{1,2}/\d{2,4}\b'
    ]
    for pattern in date_patterns:
        info["dates"].extend(re.findall(pattern, text, re.IGNORECASE))

    # Extract tasks (action verbs)
    task_patterns = [
        r'(?:need to|have to|must|should)\s+(\w+(?:\s+\w+){0,5})',
        r'(?:remember to|don\'t forget to)\s+(\w+(?:\s+\w+){0,5})'
    ]
    for pattern in task_patterns:
        info["tasks"].extend(re.findall(pattern, text, re.IGNORECASE))

    # Extract names (capitalized words)
    info["contacts"] = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', text)

    return info

Step 4: Categorize Memo

def categorize_memo(text):
    categories = {
        "work": ["meeting", "project", "deadline", "client", "email"],
        "personal": ["family", "friend", "home", "weekend"],
        "shopping": ["buy", "purchase", "store", "grocery"],
        "ideas": ["idea", "think", "maybe", "could"],
        "tasks": ["todo", "task", "need to", "must"]
    }

    text_lower = text.lower()
    scores = {}

    for category, keywords in categories.items():
        score = sum(1 for keyword in keywords if keyword in text_lower)
        scores[category] = score

    return max(scores, key=scores.get) if max(scores.values()) > 0 else "general"

Step 5: Generate Structured Output

def process_voice_memo(audio_file):
    # Transcribe
    raw_text = transcribe_voice_memo(audio_file)

    # Clean
    clean_text = clean_transcription(raw_text)

    # Extract info
    info = extract_info(clean_text)

    # Categorize
    category = categorize_memo(clean_text)

    # Create structured memo
    memo = {
        "timestamp": datetime.now().isoformat(),
        "category": category,
        "text": clean_text,
        "raw_text": raw_text,
        "extracted_info": info,
        "summary": generate_summary(clean_text)
    }

    return memo

def generate_summary(text):
    # Use first sentence or first 100 chars
    sentences = text.split('. ')
    return sentences[0] if sentences else text[:100]

Advanced Features

Batch Processing

Process multiple memos:

def process_memo_batch(audio_files):
    memos = []
    for audio_file in audio_files:
        memo = process_voice_memo(audio_file)
        memos.append(memo)

    # Group by category
    by_category = {}
    for memo in memos:
        category = memo["category"]
        if category not in by_category:
            by_category[category] = []
        by_category[category].append(memo)

    return by_category

Search and Filter

def search_memos(memos, query):
    results = []
    query_lower = query.lower()

    for memo in memos:
        if query_lower in memo["text"].lower():
            results.append(memo)

    return results

def filter_by_date(memos, date):
    return [m for m in memos if date in m["extracted_info"]["dates"]]

Export Formats

def export_to_markdown(memos):
    md = "# Voice Memos\
\
"

    for memo in memos:
        md += f"## {memo['timestamp']}\
"
        md += f"**Category**: {memo['category']}\
\
"
        md += f"{memo['text']}\
\
"

        if memo['extracted_info']['tasks']:
            md += "**Tasks**:\
"
            for task in memo['extracted_info']['tasks']:
                md += f"- [ ] {task}\
"
            md += "\
"

    return md

Output Format

• Cleaned transcription text
• Structured memo JSON
• Extracted information (dates, tasks, contacts)
• Category classification
• Summary

Tips for Best Results

• Speak clearly and at normal pace
• Mention dates and names explicitly
• Use action verbs for tasks
• Keep memos under 5 minutes for best results
• Review and edit extracted information

Reference

• SenseAudio ASR API
• SenseAudio Platform