pub struct Content {
pub parts: Vec<Part>,
pub role: Option<Role>,
}Expand description
Content of a message
Fields§
§parts: Vec<Part>Parts of the content
role: Option<Role>Role of the content
Implementations§
Source§impl Content
impl Content
Sourcepub fn function_call(function_call: FunctionCall) -> Self
pub fn function_call(function_call: FunctionCall) -> Self
Create a new content with a function call
Examples found in repository?
examples/google_search_with_functions.rs (line 98)
9async fn main() -> Result<(), Box<dyn std::error::Error>> {
10 // Get API key from environment variable
11 let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");
12
13 // Create client
14 let client = Gemini::new(api_key);
15
16 println!("--- Google Search with Function Calling example ---");
17
18 // Define a calculator function
19 let calculate = FunctionDeclaration::new(
20 "calculate",
21 "Perform a calculation",
22 FunctionParameters::object()
23 .with_property(
24 "operation",
25 PropertyDetails::enum_type(
26 "The mathematical operation to perform",
27 ["add", "subtract", "multiply", "divide"],
28 ),
29 true,
30 )
31 .with_property("a", PropertyDetails::number("The first number"), true)
32 .with_property("b", PropertyDetails::number("The second number"), true),
33 );
34
35 // Create function tool
36 let function_tool = Tool::new(calculate);
37
38 // Create a request with both tools
39 let response = client
40 .generate_content()
41 .with_user_message("What is the current Google stock price multiplied by 2?")
42 .with_tool(function_tool.clone())
43 .with_function_calling_mode(FunctionCallingMode::Any)
44 .execute()
45 .await?;
46
47 // Check if there are function calls
48 if let Some(function_call) = response.function_calls().first() {
49 println!(
50 "Function call: {} with args: {}",
51 function_call.name, function_call.args
52 );
53
54 // Handle the calculate function
55 if function_call.name == "calculate" {
56 let operation: String = function_call.get("operation")?;
57 let a: f64 = function_call.get("a")?;
58 let b: f64 = function_call.get("b")?;
59
60 println!("Calculation: {} {} {}", a, operation, b);
61
62 let result = match operation.as_str() {
63 "add" => a + b,
64 "subtract" => a - b,
65 "multiply" => a * b,
66 "divide" => a / b,
67 _ => panic!("Unknown operation"),
68 };
69
70 let function_response = json!({
71 "result": result,
72 })
73 .to_string();
74
75 // Based on the curl example, we need to structure the conversation properly:
76 // 1. A user message with the original query
77 // 2. A model message containing the function call
78 // 3. A user message containing the function response
79
80 // Construct conversation following the exact curl pattern
81 let mut conversation = client.generate_content();
82
83 // 1. Add user message with original query
84 conversation = conversation
85 .with_user_message("What is the current Google stock price multiplied by 2?");
86
87 // 2. Create model message with function call
88 let model_function_call = FunctionCall::new(
89 "calculate",
90 json!({
91 "operation": operation,
92 "a": a,
93 "b": b
94 }),
95 );
96
97 // Create model content with function call
98 let model_content = Content::function_call(model_function_call).with_role(Role::Model);
99
100 // Add as model message
101 let model_message = Message {
102 content: model_content,
103 role: Role::Model,
104 };
105 conversation = conversation.with_message(model_message);
106
107 // 3. Add user message with function response
108 conversation =
109 conversation.with_function_response_str("calculate", function_response)?;
110
111 // Execute the request
112 let final_response = conversation.execute().await?;
113
114 println!("Final response: {}", final_response.text());
115 } else {
116 println!("Unknown function call: {}", function_call.name);
117 }
118 } else {
119 println!("No function calls in the response.");
120 println!("Direct response: {}", response.text());
121 }
122
123 Ok(())
124}More examples
examples/tools.rs (line 121)
9async fn main() -> Result<(), Box<dyn std::error::Error>> {
10 // Get API key from environment variable
11 let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");
12
13 // Create client
14 let client = Gemini::new(api_key);
15
16 println!("--- Tools example with multiple functions ---");
17
18 // Define a weather function
19 let get_weather = FunctionDeclaration::new(
20 "get_weather",
21 "Get the current weather for a location",
22 FunctionParameters::object()
23 .with_property(
24 "location",
25 PropertyDetails::string("The city and state, e.g., San Francisco, CA"),
26 true,
27 )
28 .with_property(
29 "unit",
30 PropertyDetails::enum_type("The unit of temperature", ["celsius", "fahrenheit"]),
31 false,
32 ),
33 );
34
35 // Define a calculator function
36 let calculate = FunctionDeclaration::new(
37 "calculate",
38 "Perform a calculation",
39 FunctionParameters::object()
40 .with_property(
41 "operation",
42 PropertyDetails::enum_type(
43 "The mathematical operation to perform",
44 ["add", "subtract", "multiply", "divide"],
45 ),
46 true,
47 )
48 .with_property("a", PropertyDetails::number("The first number"), true)
49 .with_property("b", PropertyDetails::number("The second number"), true),
50 );
51
52 // Create a tool with multiple functions
53 let tool = Tool::with_functions(vec![get_weather, calculate]);
54
55 // Create a request with tool functions
56 let response = client
57 .generate_content()
58 .with_system_prompt(
59 "You are a helpful assistant that can check weather and perform calculations.",
60 )
61 .with_user_message("What's 42 times 12?")
62 .with_tool(tool)
63 .with_function_calling_mode(FunctionCallingMode::Any)
64 .execute()
65 .await?;
66
67 // Process function calls
68 if let Some(function_call) = response.function_calls().first() {
69 println!(
70 "Function call: {} with args: {}",
71 function_call.name, function_call.args
72 );
73
74 // Handle different function calls
75 match function_call.name.as_str() {
76 "calculate" => {
77 let operation: String = function_call.get("operation")?;
78 let a: f64 = function_call.get("a")?;
79 let b: f64 = function_call.get("b")?;
80
81 println!("Calculation: {} {} {}", a, operation, b);
82
83 let result = match operation.as_str() {
84 "add" => a + b,
85 "subtract" => a - b,
86 "multiply" => a * b,
87 "divide" => a / b,
88 _ => panic!("Unknown operation"),
89 };
90
91 let function_response = json!({
92 "result": result,
93 })
94 .to_string();
95
96 // Based on the curl example, we need to structure the conversation properly:
97 // 1. A user message with the original query
98 // 2. A model message containing the function call
99 // 3. A user message containing the function response
100
101 // Construct conversation following the exact curl pattern
102 let mut conversation = client.generate_content();
103
104 // 1. Add user message with original query and system prompt
105 conversation = conversation
106 .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
107 .with_user_message("What's 42 times 12?");
108
109 // 2. Create model message with function call
110 let model_function_call = FunctionCall::new(
111 "calculate",
112 json!({
113 "operation": operation,
114 "a": a,
115 "b": b
116 }),
117 );
118
119 // Create model content with function call
120 let model_content =
121 Content::function_call(model_function_call).with_role(Role::Model);
122
123 // Add as model message
124 let model_message = Message {
125 content: model_content,
126 role: Role::Model,
127 };
128 conversation = conversation.with_message(model_message);
129
130 // 3. Add user message with function response
131 conversation =
132 conversation.with_function_response_str("calculate", function_response)?;
133
134 // Execute the request
135 let final_response = conversation.execute().await?;
136
137 println!("Final response: {}", final_response.text());
138 }
139 "get_weather" => {
140 let location: String = function_call.get("location")?;
141 let unit = function_call
142 .get::<String>("unit")
143 .unwrap_or_else(|_| String::from("celsius"));
144
145 println!("Weather request for: {}, Unit: {}", location, unit);
146
147 let weather_response = json!({
148 "temperature": 22,
149 "unit": unit,
150 "condition": "sunny"
151 })
152 .to_string();
153
154 // Based on the curl example, we need to structure the conversation properly:
155 // 1. A user message with the original query
156 // 2. A model message containing the function call
157 // 3. A user message containing the function response
158
159 // Construct conversation following the exact curl pattern
160 let mut conversation = client.generate_content();
161
162 // 1. Add user message with original query and system prompt
163 conversation = conversation
164 .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
165 .with_user_message("What's 42 times 12?");
166
167 // 2. Create model message with function call
168 let model_function_call = FunctionCall::new(
169 "get_weather",
170 json!({
171 "location": location,
172 "unit": unit
173 }),
174 );
175
176 // Create model content with function call
177 let model_content =
178 Content::function_call(model_function_call).with_role(Role::Model);
179
180 // Add as model message
181 let model_message = Message {
182 content: model_content,
183 role: Role::Model,
184 };
185 conversation = conversation.with_message(model_message);
186
187 // 3. Add user message with function response
188 conversation =
189 conversation.with_function_response_str("get_weather", weather_response)?;
190
191 // Execute the request
192 let final_response = conversation.execute().await?;
193
194 println!("Final response: {}", final_response.text());
195 }
196 _ => println!("Unknown function"),
197 }
198 } else {
199 println!("No function calls in the response.");
200 println!("Response: {}", response.text());
201 }
202
203 Ok(())
204}Sourcepub fn function_response(function_response: FunctionResponse) -> Self
pub fn function_response(function_response: FunctionResponse) -> Self
Create a new content with a function response
Sourcepub fn function_response_json(name: impl Into<String>, response: Value) -> Self
pub fn function_response_json(name: impl Into<String>, response: Value) -> Self
Create a new content with a function response from name and JSON value
Sourcepub fn with_role(self, role: Role) -> Self
pub fn with_role(self, role: Role) -> Self
Add a role to this content
Examples found in repository?
examples/advanced.rs (line 80)
9async fn main() -> Result<(), Box<dyn std::error::Error>> {
10 let api_key = env::var("GEMINI_API_KEY")?;
11
12 // Create client
13 let client = Gemini::new(api_key);
14
15 // Define a weather function
16 let get_weather = FunctionDeclaration::new(
17 "get_weather",
18 "Get the current weather for a location",
19 FunctionParameters::object()
20 .with_property(
21 "location",
22 PropertyDetails::string("The city and state, e.g., San Francisco, CA"),
23 true,
24 )
25 .with_property(
26 "unit",
27 PropertyDetails::enum_type("The unit of temperature", ["celsius", "fahrenheit"]),
28 false,
29 ),
30 );
31
32 // Create a request with function calling
33 println!("Sending function call request...");
34 let response = client
35 .generate_content()
36 .with_user_message("What's the weather like in Tokyo right now?")
37 .with_function(get_weather)
38 .with_function_calling_mode(FunctionCallingMode::Any)
39 .execute()
40 .await?;
41
42 // Check if there are function calls
43 if let Some(function_call) = response.function_calls().first() {
44 println!(
45 "Function call received: {} with args: {}",
46 function_call.name, function_call.args
47 );
48
49 // Get parameters from the function call
50 let location: String = function_call.get("location")?;
51 let unit = function_call
52 .get::<String>("unit")
53 .unwrap_or_else(|_| String::from("celsius"));
54
55 println!("Location: {}, Unit: {}", location, unit);
56
57 // Simulate function execution (in a real app, this would call a weather API)
58 // Create a JSON response object
59 let weather_response = serde_json::json!({
60 "temperature": 22,
61 "unit": unit,
62 "condition": "sunny",
63 "location": location
64 });
65
66 // Continue the conversation with the function result
67 // We need to replay the entire conversation with the function response
68 println!("Sending function response...");
69
70 // First, need to recreate the original prompt and the model's response
71 let mut final_request = client
72 .generate_content()
73 .with_user_message("What's the weather like in Tokyo right now?");
74
75 // Add the function call from the model's response
76 let mut call_content = Content::default();
77 call_content.parts.push(Part::FunctionCall {
78 function_call: (*function_call).clone(),
79 });
80 let call_content = call_content.with_role(Role::Model);
81 final_request.contents.push(call_content);
82
83 // Now add the function response using the JSON value
84 final_request = final_request.with_function_response("get_weather", weather_response);
85
86 // Execute the request
87 let final_response = final_request.execute().await?;
88
89 println!("Final response: {}", final_response.text());
90 } else {
91 println!("No function calls in the response.");
92 println!("Response text: {}", response.text());
93 }
94
95 Ok(())
96}More examples
examples/google_search_with_functions.rs (line 98)
9async fn main() -> Result<(), Box<dyn std::error::Error>> {
10 // Get API key from environment variable
11 let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");
12
13 // Create client
14 let client = Gemini::new(api_key);
15
16 println!("--- Google Search with Function Calling example ---");
17
18 // Define a calculator function
19 let calculate = FunctionDeclaration::new(
20 "calculate",
21 "Perform a calculation",
22 FunctionParameters::object()
23 .with_property(
24 "operation",
25 PropertyDetails::enum_type(
26 "The mathematical operation to perform",
27 ["add", "subtract", "multiply", "divide"],
28 ),
29 true,
30 )
31 .with_property("a", PropertyDetails::number("The first number"), true)
32 .with_property("b", PropertyDetails::number("The second number"), true),
33 );
34
35 // Create function tool
36 let function_tool = Tool::new(calculate);
37
38 // Create a request with both tools
39 let response = client
40 .generate_content()
41 .with_user_message("What is the current Google stock price multiplied by 2?")
42 .with_tool(function_tool.clone())
43 .with_function_calling_mode(FunctionCallingMode::Any)
44 .execute()
45 .await?;
46
47 // Check if there are function calls
48 if let Some(function_call) = response.function_calls().first() {
49 println!(
50 "Function call: {} with args: {}",
51 function_call.name, function_call.args
52 );
53
54 // Handle the calculate function
55 if function_call.name == "calculate" {
56 let operation: String = function_call.get("operation")?;
57 let a: f64 = function_call.get("a")?;
58 let b: f64 = function_call.get("b")?;
59
60 println!("Calculation: {} {} {}", a, operation, b);
61
62 let result = match operation.as_str() {
63 "add" => a + b,
64 "subtract" => a - b,
65 "multiply" => a * b,
66 "divide" => a / b,
67 _ => panic!("Unknown operation"),
68 };
69
70 let function_response = json!({
71 "result": result,
72 })
73 .to_string();
74
75 // Based on the curl example, we need to structure the conversation properly:
76 // 1. A user message with the original query
77 // 2. A model message containing the function call
78 // 3. A user message containing the function response
79
80 // Construct conversation following the exact curl pattern
81 let mut conversation = client.generate_content();
82
83 // 1. Add user message with original query
84 conversation = conversation
85 .with_user_message("What is the current Google stock price multiplied by 2?");
86
87 // 2. Create model message with function call
88 let model_function_call = FunctionCall::new(
89 "calculate",
90 json!({
91 "operation": operation,
92 "a": a,
93 "b": b
94 }),
95 );
96
97 // Create model content with function call
98 let model_content = Content::function_call(model_function_call).with_role(Role::Model);
99
100 // Add as model message
101 let model_message = Message {
102 content: model_content,
103 role: Role::Model,
104 };
105 conversation = conversation.with_message(model_message);
106
107 // 3. Add user message with function response
108 conversation =
109 conversation.with_function_response_str("calculate", function_response)?;
110
111 // Execute the request
112 let final_response = conversation.execute().await?;
113
114 println!("Final response: {}", final_response.text());
115 } else {
116 println!("Unknown function call: {}", function_call.name);
117 }
118 } else {
119 println!("No function calls in the response.");
120 println!("Direct response: {}", response.text());
121 }
122
123 Ok(())
124}examples/tools.rs (line 121)
9async fn main() -> Result<(), Box<dyn std::error::Error>> {
10 // Get API key from environment variable
11 let api_key = env::var("GEMINI_API_KEY").expect("GEMINI_API_KEY environment variable not set");
12
13 // Create client
14 let client = Gemini::new(api_key);
15
16 println!("--- Tools example with multiple functions ---");
17
18 // Define a weather function
19 let get_weather = FunctionDeclaration::new(
20 "get_weather",
21 "Get the current weather for a location",
22 FunctionParameters::object()
23 .with_property(
24 "location",
25 PropertyDetails::string("The city and state, e.g., San Francisco, CA"),
26 true,
27 )
28 .with_property(
29 "unit",
30 PropertyDetails::enum_type("The unit of temperature", ["celsius", "fahrenheit"]),
31 false,
32 ),
33 );
34
35 // Define a calculator function
36 let calculate = FunctionDeclaration::new(
37 "calculate",
38 "Perform a calculation",
39 FunctionParameters::object()
40 .with_property(
41 "operation",
42 PropertyDetails::enum_type(
43 "The mathematical operation to perform",
44 ["add", "subtract", "multiply", "divide"],
45 ),
46 true,
47 )
48 .with_property("a", PropertyDetails::number("The first number"), true)
49 .with_property("b", PropertyDetails::number("The second number"), true),
50 );
51
52 // Create a tool with multiple functions
53 let tool = Tool::with_functions(vec![get_weather, calculate]);
54
55 // Create a request with tool functions
56 let response = client
57 .generate_content()
58 .with_system_prompt(
59 "You are a helpful assistant that can check weather and perform calculations.",
60 )
61 .with_user_message("What's 42 times 12?")
62 .with_tool(tool)
63 .with_function_calling_mode(FunctionCallingMode::Any)
64 .execute()
65 .await?;
66
67 // Process function calls
68 if let Some(function_call) = response.function_calls().first() {
69 println!(
70 "Function call: {} with args: {}",
71 function_call.name, function_call.args
72 );
73
74 // Handle different function calls
75 match function_call.name.as_str() {
76 "calculate" => {
77 let operation: String = function_call.get("operation")?;
78 let a: f64 = function_call.get("a")?;
79 let b: f64 = function_call.get("b")?;
80
81 println!("Calculation: {} {} {}", a, operation, b);
82
83 let result = match operation.as_str() {
84 "add" => a + b,
85 "subtract" => a - b,
86 "multiply" => a * b,
87 "divide" => a / b,
88 _ => panic!("Unknown operation"),
89 };
90
91 let function_response = json!({
92 "result": result,
93 })
94 .to_string();
95
96 // Based on the curl example, we need to structure the conversation properly:
97 // 1. A user message with the original query
98 // 2. A model message containing the function call
99 // 3. A user message containing the function response
100
101 // Construct conversation following the exact curl pattern
102 let mut conversation = client.generate_content();
103
104 // 1. Add user message with original query and system prompt
105 conversation = conversation
106 .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
107 .with_user_message("What's 42 times 12?");
108
109 // 2. Create model message with function call
110 let model_function_call = FunctionCall::new(
111 "calculate",
112 json!({
113 "operation": operation,
114 "a": a,
115 "b": b
116 }),
117 );
118
119 // Create model content with function call
120 let model_content =
121 Content::function_call(model_function_call).with_role(Role::Model);
122
123 // Add as model message
124 let model_message = Message {
125 content: model_content,
126 role: Role::Model,
127 };
128 conversation = conversation.with_message(model_message);
129
130 // 3. Add user message with function response
131 conversation =
132 conversation.with_function_response_str("calculate", function_response)?;
133
134 // Execute the request
135 let final_response = conversation.execute().await?;
136
137 println!("Final response: {}", final_response.text());
138 }
139 "get_weather" => {
140 let location: String = function_call.get("location")?;
141 let unit = function_call
142 .get::<String>("unit")
143 .unwrap_or_else(|_| String::from("celsius"));
144
145 println!("Weather request for: {}, Unit: {}", location, unit);
146
147 let weather_response = json!({
148 "temperature": 22,
149 "unit": unit,
150 "condition": "sunny"
151 })
152 .to_string();
153
154 // Based on the curl example, we need to structure the conversation properly:
155 // 1. A user message with the original query
156 // 2. A model message containing the function call
157 // 3. A user message containing the function response
158
159 // Construct conversation following the exact curl pattern
160 let mut conversation = client.generate_content();
161
162 // 1. Add user message with original query and system prompt
163 conversation = conversation
164 .with_system_prompt("You are a helpful assistant that can check weather and perform calculations.")
165 .with_user_message("What's 42 times 12?");
166
167 // 2. Create model message with function call
168 let model_function_call = FunctionCall::new(
169 "get_weather",
170 json!({
171 "location": location,
172 "unit": unit
173 }),
174 );
175
176 // Create model content with function call
177 let model_content =
178 Content::function_call(model_function_call).with_role(Role::Model);
179
180 // Add as model message
181 let model_message = Message {
182 content: model_content,
183 role: Role::Model,
184 };
185 conversation = conversation.with_message(model_message);
186
187 // 3. Add user message with function response
188 conversation =
189 conversation.with_function_response_str("get_weather", weather_response)?;
190
191 // Execute the request
192 let final_response = conversation.execute().await?;
193
194 println!("Final response: {}", final_response.text());
195 }
196 _ => println!("Unknown function"),
197 }
198 } else {
199 println!("No function calls in the response.");
200 println!("Response: {}", response.text());
201 }
202
203 Ok(())
204}Trait Implementations§
Source§impl<'de> Deserialize<'de> for Content
impl<'de> Deserialize<'de> for Content
Source§fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations§
impl Freeze for Content
impl RefUnwindSafe for Content
impl Send for Content
impl Sync for Content
impl Unpin for Content
impl UnwindSafe for Content
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more