from google import genai
from google.genai import types
import json

client = genai.Client(api_key="VOTRE_CLE_API")

# 1. Definir les fonctions
get_weather = types.FunctionDeclaration(
    name="get_weather",
    description="Obtient la meteo d'une ville",
    parameters=types.Schema(
        type="OBJECT",
        properties={
            "city": types.Schema(type="STRING", description="Nom de la ville")
        },
        required=["city"]
    )
)

get_time = types.FunctionDeclaration(
    name="get_time",
    description="Obtient l'heure actuelle dans un fuseau horaire",
    parameters=types.Schema(
        type="OBJECT",
        properties={
            "timezone": types.Schema(type="STRING", description="ex: Europe/Paris")
        },
        required=["timezone"]
    )
)

tools = types.Tool(function_declarations=[get_weather, get_time])

# 2. Fonctions reelles
def execute_function(name, args):
    if name == "get_weather":
        # Simuler un appel API meteo
        return {"temp": 14, "condition": "ensoleille", "wind": "12 km/h"}
    elif name == "get_time":
        from datetime import datetime
        return {"time": datetime.now().strftime("%H:%M"), "timezone": args["timezone"]}

# 3. Boucle function calling
def chat_with_tools(user_message):
    messages = [types.Content(role="user", parts=[types.Part(text=user_message)])]

    while True:
        response = client.models.generate_content(
            model="gemini-2.5-flash",
            contents=messages,
            config=types.GenerateContentConfig(tools=[tools])
        )

        # Verifier s'il y a des function calls
        candidate = response.candidates[0]
        has_function_calls = any(
            part.function_call for part in candidate.content.parts
        )

        if not has_function_calls:
            return response.text  # Reponse finale texte

        # Executer toutes les fonctions (parallel calling)
        messages.append(candidate.content)
        function_responses = []
        for part in candidate.content.parts:
            if part.function_call:
                result = execute_function(
                    part.function_call.name,
                    dict(part.function_call.args)
                )
                function_responses.append(
                    types.Part(function_response=types.FunctionResponse(
                        name=part.function_call.name,
                        response=result
                    ))
                )

        messages.append(types.Content(parts=function_responses))

# 4. Test
print(chat_with_tools("Quelle meteo et quelle heure a Paris ?"))
# -> Gemini appelle get_weather ET get_time en parallele !

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE_API")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Calcule les 20 premiers nombres de Fibonacci "
             "et trace un graphique de leur croissance.",
    config=types.GenerateContentConfig(
        tools=[types.Tool(code_execution=types.CodeExecution())]
    )
)

# La reponse contient le code execute ET le resultat
for part in response.candidates[0].content.parts:
    if part.executable_code:
        print(f"CODE:\n{part.executable_code.code}")
    if part.code_execution_result:
        print(f"RESULTAT:\n{part.code_execution_result.output}")
    if part.text:
        print(f"TEXTE:\n{part.text}")

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE_API")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Quels sont les derniers modeles Gemini sortis en 2026 "
             "et leurs performances sur les benchmarks ?",
    config=types.GenerateContentConfig(
        tools=[types.Tool(google_search=types.GoogleSearch())]
    )
)

print(response.text)

# Acceder aux sources et citations
grounding = response.candidates[0].grounding_metadata
if grounding:
    print("\n--- SOURCES ---")
    if grounding.grounding_chunks:
        for chunk in grounding.grounding_chunks:
            if chunk.web:
                print(f"  [{chunk.web.title}]({chunk.web.uri})")

    # Requetes de recherche utilisees par le modele
    if grounding.web_search_queries:
        print("\n--- REQUETES ---")
        for query in grounding.web_search_queries:
            print(f"  - {query}")

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE_API")

# Gemini 3 supporte l'URL Context comme outil integre
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Analyse la page https://ai.google.dev/gemini-api/docs/pricing "
             "et extrais un tableau comparatif des prix par modele.",
    config=types.GenerateContentConfig(
        tools=[types.Tool(url_context=types.UrlContext())],
        response_mime_type="application/json",
        response_schema={
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "model": {"type": "string"},
                    "input_price": {"type": "string"},
                    "output_price": {"type": "string"},
                    "context_window": {"type": "string"}
                }
            }
        }
    )
)

import json
data = json.loads(response.text)
for model in data:
    print(f"{model['model']}: {model['input_price']} / {model['output_price']}")

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE_API")

# Fonction custom
save_report = types.FunctionDeclaration(
    name="save_report",
    description="Sauvegarde un rapport d'analyse dans le systeme",
    parameters=types.Schema(
        type="OBJECT",
        properties={
            "title": types.Schema(type="STRING"),
            "content": types.Schema(type="STRING"),
            "format": types.Schema(type="STRING", enum=["pdf", "html", "md"])
        },
        required=["title", "content"]
    )
)

# Combiner : Search + Code Execution + Custom Function
response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Recherche les dernieres stats d'adoption de Kubernetes en 2026, "
             "calcule les tendances de croissance avec un graphique, "
             "puis sauvegarde le rapport en PDF.",
    config=types.GenerateContentConfig(
        tools=[
            types.Tool(google_search=types.GoogleSearch()),
            types.Tool(code_execution=types.CodeExecution()),
            types.Tool(function_declarations=[save_report])
        ]
    )
)
# Gemini orchestre automatiquement :
# 1. Google Search -> donnees actuelles
# 2. Code Execution -> calcul + graphique
# 3. save_report() -> sauvegarde du resultat

# Installation
pip install google-adk

# Structure de projet recommandee
my_agent/
├── __init__.py
├── agent.py          # Definition de l'agent
├── tools.py          # Outils custom
└── .env              # GOOGLE_API_KEY=...

from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool, google_search

# Definir un outil custom
def get_current_time(timezone: str = "UTC") -> dict:
    """Retourne l'heure actuelle dans le fuseau horaire donne."""
    from datetime import datetime
    import pytz
    tz = pytz.timezone(timezone)
    now = datetime.now(tz)
    return {"time": now.strftime("%H:%M:%S"), "timezone": timezone}

# Creer l'agent
agent = LlmAgent(
    name="assistant_agent",
    model="gemini-2.5-flash",
    instruction="""Tu es un assistant intelligent.
    Utilise tes outils pour repondre aux questions.
    Sois precis et concis dans tes reponses.""",
    tools=[
        FunctionTool(get_current_time),
        google_search,  # Outil built-in
    ],
)

# Lancer l'interface de test web
adk web

# Ou executer directement en Python
adk run my_agent

from google.adk.sessions import InMemorySessionService

# Service de sessions en memoire (dev/test)
session_service = InMemorySessionService()

# Creer une session
session = await session_service.create_session(
    app_name="my_agent",
    user_id="user_123",
)

# Acceder au state de la session
session.state["user_preferences"] = {"language": "fr", "theme": "dark"}
session.state["interaction_count"] = 0

print(f"Session ID: {session.id}")
print(f"State: {session.state}")

from google.adk.sessions import DatabaseSessionService

# Session persistante en base de donnees
session_service = DatabaseSessionService(
    db_url="sqlite:///sessions.db"
    # Ou PostgreSQL: "postgresql://user:pass@host/db"
)

# Les sessions survivent aux redemarrages
session = await session_service.get_session(
    app_name="my_agent",
    user_id="user_123",
    session_id="existing_session_id"
)

from google.adk.memory import InMemoryMemoryService

# Service de memoire long terme
memory_service = InMemoryMemoryService()

# L'agent avec memoire
agent = LlmAgent(
    name="memory_agent",
    model="gemini-2.5-flash",
    instruction="Tu te souviens des preferences de l'utilisateur.",
    tools=[google_search],
)

# Executer avec session + memoire
from google.adk.runners import Runner

runner = Runner(
    agent=agent,
    app_name="my_agent",
    session_service=session_service,
    memory_service=memory_service,
)

# Le runner gere automatiquement la memoire
response = await runner.run(
    user_id="user_123",
    session_id=session.id,
    new_message="Rappelle-toi que j'aime le Python"
)

from google.adk.agents import LlmAgent, SequentialAgent, ParallelAgent
from google.adk.tools import FunctionTool, google_search

# Agent 1 : Chercheur
researcher = LlmAgent(
    name="researcher",
    model="gemini-2.5-flash",
    instruction="""Recherche des informations sur le sujet demande.
    Stocke tes resultats dans state['research_data'].""",
    tools=[google_search],
    output_key="research_data",  # Auto-save dans state
)

# Agent 2 : Analyste
analyst = LlmAgent(
    name="analyst",
    model="gemini-2.5-flash",
    instruction="""Analyse les donnees de recherche dans state['research_data'].
    Produis une analyse structuree avec points cles et tendances.""",
    output_key="analysis_results",
)

# Agent 3 : Redacteur
writer = LlmAgent(
    name="writer",
    model="gemini-2.5-flash",
    instruction="""A partir de state['analysis_results'],
    redige un rapport professionnel en francais.
    Structure : resume, points cles, recommandations.""",
    output_key="final_report",
)

# Orchestrateur sequentiel
pipeline = SequentialAgent(
    name="research_pipeline",
    sub_agents=[researcher, analyst, writer],
)

from google.adk.tools import AgentTool

# Wrapper un agent specialise comme outil
expert_tool = AgentTool(agent=analyst)

# L'agent principal peut appeler l'expert
supervisor = LlmAgent(
    name="supervisor",
    model="gemini-2.5-pro",
    instruction="Tu supervises et delegues aux experts.",
    tools=[expert_tool, google_search],
    sub_agents=[researcher, writer],  # Delegation directe
)

from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import MCPToolset
from google.adk.tools.mcp_tool import SseServerParams, StdioServerParams

# Option 1 : Serveur MCP distant (SSE)
mcp_tools_remote = MCPToolset(
    connection_params=SseServerParams(
        url="https://my-mcp-server.example.com/sse",
        headers={"Authorization": "Bearer TOKEN"}
    )
)

# Option 2 : Serveur MCP local (stdio)
mcp_tools_local = MCPToolset(
    connection_params=StdioServerParams(
        command="npx",
        args=["-y", "@modelcontextprotocol/server-filesystem", "/data"]
    )
)

# Agent avec outils MCP
agent = LlmAgent(
    name="mcp_agent",
    model="gemini-2.5-flash",
    instruction="Utilise les outils MCP pour acceder aux donnees.",
    tools=[mcp_tools_remote],  # Ou mcp_tools_local
)

# Installation
npm install -g @anthropic-ai/gemini-cli
# Ou via Google
npm install -g @google/gemini-cli

# Utilisation basique
gemini "Explique ce fichier" --file main.py

# Mode interactif
gemini chat

# Avec contexte de projet
gemini "Corrige les bugs" --dir ./src

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxx"
      }
    }
  }
}

# Exemple de prompt pour App Prototyping :
"Cree une application web de gestion de taches avec :
- Interface React avec Material UI
- Backend Firebase avec Firestore
- Authentification Google
- CRUD complet sur les taches
- Filtres par statut et priorite"

# Firebase Studio genere automatiquement :
# - Code frontend React complet
# - Configuration Firebase
# - Rules Firestore
# - Deploiement configure

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE")

# Configuration Live API
config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],  # ou ["TEXT"], ["AUDIO", "TEXT"]
    speech_config=types.SpeechConfig(
        voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(
                voice_name="Puck"  # Voix disponible
            )
        )
    ),
    tools=[
        types.Tool(google_search_retrieval=
            types.GoogleSearchRetrieval()),
    ],
)

# Connexion live
async with client.aio.live.connect(
    model="gemini-2.5-flash",
    config=config
) as session:
    # Envoyer du texte
    await session.send_client_content(
        turns=types.Content(
            role="user",
            parts=[types.Part(text="Bonjour, quel temps fait-il ?")]
        )
    )

    # Recevoir la reponse en streaming
    async for response in session.receive():
        if response.text:
            print(response.text, end="", flush=True)
        if response.data:
            # Audio bytes a jouer
            play_audio(response.data)

from google import genai
from google.genai import types
import wave, struct

client = genai.Client(api_key="VOTRE_CLE")

# Generation audio depuis du texte
response = client.models.generate_content(
    model="gemini-2.5-flash-native-audio-preview",
    contents="Bonjour ! Je suis votre assistant vocal Gemini.",
    config=types.GenerateContentConfig(
        response_modalities=["AUDIO"],
        speech_config=types.SpeechConfig(
            voice_config=types.VoiceConfig(
                prebuilt_voice_config=types.PrebuiltVoiceConfig(
                    voice_name="Kore"
                )
            )
        ),
    ),
)

# Sauvegarder l'audio en WAV
audio_data = response.candidates[0].content.parts[0].inline_data.data
with wave.open("output.wav", "wb") as wf:
    wf.setnchannels(1)
    wf.setsampwidth(2)   # 16-bit PCM
    wf.setframerate(24000)  # 24kHz
    wf.writeframes(audio_data)

# Via Live API pour le bidirectionnel
config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    speech_config=types.SpeechConfig(
        voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(
                voice_name="Charon"
            )
        )
    ),
)

async with client.aio.live.connect(
    model="gemini-2.5-flash",
    config=config
) as session:
    # Envoyer de l'audio du microphone
    while True:
        audio_chunk = capture_microphone(duration_ms=200)
        await session.send_realtime_input(
            media=types.Blob(
                data=audio_chunk,
                mime_type="audio/pcm;rate=16000"
            )
        )

        # Recevoir et jouer la reponse
        async for msg in session.receive():
            if msg.data:
                play_speaker(msg.data)

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE")

# Embedding simple
result = client.models.embed_content(
    model="gemini-embedding-001",
    contents="Gemini est le modele IA de Google",
    config=types.EmbedContentConfig(
        task_type="RETRIEVAL_DOCUMENT",
        output_dimensionality=768,  # MRL : 768, 1536 ou 3072
    ),
)

vector = result.embeddings[0].values
print(f"Dimensions: {len(vector)}")  # 768
print(f"Premiers: {vector[:5]}")     # [0.012, -0.034, ...]

# Embeddings par lot (plus efficace)
texts = [
    "Gemini 2.5 Flash est rapide et economique",
    "Le RAG combine retrieval et generation",
    "Les agents utilisent des outils pour agir",
    "Le context caching reduit les couts de 90%",
]

result = client.models.embed_content(
    model="gemini-embedding-001",
    contents=texts,
    config=types.EmbedContentConfig(
        task_type="RETRIEVAL_DOCUMENT",
        output_dimensionality=1536,
    ),
)

for i, emb in enumerate(result.embeddings):
    print(f"Text {i}: {len(emb.values)} dimensions")

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE")

# Methode 1 : Inline requests
batch_job = client.batches.create(
    model="gemini-2.5-flash",
    requests=[
        types.BatchRequest(
            custom_id="req-001",
            request=types.GenerateContentRequest(
                contents="Resume cet article en 3 points : ...",
                config=types.GenerateContentConfig(
                    max_output_tokens=500,
                ),
            ),
        ),
        types.BatchRequest(
            custom_id="req-002",
            request=types.GenerateContentRequest(
                contents="Traduis en anglais : ...",
            ),
        ),
        # ... jusqu'a des milliers de requetes
    ],
)

print(f"Batch ID: {batch_job.name}")
print(f"Status: {batch_job.state}")  # PENDING

import time

# Verifier le statut
while True:
    batch = client.batches.get(name=batch_job.name)
    print(f"Status: {batch.state}")

    if batch.state == "JOB_STATE_SUCCEEDED":
        break
    elif batch.state == "JOB_STATE_FAILED":
        print(f"Erreur: {batch.error}")
        break

    time.sleep(30)  # Verifier toutes les 30s

# Recuperer les resultats
for result in client.batches.list_results(name=batch_job.name):
    print(f"ID: {result.custom_id}")
    print(f"Reponse: {result.response.text[:100]}...")

# Lister tous les batch jobs
for job in client.batches.list():
    print(f"{job.name}: {job.state}")

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE")

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="Explique les risques de cybersecurite",
    config=types.GenerateContentConfig(
        safety_settings=[
            types.SafetySetting(
                category="HARM_CATEGORY_DANGEROUS_CONTENT",
                threshold="BLOCK_MEDIUM_AND_ABOVE",
            ),
            types.SafetySetting(
                category="HARM_CATEGORY_HARASSMENT",
                threshold="BLOCK_ONLY_HIGH",
            ),
            # Les categories non specifiees restent a BLOCK_NONE
        ],
    ),
)

# Verifier les ratings de la reponse
for candidate in response.candidates:
    if candidate.safety_ratings:
        for rating in candidate.safety_ratings:
            print(f"Categorie: {rating.category}")
            print(f"Probabilite: {rating.probability}")
            print(f"Bloque: {rating.blocked}")

    # Verifier si la reponse a ete bloquee
    if candidate.finish_reason == "SAFETY":
        print("ATTENTION: Reponse bloquee par les filtres de securite")
        print(f"Raison: {candidate.safety_ratings}")

{"text_input": "Quel est le statut de la commande #12345 ?", "output": "Commande #12345 : En cours de livraison. Estimation : 2 jours ouvrables. Transporteur : Colissimo."}
{"text_input": "Je veux retourner mon produit", "output": "Procedure de retour initiee. Vous recevrez un email avec l'etiquette de retour sous 24h. Remboursement sous 5-7 jours apres reception."}
{"text_input": "Probleme avec ma facture de janvier", "output": "J'ai identifie une anomalie sur votre facture de janvier. Montant corrige : 45.90 EUR. Un avoir sera emis sous 48h."}
{"text_input": "Changer mon adresse de livraison", "output": "Adresse mise a jour avec succes. Prochaine livraison a la nouvelle adresse. Confirmation envoyee par email."}

from google import genai
from google.genai import types

client = genai.Client(api_key="VOTRE_CLE")

# Preparer les exemples d'entrainement
training_data = [
    types.TuningExample(
        text_input="Quel est le statut de la commande #12345 ?",
        output="Commande #12345 : En cours de livraison..."
    ),
    types.TuningExample(
        text_input="Je veux retourner mon produit",
        output="Procedure de retour initiee..."
    ),
    # ... au moins 20 exemples
]

# Creer le job de tuning
tuning_job = client.tunings.create(
    base_model="models/gemini-2.5-flash-001-tuning",
    training_dataset=types.TuningDataset(
        examples=types.TuningExamples(
            examples=training_data
        )
    ),
    config=types.CreateTuningJobConfig(
        epoch_count=5,
        learning_rate=0.001,
        tuned_model_display_name="support-client-v1",
    ),
)

print(f"Job: {tuning_job.name}")
print(f"Status: {tuning_job.state}")

# Une fois le tuning termine
response = client.models.generate_content(
    model=tuning_job.tuned_model.model,  # ex: tunedModels/support-client-v1-xxxxx
    contents="Le client veut modifier sa commande",
)
print(response.text)

# Lister vos modeles fine-tunes
for model in client.tunings.list():
    print(f"{model.tuned_model.model}: {model.state}")