Skip to content

gemini_model

arai_ai_agents.models.gemini_model

GeminiModel

Bases: ModelInterface

Gemini model implementation.

Attributes:

Name Type Description
model str

The name of the Gemini model to use.
Source code in arai_ai_agents/models/gemini_model.py 
 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
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
class GeminiModel(ModelInterface):
    """Gemini model implementation.

    Attributes:
        model (str): The name of the Gemini model to use.
    """

    def __init__(self, api_key=None, model_name="gemini-exp-1206"):
        """Initialize the Gemini model.

        Args:
            api_key (str): The API key to use for the Gemini model.
            model_name (str): The name of the Gemini model to use.

        Example:
            >>> gemini_model = GeminiModel()
        """
        if api_key:
            genai.configure(api_key=api_key)
        else:
            genai.configure(api_key=os.environ.get('GOOGLE_GEMINI_API_KEY'))
        self.model = genai.GenerativeModel(model_name)

    # -------------------------------------------------------------------
    # Helper to generate a response to a given prompt using the Gemini API.
    # -------------------------------------------------------------------
    def generate_response(self, prompt, **kwargs):
        """Generate a response to a given prompt using the Gemini API.

        Args:
            prompt (str): The prompt to generate a response to.
            **kwargs: Additional keyword arguments.

        Returns:
            str: The generated response.

        Example:
            >>> gemini_model = GeminiModel()
            >>> response = gemini_model.generate_response("What is the weather in Tokyo?")
        """
        if isinstance(prompt, str):
            return self.generate_response_from_string(prompt, **kwargs)       
        elif isinstance(prompt, list[dict]):
            return self.generate_response_dictionary(prompt)

    # -------------------------------------------------------------------
    # Helper to generate a response to a given prompt using a list of dictionaries
    # -------------------------------------------------------------------
    def generate_response_dictionary(self, prompt: list[dict]) -> str:
        """Generate a response to a given prompt using a list of dictionaries.

        Args:
            prompt (list[dict]): The prompt to generate a response to.

        Returns:
            str: The generated response.

        Example:
            >>> gemini_model = GeminiModel()
            >>> response = gemini_model.generate_response_dictionary([{"role": "user", "parts": "What is the weather in Tokyo?"}])
        """
        try:
            response = self.model.generate_content(prompt)
            return response.text.strip()
        except Exception as e:
            return f"Error generating response: {str(e)}"

    # -------------------------------------------------------------------
    # Helper to generate a response to a given prompt using a string
    # -------------------------------------------------------------------
    def generate_response_from_string(self, prompt, **kwargs):
        """
        Description: 
            Generate a response to a given prompt using a string.

        Args:
            prompt (str): The prompt to generate a response to.
            **kwargs: Additional keyword arguments.

        Returns:
            str: The generated response.

        Example:
            >>> gemini_model = GeminiModel()
            >>> response = gemini_model.generate_response_from_string("What is the weather in Tokyo?")
        """
        # Extract personality and style from kwargs, or use defaults from agent_template
        if kwargs:
            if "personality" in kwargs:
                personality = kwargs.get("personality")
            if "communication_style" in kwargs:
                communication_style = kwargs.get("communication_style")
        else:
            personality = ""
            communication_style = ""        

        try:
            # instructions being sent to the ai model
            messages = []

            # add personality and style to the instructions
            if personality or communication_style:
                persona_prompt = f"{personality} {communication_style}"
                messages.append({
                    "role": "user",
                    "parts": [persona_prompt]
                })

            # user message
            messages.append({
                "role": "user",
                "parts": [prompt]
            })

            # Make sure that what is being sent to the model is correct
            # print(messages)

            # generate the response
            response = self.model.generate_content(messages)
            return response.text.strip()

        except Exception as e:
            return f"Error generating response: {str(e)}"

    # -------------------------------------------------------------------
    # Helper to fix a response that is not valid YAML
    # -------------------------------------------------------------------
    def fix_response(self, prompt, response):
        """Fix a response that is not valid YAML.

        Args:
            prompt (str): The prompt to generate a response to.
            response (str): The response to fix.

        Returns:
            str: The fixed response.

        Raises:
            Exception: If there's an error calling the API.

        Example:
            >>> gemini_model = GeminiModel()
            >>> response = gemini_model.fix_response("What is the weather in Tokyo?", "The weather in Tokyo is sunny.")
        """
        try:
            # instructions being sent to the ai model
            messages = []

            # add personality and style to the instructions            
            messages.append({
                "role": "user",
                "parts": [prompt]
            })

            # user message
            messages.append({
                "role": "user",
                "parts": [response]
            })

            # Make sure that what is being sent to the model is correct
            # print(messages)

            # generate the response
            response = self.model.generate_content(messages)
            return response.text.strip()

        except Exception as e:
            return f"Error generating response: {str(e)}"

    def generate_yaml_response(self):
        """Generate a YAML response.

        Args:
            None

        Returns:
            None

        Example:
            >>> gemini_model = GeminiModel()
            >>> gemini_model.generate_yaml_response()
        """
        messages = []

        messages.append({
            "role": "user",
            "parts": "Create me a YAML file with the following fields: name, personality, communication_style, topic, backstory, universe, hashtags, emojis. Start and end the file with ```yaml and ```"
        })

        response = self.model.generate_content(messages)
        print(response)

        # save the response to a file
        with open("response.txt", "w", encoding="utf-8") as f:
            f.write(response.text.strip())

        # save the response to a file
        with open("response.yaml", "w", encoding="utf-8") as f:
            f.write(response.text)

        # strip the response
        with open("response_stripped.yaml", "w", encoding="utf-8") as f:
            f.write(response.text.strip())


        # save the response to a yaml file
        with open("yaml_response.yaml", "w", encoding="utf-8") as f:
            yaml.dump(response.text, f)       

        # strip the response
        with open("yaml_response_stripped.yaml", "w", encoding="utf-8") as f:
            yaml.dump(response.text.strip(), f)

__init__(api_key=None, model_name='gemini-exp-1206')

Initialize the Gemini model.

Parameters:

Name Type Description Default
api_key str

The API key to use for the Gemini model.

 None
model_name str

The name of the Gemini model to use.

 'gemini-exp-1206'
Example

gemini_model = GeminiModel()

Source code in arai_ai_agents/models/gemini_model.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
def __init__(self, api_key=None, model_name="gemini-exp-1206"):
    """Initialize the Gemini model.

    Args:
        api_key (str): The API key to use for the Gemini model.
        model_name (str): The name of the Gemini model to use.

    Example:
        >>> gemini_model = GeminiModel()
    """
    if api_key:
        genai.configure(api_key=api_key)
    else:
        genai.configure(api_key=os.environ.get('GOOGLE_GEMINI_API_KEY'))
    self.model = genai.GenerativeModel(model_name)

fix_response(prompt, response)

Fix a response that is not valid YAML.

Parameters:

Name Type Description Default
prompt str

The prompt to generate a response to.

 required
response str

The response to fix.

 required

Returns:

Name Type Description
str

The fixed response.

Raises:

Type Description
Exception

If there's an error calling the API.
Example

gemini_model = GeminiModel() response = gemini_model.fix_response("What is the weather in Tokyo?", "The weather in Tokyo is sunny.")

Source code in arai_ai_agents/models/gemini_model.py 
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
def fix_response(self, prompt, response):
    """Fix a response that is not valid YAML.

    Args:
        prompt (str): The prompt to generate a response to.
        response (str): The response to fix.

    Returns:
        str: The fixed response.

    Raises:
        Exception: If there's an error calling the API.

    Example:
        >>> gemini_model = GeminiModel()
        >>> response = gemini_model.fix_response("What is the weather in Tokyo?", "The weather in Tokyo is sunny.")
    """
    try:
        # instructions being sent to the ai model
        messages = []

        # add personality and style to the instructions            
        messages.append({
            "role": "user",
            "parts": [prompt]
        })

        # user message
        messages.append({
            "role": "user",
            "parts": [response]
        })

        # Make sure that what is being sent to the model is correct
        # print(messages)

        # generate the response
        response = self.model.generate_content(messages)
        return response.text.strip()

    except Exception as e:
        return f"Error generating response: {str(e)}"

generate_response(prompt, **kwargs)

Generate a response to a given prompt using the Gemini API.

Parameters:

Name Type Description Default
prompt str

The prompt to generate a response to.

 required
**kwargs

Additional keyword arguments.

 {}

Returns:

Name Type Description
str

The generated response.
Example

gemini_model = GeminiModel() response = gemini_model.generate_response("What is the weather in Tokyo?")

Source code in arai_ai_agents/models/gemini_model.py 
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
def generate_response(self, prompt, **kwargs):
    """Generate a response to a given prompt using the Gemini API.

    Args:
        prompt (str): The prompt to generate a response to.
        **kwargs: Additional keyword arguments.

    Returns:
        str: The generated response.

    Example:
        >>> gemini_model = GeminiModel()
        >>> response = gemini_model.generate_response("What is the weather in Tokyo?")
    """
    if isinstance(prompt, str):
        return self.generate_response_from_string(prompt, **kwargs)       
    elif isinstance(prompt, list[dict]):
        return self.generate_response_dictionary(prompt)

generate_response_dictionary(prompt)

Generate a response to a given prompt using a list of dictionaries.

Parameters:

Name Type Description Default
prompt list[dict]

The prompt to generate a response to.

 required

Returns:

Name Type Description
str str

The generated response.
Example

gemini_model = GeminiModel() response = gemini_model.generate_response_dictionary([{"role": "user", "parts": "What is the weather in Tokyo?"}])

Source code in arai_ai_agents/models/gemini_model.py 
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
def generate_response_dictionary(self, prompt: list[dict]) -> str:
    """Generate a response to a given prompt using a list of dictionaries.

    Args:
        prompt (list[dict]): The prompt to generate a response to.

    Returns:
        str: The generated response.

    Example:
        >>> gemini_model = GeminiModel()
        >>> response = gemini_model.generate_response_dictionary([{"role": "user", "parts": "What is the weather in Tokyo?"}])
    """
    try:
        response = self.model.generate_content(prompt)
        return response.text.strip()
    except Exception as e:
        return f"Error generating response: {str(e)}"

generate_response_from_string(prompt, **kwargs)

Description

Generate a response to a given prompt using a string.

Parameters:

Name Type Description Default
prompt str

The prompt to generate a response to.

 required
**kwargs

Additional keyword arguments.

 {}

Returns:

Name Type Description
str

The generated response.
Example

gemini_model = GeminiModel() response = gemini_model.generate_response_from_string("What is the weather in Tokyo?")

Source code in arai_ai_agents/models/gemini_model.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
def generate_response_from_string(self, prompt, **kwargs):
    """
    Description: 
        Generate a response to a given prompt using a string.

    Args:
        prompt (str): The prompt to generate a response to.
        **kwargs: Additional keyword arguments.

    Returns:
        str: The generated response.

    Example:
        >>> gemini_model = GeminiModel()
        >>> response = gemini_model.generate_response_from_string("What is the weather in Tokyo?")
    """
    # Extract personality and style from kwargs, or use defaults from agent_template
    if kwargs:
        if "personality" in kwargs:
            personality = kwargs.get("personality")
        if "communication_style" in kwargs:
            communication_style = kwargs.get("communication_style")
    else:
        personality = ""
        communication_style = ""        

    try:
        # instructions being sent to the ai model
        messages = []

        # add personality and style to the instructions
        if personality or communication_style:
            persona_prompt = f"{personality} {communication_style}"
            messages.append({
                "role": "user",
                "parts": [persona_prompt]
            })

        # user message
        messages.append({
            "role": "user",
            "parts": [prompt]
        })

        # Make sure that what is being sent to the model is correct
        # print(messages)

        # generate the response
        response = self.model.generate_content(messages)
        return response.text.strip()

    except Exception as e:
        return f"Error generating response: {str(e)}"

generate_yaml_response()

Generate a YAML response.

Returns:

Type Description

None
Example

gemini_model = GeminiModel() gemini_model.generate_yaml_response()

Source code in arai_ai_agents/models/gemini_model.py 
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
def generate_yaml_response(self):
    """Generate a YAML response.

    Args:
        None

    Returns:
        None

    Example:
        >>> gemini_model = GeminiModel()
        >>> gemini_model.generate_yaml_response()
    """
    messages = []

    messages.append({
        "role": "user",
        "parts": "Create me a YAML file with the following fields: name, personality, communication_style, topic, backstory, universe, hashtags, emojis. Start and end the file with ```yaml and ```"
    })

    response = self.model.generate_content(messages)
    print(response)

    # save the response to a file
    with open("response.txt", "w", encoding="utf-8") as f:
        f.write(response.text.strip())

    # save the response to a file
    with open("response.yaml", "w", encoding="utf-8") as f:
        f.write(response.text)

    # strip the response
    with open("response_stripped.yaml", "w", encoding="utf-8") as f:
        f.write(response.text.strip())


    # save the response to a yaml file
    with open("yaml_response.yaml", "w", encoding="utf-8") as f:
        yaml.dump(response.text, f)       

    # strip the response
    with open("yaml_response_stripped.yaml", "w", encoding="utf-8") as f:
        yaml.dump(response.text.strip(), f)