# Streaming with automatic tracing
response = model.generate_content(
    "Write a story about AI",
    stream=True
)

for chunk in response:
    print(chunk.text, end="", flush=True)

// Streaming with automatic tracing
const result = await model.generateContentStream(
  'Write a story about AI'
);

for await (const chunk of result.stream) {
  process.stdout.write(chunk.text());
}

// Get aggregated response
const response = await result.response;

# Start a chat session
chat = model.start_chat(history=[])

# Each message is traced
response = chat.send_message("Hello! I'm learning about AI.")
print(response.text)

response = chat.send_message("What are neural networks?")
print(response.text)

# Full conversation history is captured

// Start a chat session
const chat = model.startChat({ history: [] });

// Each message is traced
let result = await chat.sendMessage("Hello! I'm learning about AI.");
console.log(result.response.text());

result = await chat.sendMessage('What are neural networks?');
console.log(result.response.text());

// Full conversation history is captured

# Define functions
def get_weather(location: str) -> dict:
    return {"temperature": 72, "condition": "sunny"}

tools = [
    genai.protos.Tool(
        function_declarations=[
            genai.protos.FunctionDeclaration(
                name="get_weather",
                description="Get weather for a location",
                parameters=genai.protos.Schema(
                    type=genai.protos.Type.OBJECT,
                    properties={
                        "location": genai.protos.Schema(
                            type=genai.protos.Type.STRING
                        )
                    },
                    required=["location"]
                )
            )
        ]
    )
]

model = wrap_google(
    genai.GenerativeModel("gemini-1.5-pro", tools=tools),
    brokle=brokle
)

response = model.generate_content("What's the weather in Paris?")

# Function calls are captured in the trace
for part in response.parts:
    if fn := part.function_call:
        print(f"Function: {fn.name}")
        print(f"Args: {fn.args}")

const tools = [
  {
    functionDeclarations: [
      {
        name: 'get_weather',
        description: 'Get weather for a location',
        parameters: {
          type: 'object',
          properties: {
            location: { type: 'string' }
          },
          required: ['location']
        }
      }
    ]
  }
];

const model = client.getGenerativeModel({
  model: 'gemini-1.5-pro',
  tools
});

const result = await model.generateContent(
  "What's the weather in Paris?"
);

// Function calls are captured in the trace
const response = result.response;
const calls = response.functionCalls();
if (calls) {
  calls.forEach(call => {
    console.log('Function:', call.name);
    console.log('Args:', call.args);
  });
}

import PIL.Image

# From file
image = PIL.Image.open("image.jpg")

response = model.generate_content([
    "What's in this image?",
    image
])

print(response.text)

# From URL (base64)
import base64
import httpx

image_data = base64.standard_b64encode(
    httpx.get("https://example.com/image.jpg").content
).decode("utf-8")

response = model.generate_content([
    "Describe this image",
    {"mime_type": "image/jpeg", "data": image_data}
])

import fs from 'fs';

// From file
const imageData = fs.readFileSync('image.jpg').toString('base64');

const result = await model.generateContent([
  "What's in this image?",
  {
    inlineData: {
      mimeType: 'image/jpeg',
      data: imageData
    }
  }
]);

console.log(result.response.text());

embed_model = wrap_google(
    genai.GenerativeModel("models/embedding-001"),
    brokle=brokle
)

result = genai.embed_content(
    model="models/embedding-001",
    content="Hello world",
    task_type="retrieval_document"
)

print(f"Embedding dimension: {len(result['embedding'])}")

const embedModel = client.getGenerativeModel({
  model: 'embedding-001'
});

const result = await embedModel.embedContent('Hello world');
console.log('Embedding dimension:', result.embedding.values.length);