Learn common patterns for using Google Gemini with Metorial's 600+ integrations.

Pattern 1: Simple Query and Response

The most basic pattern - ask a question, get an answer using integrations:

await metorial.withProviderSession(
  metorialGoogle,
  { serverDeployments: ['your-server-deployment-id'] },
  async session => {
    let response = await genAI.models.generateContent({
      model: 'gemini-1.5-pro-latest',
      contents: [{
        role: 'user',
        parts: [{ text: 'What are my meetings today?' }]
      }],
      config: { tools: session.tools }
    });

    let functionCalls = response.candidates?.[0]?.content?.parts
      ?.filter(part => part.functionCall)
      .map(part => part.functionCall!);

    if (functionCalls && functionCalls.length > 0) {
      let results = await session.callTools(functionCalls);
      console.log('Your meetings:', results);
    }
  }
);

Pattern 2: Multi-Step Conversations

Handle conversations where the agent needs to use multiple integrations:

await metorial.withProviderSession(
  metorialGoogle,
  { serverDeployments: ['your-server-deployment-id'] },
  async session => {
    let conversation = [{
      role: 'user',
      parts: [{ text: 'Find the README from the metorial repo on GitHub' }]
    }];

    let response = await genAI.models.generateContent({
      model: 'gemini-1.5-pro-latest',
      contents: conversation,
      config: { tools: session.tools }
    });

    let functionCalls = response.candidates?.[0]?.content?.parts
      ?.filter(part => part.functionCall)
      .map(part => part.functionCall!);

    if (functionCalls && functionCalls.length > 0) {
      let results = await session.callTools(functionCalls);
      
      // Add the function results to conversation history
      conversation.push({
        role: 'model',
        parts: functionCalls.map(fc => ({ functionCall: fc }))
      });
      
      conversation.push({
        role: 'function',
        parts: results.map((result, i) => ({
          functionResponse: {
            name: functionCalls[i].name,
            response: result
          }
        }))
      });

      // Continue the conversation
      conversation.push({
        role: 'user',
        parts: [{ text: 'Now summarize that README' }]
      });

      let finalResponse = await genAI.models.generateContent({
        model: 'gemini-1.5-pro-latest',
        contents: conversation,
        config: { tools: session.tools }
      });

      console.log(finalResponse.candidates?.[0]?.content?.parts?.[0]?.text);
    }
  }
);

Pattern 3: Batch Processing

Process multiple items using integrations:

const tasks = [
  'Summarize the latest issue in the metorial repo',
  'Find my next meeting',
  'Check unread emails'
];

await metorial.withProviderSession(
  metorialGoogle,
  { serverDeployments: ['your-server-deployment-id'] },
  async session => {
    for (const task of tasks) {
      let response = await genAI.models.generateContent({
        model: 'gemini-1.5-flash-latest', // Using Flash for speed
        contents: [{
          role: 'user',
          parts: [{ text: task }]
        }],
        config: { tools: session.tools }
      });

      let functionCalls = response.candidates?.[0]?.content?.parts
        ?.filter(part => part.functionCall)
        .map(part => part.functionCall!);

      if (functionCalls && functionCalls.length > 0) {
        let results = await session.callTools(functionCalls);
        console.log(`Results for "${task}":`, results);
      }
    }
  }
);

Pattern 4: Error Handling and Retries

Robust error handling for production applications:

await metorial.withProviderSession(
  metorialGoogle,
  { serverDeployments: ['your-server-deployment-id'] },
  async session => {
    const maxRetries = 3;
    let attempt = 0;

    while (attempt < maxRetries) {
      try {
        let response = await genAI.models.generateContent({
          model: 'gemini-1.5-pro-latest',
          contents: [{
            role: 'user',
            parts: [{ text: 'Get my calendar events' }]
          }],
          config: { tools: session.tools }
        });

        let functionCalls = response.candidates?.[0]?.content?.parts
          ?.filter(part => part.functionCall)
          .map(part => part.functionCall!);

        if (functionCalls && functionCalls.length > 0) {
          let results = await session.callTools(functionCalls);
          console.log('Success:', results);
          break;
        }
      } catch (error) {
        attempt++;
        console.error(`Attempt ${attempt} failed:`, error);
        
        if (attempt === maxRetries) {
          console.error('Max retries reached');
          throw error;
        }
        
        // Wait before retrying
        await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
      }
    }
  }
);

These patterns cover most use cases when building AI agents with Google Gemini and Metorial integrations.