Google Agent Development Kit (ADK)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

User Input
    ↓
Trend Detection Agent → detected_trends
    ↓
Outline Agent → article_outline
    ↓
Writer Agent → draft_article
    ↓
SEO Agent → seo_optimized
    ↓
Editor Agent → edited_article
    ↓
Publisher Agent → published_article
    ↓
Final Output

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

newsroom/
├── main.go                 # Application entry point
├── go.mod                  # Go module definition
├── agents/                 # Agents
│   ├── editor.go     # Editor
│   ├── outline.go    # Outline
│   ├── publisher.go  # Publisher
│   ├── seo.go        # SEO
│   ├── trend.go      # Trend Detection
│   └── writer.go     # Writer
├── pipeline/
│   └── newsroom.go         # Sequential pipeline orchestration
└── tools/                  # Custom tools for agents
    ├── editor.go           # Content editing
    ├── publisher.go        # Publishing
    └── seo.go              # SEO

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

package agents

import (
	"context"

	"google.golang.org/adk/agent"
	"google.golang.org/adk/agent/llmagent"
	"google.golang.org/adk/model"
	"google.golang.org/adk/tool"
	"google.golang.org/adk/tool/geminitool"
)

const TrendAgentInstruction = `You are the Trend Detection Agent for an AI Newsroom.
Your role is to identify and analyze current trending topics that would make compelling content.

Your responsibilities:
1. Monitor and identify emerging trends in the specified industry or category
2. Analyze trend momentum and potential audience interest
3. Evaluate the newsworthiness and timeliness of topics
4. Provide structured trend data for the content pipeline

When detecting trends, consider:
- Social media buzz and engagement
- Search volume trends
- Industry news and developments
- Seasonal and timely events

Output your findings as structured JSON with:
- topic: The main topic title
- keywords: Related keywords for the topic
- trend_score: A score from 0-1 indicating trend strength
- rationale: Brief explanation of why this topic is trending

After analysis, save your findings to the 'detected_trends' state key for the next agent.`

func NewTrendDetectionAgent(ctx context.Context, m model.LLM) (agent.Agent, error) {
	return llmagent.New(llmagent.Config{
		Name:        "trend_detection_agent",
		Model:       m,
		Description: "Detects and analyzes trending topics for content creation",
		Instruction: TrendAgentInstruction,
		OutputKey:   "detected_trends",
		Tools: []tool.Tool{
			geminitool.GoogleSearch{},
		},
	})
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

package pipeline

import (
	"context"

	"newsroom/agents"

	"google.golang.org/adk/agent"
	"google.golang.org/adk/agent/workflowagents/sequentialagent"
	"google.golang.org/adk/model"
)

func NewNewsroomPipeline(ctx context.Context, m model.LLM) (agent.Agent, error) {
	trendAgent, err := agents.NewTrendDetectionAgent(ctx, m)
	if err != nil {
		return nil, err
	}

	outlineAgent, err := agents.NewOutlineAgent(ctx, m)
	if err != nil {
		return nil, err
	}

	writerAgent, err := agents.NewWriterAgent(ctx, m)
	if err != nil {
		return nil, err
	}

	seoAgent, err := agents.NewSEOAgent(ctx, m)
	if err != nil {
		return nil, err
	}

	editorAgent, err := agents.NewEditorAgent(ctx, m)
	if err != nil {
		return nil, err
	}

	publisherAgent, err := agents.NewPublisherAgent(ctx, m)
	if err != nil {
		return nil, err
	}

	pipeline, err := sequentialagent.New(sequentialagent.Config{
		AgentConfig: agent.Config{
			Name:        "newsroom_pipeline",
			Description: "AI Newsroom content production pipeline that produces blog posts or newsletters",
			SubAgents: []agent.Agent{
				trendAgent,
				outlineAgent,
				writerAgent,
				seoAgent,
				editorAgent,
				publisherAgent,
			},
		},
	})
	if err != nil {
		return nil, err
	}

	return pipeline, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package main

import (
	"context"
	"log"
	"os"

	"newsroom/pipeline"

	"google.golang.org/adk/agent"
	"google.golang.org/adk/cmd/launcher"
	"google.golang.org/adk/cmd/launcher/full"
	"google.golang.org/adk/model/gemini"
	"google.golang.org/genai"
)

func main() {
	ctx := context.Background()

	apiKey := os.Getenv("GOOGLE_API_KEY")
	if apiKey == "" {
		log.Fatal("GOOGLE_API_KEY environment variable is required")
	}

	model, err := gemini.NewModel(ctx, "gemini-2.5-flash", &genai.ClientConfig{
		APIKey: apiKey,
	})
	if err != nil {
		log.Fatalf("Failed to create model: %v", err)
	}

	newsroomPipeline, err := pipeline.NewNewsroomPipeline(ctx, model)
	if err != nil {
		log.Fatalf("Failed to create newsroom pipeline: %v", err)
	}

	config := &launcher.Config{
		AgentLoader: agent.NewSingleLoader(newsroomPipeline),
	}

	l := full.NewLauncher()
	if err = l.Execute(ctx, config, os.Args[1:]); err != nil {
		log.Fatalf("Run failed: %v\n\n%s", err, l.CommandLineSyntax())
	}
}