Gerar músicas com o Lyria 3

O Lyria 3 é a família de modelos de geração de música do Google, disponível pela API Gemini. Com o Lyria 3, é possível gerar áudio estéreo de alta qualidade em 44, 1 kHz com base em comandos de texto ou imagens. Esses modelos oferecem coerência estrutural, incluindo vocais, letras sincronizadas e arranjos instrumentais completos.

A família Lyria 3 inclui dois modelos:

Modelo ID do modelo Ideal para Duração Saída
Lyria 3 Clip lyria-3-clip-preview Clipes curtos, loops, prévias 30 segundos MP3
Lyria 3 Pro lyria-3-pro-preview Músicas completas com versos, refrões e pontes Alguns minutos (controláveis usando o comando) MP3

Os dois modelos podem ser usados com a nova API Interactions, que aceita entradas multimodais (texto e imagens) e produz áudio estéreo de alta fidelidade de 44,1 kHz.

Gerar um videoclipe

O modelo Lyria 3 Clip sempre gera um clipe de 30 segundos. Para gerar um clipe, chame o método interactions.create com um comando de texto. A resposta sempre inclui a letra e a estrutura da música geradas, além do áudio no esquema steps.

Python

import base64
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="lyria-3-clip-preview",
    input="A short instrumental acoustic guitar piece.",
)

generated_audio = interaction.output_audio
if generated_audio:
    with open("music.mp3", "wb") as f:
        f.write(base64.b64decode(generated_audio.data))

lyrics = interaction.output_text
if lyrics:
    print(f"Lyrics:\n{lyrics}")

JavaScript

import { GoogleGenAI } from '@google/genai';
import * as fs from 'fs';

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
    model: 'lyria-3-clip-preview',
    input: 'A short instrumental acoustic guitar piece.',
});

const generatedAudio = interaction.output_audio;
if (generatedAudio) {
  fs.writeFileSync('music.mp3', Buffer.from(generatedAudio.data, 'base64'));
}

const lyrics = interaction.output_text;
if (lyrics) {
  console.log(`Lyrics:\n${lyrics}`);
}

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "model": "lyria-3-clip-preview",
    "input": "A short instrumental acoustic guitar piece."
}'

É possível recuperar os dados de música gerados usando a propriedade interaction.output_audio, que retorna o último bloco de áudio gerado. Também é possível recuperar a letra e a estrutura da música usando a propriedade interaction.output_text. Para detalhes sobre propriedades de conveniência, consulte a visão geral das interações.

Gerar uma música completa

Use o modelo lyria-3-pro-preview para gerar músicas completas que duram alguns minutos. O modelo Pro entende a estrutura musical e pode criar composições com versos, refrões e pontes distintos. É possível influenciar a duração especificando-a no comando (por exemplo, "crie uma música de 2 minutos") ou usando carimbos de data/hora para definir a estrutura.

Python

interaction = client.interactions.create(
    model="lyria-3-pro-preview",
    input="An epic cinematic orchestral piece about a journey home. Starts with a solo piano intro, builds through sweeping strings, and climaxes with a massive wall of sound.",
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3-pro-preview',
    input: 'A beautiful piano melody.',
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
    "model": "lyria-3-pro-preview",
    "input": "A beautiful piano melody."
}'

Selecionar o formato de saída

Por padrão, os modelos do Lyria 3 geram áudio no formato MP3. Para o Lyria 3 Pro, também é possível solicitar a saída no formato WAV definindo response_format.

Python

interaction = client.interactions.create(
    model="lyria-3-pro-preview",
    input="A beautiful piano melody.",
    response_format={"type": "audio"},
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3-pro-preview',
    input: 'A beautiful piano melody.',
    response_format: {
        type: 'audio',
    },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3-pro-preview",
    "input": "A beautiful piano melody.",
    "response_format": {
        "type": "audio"
    }
  }'

Analise a resposta

A resposta da Lyria 3 contém vários blocos de conteúdo no esquema steps. As interações retornam uma sequência de etapas, em que model_output etapas contêm o conteúdo gerado. Os blocos de conteúdo de texto contêm a letra gerada ou uma descrição JSON da estrutura da música. Os blocos de conteúdo do tipo audio contêm os dados de áudio codificados em base64.

Python

lyrics = []
audio_data = None

generated_audio = interaction.output_audio
if generated_audio:
    with open("output.mp3", "wb") as f:
        f.write(base64.b64decode(generated_audio.data))

lyrics = interaction.output_text
if lyrics:
    print(f"Lyrics:\n{lyrics}")

JavaScript

const lyrics = [];
let audioData = null;

const generatedAudio = interaction.output_audio;
if (generatedAudio) {
    fs.writeFileSync("output.mp3", Buffer.from(generatedAudio.data, 'base64'));
}

const lyrics = interaction.output_text;
if (lyrics) {
    console.log("Lyrics:\n" + lyrics);
}

REST

# The output from the REST API is a JSON object containing base64 encoded data.
# You can extract the text or the audio data using a tool like jq.
# To extract the audio and save it to a file:
curl ... | jq -r '.steps[] | select(.type=="model_output") | .content[] | select(.type=="audio") | .data' | base64 -d > output.mp3

Letras e músicas intercaladas

Como a saída do Lyria 3 é complexa, contendo etapas e blocos separados para letras geradas (texto) e a música em si (áudio), as propriedades de conveniência oferecem um atalho rápido e recomendado.

No entanto, se você quiser controle programático total sobre a linha do tempo bruta de etapas retornadas pelo servidor (como registrar blocos de conteúdo individuais à medida que são recebidos), itere manualmente em steps:

Python

lyrics = []
audio_data = None

for step in interaction.steps:
    if step.type == "model_output":
        for content_block in step.content:
            if content_block.type == "audio":
                audio_data = base64.b64decode(content_block.data)
            elif content_block.type == "text":
                lyrics.append(content_block.text)

if lyrics:
    print("Lyrics:\n" + "\n".join(lyrics))

if audio_data:
    with open("output.mp3", "wb") as f:
        f.write(audio_data)

JavaScript

const lyrics = [];
let audioData = null;

for (const step of interaction.steps) {
    if (step.type === 'model_output') {
        for (const contentBlock of step.content) {
            if (contentBlock.type === 'audio') {
                audioData = Buffer.from(contentBlock.data, 'base64');
            } else if (contentBlock.type === 'text') {
                lyrics.push(contentBlock.text);
            }
        }
    }
}

if (lyrics.length) {
    console.log("Lyrics:\n" + lyrics.join("\n"));
}

if (audioData) {
    fs.writeFileSync("output.mp3", audioData);
}

Gerar música com base em imagens

O Lyria 3 aceita entradas multimodais. Você pode fornecer até 10 imagens com seu comando de texto na lista input, e o modelo vai compor músicas inspiradas no conteúdo visual.

Python

import base64

with open("desert_sunset.jpg", "rb") as f:
    image_bytes = f.read()
    image_b64 = base64.b64encode(image_bytes).decode("utf-8")

response = client.interactions.create(
    model="lyria-3-pro-preview",
    input=[
        {
            "type": "text",
            "text": "An atmospheric ambient track inspired by the mood and colors in this image.",
        },
        {
            "type": "image",
            "mime_type": "image/jpeg",
            "data": image_b64,
        },
    ],
)

JavaScript

import * as fs from "fs";

const imageBytes = fs.readFileSync("desert_sunset.jpg").toString("base64");

const interaction = await client.interactions.create({
    model: "lyria-3-pro-preview",
    input: [
        {
            type: "text",
            text: "An atmospheric ambient track inspired by the mood and colors in this image.",
        },
        {
            type: "image",
            mime_type: "image/jpeg",
            data: imageBytes,
        },
    ],
});

REST

# Pass base64 encoded image data directly:
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "lyria-3-pro-preview",
    "input": [
      {"type": "text", "text": "An atmospheric ambient track inspired by the mood and colors in this image."},
      {"type": "image", "mime_type": "image/jpeg", "data": "/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAP//////////////////////////////////////////////////////////////////////////////////////wgALCAABAAEBAREA/8QAFBABAAAAAAAAAAAAAAAAAAAAAP/aAAgBAQABPxA="}
    ]
  }'

Fornecer letras personalizadas

Você pode escrever suas próprias letras e incluí-las no comando. Use tags de seção como [Verse], [Chorus] e [Bridge] para ajudar o modelo a entender a estrutura da música:

Python

prompt = """
Create a dreamy indie pop song with the following lyrics:

[Verse 1]
Walking through the neon glow,
city lights reflect below,
every shadow tells a story,
every corner, fading glory.

[Chorus]
We are the echoes in the night,
burning brighter than the light,
hold on tight, don't let me go,
we are the echoes down below.

[Verse 2]
Footsteps lost on empty streets,
rhythms sync to heartbeats,
whispers carried by the breeze,
dancing through the autumn leaves.
"""

interaction = client.interactions.create(
    model="lyria-3-pro-preview",
    input=prompt,
)

JavaScript

const prompt = `
Create a dreamy indie pop song with the following lyrics:

[Verse 1]
Walking through the neon glow,
city lights reflect below,
every shadow tells a story,
every corner, fading glory.

[Chorus]
We are the echoes in the night,
burning brighter than the light,
hold on tight, don't let me go,
we are the echoes down below.

[Verse 2]
Footsteps lost on empty streets,
rhythms sync to heartbeats,
whispers carried by the breeze,
dancing through the autumn leaves.
`;

const interaction = await client.interactions.create({
    model: 'lyria-3-pro-preview',
    input: prompt,
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3-pro-preview",
    "input": "Create a dreamy indie pop song with the following lyrics: ..."
  }'

Controlar o tempo e a estrutura

É possível especificar exatamente o que acontece em momentos específicos da música usando carimbos de data/hora. Isso é útil para controlar quando os instrumentos entram, quando as letras são entregues e como a música progride:

Python

prompt = """
[0:00 - 0:10] Intro: Begin with a soft lo-fi beat and muffled
              vinyl crackle.
[0:10 - 0:30] Verse 1: Add a warm Fender Rhodes piano melody
              and gentle vocals singing about a rainy morning.
[0:30 - 0:50] Chorus: Full band with upbeat drums and soaring
              synth leads. The lyrics are hopeful and uplifting.
[0:50 - 1:00] Outro: Fade out with the piano melody alone.
"""

interaction = client.interactions.create(
    model="lyria-3-pro-preview",
    input=prompt,
)

JavaScript

const prompt = `
[0:00 - 0:10] Intro: Begin with a soft lo-fi beat and muffled
              vinyl crackle.
[0:10 - 0:30] Verse 1: Add a warm Fender Rhodes piano melody
              and gentle vocals singing about a rainy morning.
[0:30 - 0:50] Chorus: Full band with upbeat drums and soaring
              synth leads. The lyrics are hopeful and uplifting.
[0:50 - 1:00] Outro: Fade out with the piano melody alone.
`;

const interaction = await client.interactions.create({
    model: 'lyria-3-pro-preview',
    input: prompt,
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3-pro-preview",
    "input": "[0:00 - 0:10] Intro: ..."
  }'

Gerar músicas instrumentais

Para música de fundo, trilhas sonoras de jogos ou qualquer caso de uso em que não sejam necessários vocais, peça ao modelo para produzir faixas apenas instrumentais:

Python

interaction = client.interactions.create(
    model="lyria-3-clip-preview",
    input="A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals.",
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3-clip-preview',
    input: 'A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals.',
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3-clip-preview",
    "input": "A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals."
  }'

Gerar músicas em diferentes idiomas

O Lyria 3 gera letras no idioma do seu comando. Para gerar uma música com letras em francês, escreva o comando nesse idioma. O modelo adapta o estilo vocal e a pronúncia para corresponder ao idioma.

Python

interaction = client.interactions.create(
    model="lyria-3-pro-preview",
    input="Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique.",
)

JavaScript

const interaction = await client.interactions.create({
    model: 'lyria-3-pro-preview',
    input: 'Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique.',
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "lyria-3-pro-preview",
    "input": "Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique."
  }'

Inteligência do modelo

O Lyria 3 analisa seu processo de comando em que o modelo usa a estrutura musical (introdução, verso, refrão, ponte etc.) com base no seu comando. Isso acontece antes da geração do áudio e garante a coerência estrutural e a musicalidade.

Guia de comandos

Quanto mais específico for o comando, melhores serão os resultados. Confira o que você pode incluir para orientar a geração:

  • Gênero: especifique um gênero ou uma mistura de gêneros (por exemplo, "lo-fi hip hop", "jazz fusion", "orquestra cinematográfica").
  • Instrumentos: nomeie instrumentos específicos (por exemplo, "piano Fender Rhodes", "guitarra slide", "bateria eletrônica TR-808").
  • BPM: defina o tempo (por exemplo, "120 BPM", "tempo lento em torno de 70 BPM").
  • Tonalidade/escala: especifique uma tonalidade musical (por exemplo, "em sol maior", "ré menor").
  • Clima e atmosfera: use adjetivos descritivos (por exemplo, "nostálgico", "agressivo", "etéreo", "onírico").
  • Estrutura: use tags como [Verse], [Chorus], [Bridge], [Intro], [Outro] ou marcações de tempo para controlar a progressão da música.
  • Duração: o modelo de clipe sempre produz clipes de 30 segundos. Para o modelo Pro, especifique a duração desejada no comando (por exemplo, "crie uma música de 2 minutos") ou use carimbos de data/hora para controlar a duração.

Exemplos de comandos

Confira alguns exemplos de comandos eficazes:

  • "A 30-second lofi hip hop beat with dusty vinyl crackle, mellow Rhodes piano chords, a slow boom-bap drum pattern at 85 BPM, and a jazzy upright bass line. Instrumental only."
  • "An upbeat, feel-good pop song in G major at 120 BPM with bright acoustic guitar strumming, claps, and warm vocal harmonies about a summer road trip."
  • "A dark, atmospheric trap beat at 140 BPM with heavy 808 bass, eerie synth pads, sharp hi-hats, and a haunting vocal sample. In D minor."

Práticas recomendadas

  • Itere primeiro com o Clipe. Use o modelo lyria-3-clip-preview mais rápido para testar comandos antes de gerar um texto completo com lyria-3-pro-preview.
  • Faça uma descrição específica. Comandos vagos produzem resultados genéricos. Mencione instrumentos, BPM, tom, clima e estrutura para ter o melhor resultado.
  • Use o mesmo idioma. Faça o comando no idioma em que você quer a letra.
  • Use tags de seção. As tags [Verse], [Chorus] e [Bridge] oferecem ao modelo uma estrutura clara para seguir.
  • Separe as letras das instruções. Ao fornecer letras personalizadas, separe-as claramente das instruções de direção musical.

Limitações

  • Segurança: todos os comandos são verificados por filtros de segurança. Os comandos que acionam os filtros serão bloqueados. Isso inclui comandos que pedem vozes de artistas específicos ou a geração de letras protegidas por direitos autorais.
  • Marca-d'água: todo o áudio gerado inclui uma marca-d'água de áudio do SynthID para identificação. Essa marca-d'água é imperceptível ao ouvido humano e não afeta a experiência de audição.
  • Edição multiturno: a geração de música é um processo de turno único. A edição iterativa ou o refinamento de um clipe gerado com vários comandos não é compatível com a versão atual do Lyria 3.
  • Duração: o modelo de clipe sempre gera clipes de 30 segundos. O modelo Pro gera músicas que duram alguns minutos. A duração exata pode ser influenciada pelo comando.
  • Determinismo: os resultados podem variar entre as chamadas, mesmo com o mesmo comando.

A seguir