使用 Lyria 3.5 生成音乐
Lyria 3.5 是 Google 的音乐生成型号系列,可通过 Gemini API 购买。使用 Lyria 3.5,您可以从文本提示或图像生成高质量的 44.1 kHz 立体声音频。这些模型提供结构连贯性,包括人声、定时歌词和完整的乐器安排。
Lyria 系列包括型号:
| 模型 | 型号编号 | 最适合 | 持续时间 | 输出 |
|---|---|---|---|---|
| Lyria 3 Clip | lyria-3-clip-preview | 短片、循环、预览 | 30 秒 | MP3 |
| Lyria 3.5 | lyria-3.5 | 包含主歌、副歌、桥段的完整歌曲 | 几分钟(可使用提示控制) | MP3 |
两种型号都可以使用新的 Interactions API,支持多模态输入(文本和图像),并生成 44.1 kHz 高保真立体声 音频。
生成音乐剪辑 #
Lyria 3 Clip 模型始终生成 30-第二 剪辑。要生成剪辑,请调用 interactions.create 带有文本提示的方法。响应始终包括生成的歌词和歌曲结构以及音频中的内容 steps 架构。
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}")
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) {
if (generatedAudio?.data) {
fs.writeFileSync('music.mp3', Buffer.from(generatedAudio.data, 'base64'));
}
}
const lyrics = interaction.output_text;
if (lyrics) {
console.log(`Lyrics:\n${lyrics}`);
}
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
Client client = new Client();
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3-clip-preview"))
.input(InteractionsInput.of("A short instrumental acoustic guitar piece."))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
if (interaction.outputAudio().isPresent() && interaction.outputAudio().get().data().isPresent()) {
byte[] audioBytes = Base64.getDecoder().decode(interaction.outputAudio().get().data().get());
Files.write(Paths.get("music.mp3"), audioBytes);
}
interaction.outputText().ifPresent(lyrics -> System.out.println("Lyrics:\n" + lyrics));
package main
import (
"context"
"encoding/base64"
"fmt"
"log"
"os"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3-clip-preview"),
Input: interactions.NewInteractionsInput("A short instrumental acoustic guitar piece."),
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputAudio != nil && res.Interaction.OutputAudio.Data != nil {
audioBytes, err := base64.StdEncoding.DecodeString(*res.Interaction.OutputAudio.Data)
if err != nil {
log.Fatal(err)
}
if err := os.WriteFile("music.mp3", audioBytes, 0644); err != nil {
log.Fatal(err)
}
}
if res.Interaction.OutputText != nil {
fmt.Printf("Lyrics:\n%s\n", *res.Interaction.OutputText)
}
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "Api-Revision: 2026-05-20" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
"model": "lyria-3-clip-preview",
"input": "A short instrumental acoustic guitar piece."
}'
gemini-api music "A short instrumental acoustic guitar piece." \
-m lyria-3-clip-preview \
--out music.mp3
您可以使用以下命令检索生成的音乐数据 interaction.output_audio 属性,返回最后生成的音频块。您还可以使用以下命令检索歌曲的歌词和结构 interaction.output_text 财产。
生成一首完整长度的歌曲 #
使用 lyria-3.5 模型来生成持续几分钟的完整长度的歌曲。 Pro 模型了解音乐结构,可以创作具有独特诗句、副歌和桥段的作品。您可以通过在提示中指定它来影响持续时间(例如,“创建 2 分钟的歌曲”)或使用 时间戳 定义结构。
interaction = client.interactions.create(
model="lyria-3.5",
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.",
)
const interaction = await client.interactions.create({
model: 'lyria-3.5',
input: 'A beautiful piano melody.',
});
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = new Client();
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(
InteractionsInput.of(
"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."))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
package main
import (
"context"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput(
"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.",
),
}),
})
if err != nil {
log.Fatal(err)
}
_ = res
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "Content-Type: application/json" \
-H "Api-Revision: 2026-05-20" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-d '{
"model": "lyria-3.5",
"input": "A beautiful piano melody."
}'
gemini-api music "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." \
-m lyria-3.5 \
--out song.mp3
选择输出格式 #
默认情况下,Lyria 3.5 型号生成音频 MP3 格式。对于Lyria 3.5,您还可以请求输出 WAV 格式通过设置 response_format.
interaction = client.interactions.create(
model="lyria-3.5",
input="A beautiful piano melody.",
response_format={"type": "audio"},
)
const interaction = await client.interactions.create({
model: 'lyria-3.5',
input: 'A beautiful piano melody.',
response_format: {
type: 'audio',
},
});
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.AudioResponseFormat;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.CreateModelInteractionResponseFormat;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ResponseFormat;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = new Client();
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(InteractionsInput.of("A beautiful piano melody."))
.responseFormat(
CreateModelInteractionResponseFormat.of(
ResponseFormat.of(AudioResponseFormat.builder().build())))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
package main
import (
"context"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput("A beautiful piano melody."),
ResponseFormat: genai.Ptr(interactions.NewCreateModelInteractionResponseFormat(
interactions.NewResponseFormat(interactions.AudioResponseFormat{}),
)),
}),
})
if err != nil {
log.Fatal(err)
}
_ = res
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Api-Revision: 2026-05-20" \
-H "Content-Type: application/json" \
-d '{
"model": "lyria-3.5",
"input": "A beautiful piano melody.",
"response_format": {
"type": "audio"
}
}'
gemini-api music "A beautiful piano melody." \
-m lyria-3.5 \
--body '{"response_format":{"mime_type":"audio/wav"}}' \
--out output.wav
解析响应 #
来自 Lyria 3.5 的响应包含多个内容块 steps 架构。交互返回一系列步骤,其中 model_output 步骤包含生成的内容。文本内容块包含生成的歌词或歌曲结构的 JSON 描述。内容块与 audio type 包含 base64 编码的音频数据。
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}")
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);
}
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
Client client = new Client();
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(InteractionsInput.of("A song about a starry night."))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
if (interaction.outputAudio().isPresent() && interaction.outputAudio().get().data().isPresent()) {
byte[] audioBytes = Base64.getDecoder().decode(interaction.outputAudio().get().data().get());
Files.write(Paths.get("output.mp3"), audioBytes);
}
if (interaction.outputText().isPresent()) {
System.out.println("Lyrics:\n" + interaction.outputText().get());
}
package main
import (
"context"
"encoding/base64"
"fmt"
"log"
"os"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput("A song about a starry night."),
}),
})
if err != nil {
log.Fatal(err)
}
if res.Interaction.OutputAudio != nil && res.Interaction.OutputAudio.Data != nil {
audioBytes, err := base64.StdEncoding.DecodeString(*res.Interaction.OutputAudio.Data)
if err != nil {
log.Fatal(err)
}
if err := os.WriteFile("output.mp3", audioBytes, 0644); err != nil {
log.Fatal(err)
}
}
if res.Interaction.OutputText != nil {
fmt.Printf("Lyrics:\n%s\n", *res.Interaction.OutputText)
}
}
curl ... | jq -r '.steps[] | select(.type=="model_output") | .content[] | select(.type=="audio") | .data' | base64 -d > output.mp3
歌词和音乐交织 #
由于 Lyria 3.5 的输出很复杂,包含用于生成歌词(文本)和歌曲本身(音频)的单独步骤和块,因此便利属性提供了快速且推荐的快捷方式。
但是,如果您想要对服务器返回的步骤的原始时间线进行完全的编程控制(例如在收到单个内容块时对其进行记录),您可以手动迭代 steps 相反:
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)
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);
}
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.AudioContent;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ModelOutputStep;
import com.google.genai.gaos.models.interactions.Step;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
Client client = new Client();
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(InteractionsInput.of("A song about a starry night."))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
List<String> lyrics = new ArrayList<>();
byte[] audioData = null;
if (interaction.steps().isPresent()) {
for (Step step : interaction.steps().get()) {
if (step instanceof ModelOutputStep) {
ModelOutputStep outputStep = (ModelOutputStep) step;
if (outputStep.content().isPresent()) {
for (Content contentBlock : outputStep.content().get()) {
if (contentBlock instanceof AudioContent) {
AudioContent audioBlock = (AudioContent) contentBlock;
if (audioBlock.data().isPresent()) {
audioData = Base64.getDecoder().decode(audioBlock.data().get());
}
} else if (contentBlock instanceof TextContent) {
TextContent textBlock = (TextContent) contentBlock;
textBlock.text().ifPresent(lyrics::add);
}
}
}
}
}
}
if (!lyrics.isEmpty()) {
System.out.println("Lyrics:\n" + String.join("\n", lyrics));
}
if (audioData != null) {
Files.write(Paths.get("output.mp3"), audioData);
}
package main
import (
"context"
"encoding/base64"
"fmt"
"log"
"os"
"strings"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput("A song about a starry night."),
}),
})
if err != nil {
log.Fatal(err)
}
var lyrics []string
var audioData []byte
for _, step := range res.Interaction.Steps {
if step.ModelOutputStep != nil {
for _, contentBlock := range step.ModelOutputStep.Content {
if contentBlock.AudioContent != nil && contentBlock.AudioContent.Data != nil {
decoded, err := base64.StdEncoding.DecodeString(*contentBlock.AudioContent.Data)
if err != nil {
log.Fatal(err)
}
audioData = decoded
} else if contentBlock.TextContent != nil {
lyrics = append(lyrics, contentBlock.TextContent.Text)
}
}
}
}
if len(lyrics) > 0 {
fmt.Printf("Lyrics:\n%s\n", strings.Join(lyrics, "\n"))
}
if audioData != nil {
if err := os.WriteFile("output.mp3", audioData, 0644); err != nil {
log.Fatal(err)
}
}
}
从图像生成音乐 #
Lyria 3.5 支持多模态输入 - 您最多可以提供 10 图像 旁边的文本提示 input 列表和模型将根据视觉内容创作音乐。
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.5",
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,
},
],
)
import * as fs from "fs";
const imageBytes = fs.readFileSync("desert_sunset.jpg").toString("base64");
const interaction = await client.interactions.create({
model: "lyria-3.5",
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,
},
],
});
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.Content;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.ImageContent;
import com.google.genai.gaos.models.interactions.ImageContentMimeType;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.TextContent;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Base64;
import java.util.List;
Client client = new Client();
byte[] imageBytes = Files.readAllBytes(Paths.get("desert_sunset.jpg"));
String imageB64 = Base64.getEncoder().encodeToString(imageBytes);
Content textContent =
TextContent.builder()
.text("An atmospheric ambient track inspired by the mood and colors in this image.")
.build();
Content imageContent =
ImageContent.builder()
.mimeType(ImageContentMimeType.IMAGE_JPEG)
.data(imageB64)
.build();
List<Content> contents = Arrays.asList(textContent, imageContent);
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(InteractionsInput.ofContent(contents))
.build();
Interaction response =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
package main
import (
"context"
"encoding/base64"
"log"
"os"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
imageBytes, err := os.ReadFile("desert_sunset.jpg")
if err != nil {
log.Fatal(err)
}
imageB64 := base64.StdEncoding.EncodeToString(imageBytes)
contents := []interactions.Content{
interactions.NewContent(interactions.TextContent{
Text: "An atmospheric ambient track inspired by the mood and colors in this image.",
}),
interactions.NewContent(interactions.ImageContent{
MimeType: interactions.ImageContentMimeTypeImageJpeg.ToPointer(),
Data: genai.Ptr(imageB64),
}),
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput(contents),
}),
})
if err != nil {
log.Fatal(err)
}
_ = res
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Api-Revision: 2026-05-20" \
-H 'Content-Type: application/json' \
-d '{
"model": "lyria-3.5",
"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="}
]
}'
提供自定义歌词 #
您可以编写自己的歌词并将其包含在提示中。使用部分标签,例如 [Verse], [Chorus], 和 [Bridge] 帮助模型理解歌曲结构:
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.5",
input=prompt,
)
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.5',
input: prompt,
});
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = new Client();
String prompt =
"Create a dreamy indie pop song with the following lyrics:\n\n"
+ "[Verse 1]\n"
+ "Walking through the neon glow,\n"
+ "city lights reflect below,\n"
+ "every shadow tells a story,\n"
+ "every corner, fading glory.\n\n"
+ "[Chorus]\n"
+ "We are the echoes in the night,\n"
+ "burning brighter than the light,\n"
+ "hold on tight, don't let me go,\n"
+ "we are the echoes down below.\n\n"
+ "[Verse 2]\n"
+ "Footsteps lost on empty streets,\n"
+ "rhythms sync to heartbeats,\n"
+ "whispers carried by the breeze,\n"
+ "dancing through the autumn leaves.";
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(InteractionsInput.of(prompt))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
package main
import (
"context"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
prompt := "Create a dreamy indie pop song with the following lyrics:\n\n" +
"[Verse 1]\n" +
"Walking through the neon glow,\n" +
"city lights reflect below,\n" +
"every shadow tells a story,\n" +
"every corner, fading glory.\n\n" +
"[Chorus]\n" +
"We are the echoes in the night,\n" +
"burning brighter than the light,\n" +
"hold on tight, don't let me go,\n" +
"we are the echoes down below.\n\n" +
"[Verse 2]\n" +
"Footsteps lost on empty streets,\n" +
"rhythms sync to heartbeats,\n" +
"whispers carried by the breeze,\n" +
"dancing through the autumn leaves."
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput(prompt),
}),
})
if err != nil {
log.Fatal(err)
}
_ = res
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Api-Revision: 2026-05-20" \
-H "Content-Type: application/json" \
-d '{
"model": "lyria-3.5",
"input": "Create a dreamy indie pop song with the following lyrics: ..."
}'
cat > lyrics.txt <<'EOF'
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.
EOF
gemini-api music -f lyrics.txt --out song.mp3
控制时序和结构 #
您可以使用时间戳准确指定歌曲中特定时刻发生的情况。这对于控制乐器何时进入、歌词何时传送以及歌曲如何进行非常有用:
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.5",
input=prompt,
)
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.5',
input: prompt,
});
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = new Client();
String prompt =
"[0:00 - 0:10] Intro: Begin with a soft lo-fi beat and muffled vinyl crackle.\n"
+ "[0:10 - 0:30] Verse 1: Add a warm Fender Rhodes piano melody and gentle vocals singing about a rainy morning.\n"
+ "[0:30 - 0:50] Chorus: Full band with upbeat drums and soaring synth leads. The lyrics are hopeful and uplifting.\n"
+ "[0:50 - 1:00] Outro: Fade out with the piano melody alone.";
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(InteractionsInput.of(prompt))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
package main
import (
"context"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
prompt := "[0:00 - 0:10] Intro: Begin with a soft lo-fi beat and muffled vinyl crackle.\n" +
"[0:10 - 0:30] Verse 1: Add a warm Fender Rhodes piano melody and gentle vocals singing about a rainy morning.\n" +
"[0:30 - 0:50] Chorus: Full band with upbeat drums and soaring synth leads. The lyrics are hopeful and uplifting.\n" +
"[0:50 - 1:00] Outro: Fade out with the piano melody alone."
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput(prompt),
}),
})
if err != nil {
log.Fatal(err)
}
_ = res
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Api-Revision: 2026-05-20" \
-H "Content-Type: application/json" \
-d '{
"model": "lyria-3.5",
"input": "[0:00 - 0:10] Intro: ..."
}'
生成乐器曲目 #
对于背景音乐、游戏配乐或任何不需要人声的用例,您可以提示模型生成纯乐器曲目:
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.",
)
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.',
});
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = new Client();
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3-clip-preview"))
.input(
InteractionsInput.of(
"A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals."))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
package main
import (
"context"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3-clip-preview"),
Input: interactions.NewInteractionsInput(
"A bright chiptune melody in C Major, retro 8-bit video game style. Instrumental only, no vocals.",
),
}),
})
if err != nil {
log.Fatal(err)
}
_ = res
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Api-Revision: 2026-05-20" \
-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."
}'
生成不同语言的音乐 #
Lyria 3.5 以您的提示语言生成歌词。要生成带有法语歌词的歌曲,请用法语编写提示。该模型会调整其声音风格和发音以匹配语言。
interaction = client.interactions.create(
model="lyria-3.5",
input="Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique.",
)
const interaction = await client.interactions.create({
model: 'lyria-3.5',
input: 'Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique.',
});
import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
Client client = new Client();
CreateModelInteraction params =
CreateModelInteraction.builder()
.model(Model.of("lyria-3.5"))
.input(
InteractionsInput.of(
"Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique."))
.build();
Interaction interaction =
client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();
package main
import (
"context"
"log"
"google.golang.org/genai"
"google.golang.org/genai/interactions/models/interactions"
"google.golang.org/genai/interactions/models/operations"
)
func main() {
ctx := context.Background()
client, err := genai.NewClient(ctx, nil)
if err != nil {
log.Fatal(err)
}
res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
Model: interactions.Model("lyria-3.5"),
Input: interactions.NewInteractionsInput(
"Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique.",
),
}),
})
if err != nil {
log.Fatal(err)
}
_ = res
}
curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
-H "x-goog-api-key: $GEMINI_API_KEY" \
-H "Api-Revision: 2026-05-20" \
-H "Content-Type: application/json" \
-d '{
"model": "lyria-3.5",
"input": "Crée une chanson pop romantique en français sur un coucher de soleil à Paris. Utilise du piano et de la guitare acoustique."
}'
模型智能 #
Lyria 3.5 分析您的提示过程,其中模型根据您的提示通过音乐结构(前奏、主歌、合唱、桥段等)进行推理。这是在生成音频之前发生的,并确保结构的连贯性和音乐性。
重要提示:虽然 Lyria 3.5 在内部使用提示重写器来解释自然语言指令,但它确实 不 向用户公开中间的“思想”块或思想签名。
提示指南 #
要了解如何针对音乐流派、乐器、歌曲结构、自定义歌词和声音表达风格制作有效的提示,请参阅 Lyria 提示指南.
最佳实践 #
首先使用 Clip 进行迭代。 使用速度越快
lyria-3-clip-preview模型在提交全长生成之前尝试提示lyria-3.5.具体一点。 模糊的提示会产生一般的结果。提及乐器、BPM、调、情绪和结构以获得最佳输出。
匹配您的语言。 以您想要歌词的语言进行提示。
使用部分标签。
[Verse],[Chorus],[Bridge]标签为模型提供了清晰的结构以供遵循。将歌词与说明分开。 提供自定义歌词时,请将它们与您的音乐方向说明明确分开。
限制 #
安全:所有提示均经过安全过滤器检查。触发过滤器的提示将被阻止。这包括请求特定艺术家声音或生成受版权保护的歌词的提示。
水印:所有生成的音频都包含 SynthID 音频水印 用于识别。该水印人耳无法察觉,不会影响聆听体验。
多轮编辑:音乐生成是一个单轮过程。当前版本的 Lyria 3.5 不支持通过多个提示迭代编辑或优化生成的剪辑。
长度:剪辑模型始终生成 30 秒剪辑。 Pro 模型生成的歌曲持续几分钟;确切的持续时间可以通过您的提示来影响。
决定论:即使提示相同,不同调用的结果也可能有所不同。