API Gémeaux
2.4.12
Un * wrapper Python non officiel , python-gemini-api, est disponible pour les utilisateurs confrontés à des problèmes d'authentification fréquents ou incapables d'utiliser l'authentification Google. Ce wrapper utilise les valeurs des cookies pour interagir avec Google Gemini via l'ingénierie inverse. Le projet impliquait une collaboration avec Antonio Cheong.
Du côté officiel, Google fournit des API et SDK Gemini officiels partiellement gratuits et propres, qui peuvent être consultés et utilisés parfaitement via les packages Python, google-generativeai.
Conseil
| 2024-03-26 | [Voir Exemples de code]
Découvrez les API LLM open source temporairement gratuites avec Open Router. (Limite gratuite : 10 requêtes/minute)
| 2024-05-20 | Il y a quelques changements de logique en fonction de la région/pays (IP) et du compte. Les utilisateurs doivent vérifier les éléments suivants pour trouver la logique qui leur convient. Le package reste adapté aux cas d’utilisation les plus courants.
BOT_SERVER dans const.pyself._sid dans client.pyself._rcid dans client.py| Papier | Site officiel | API officielle | Documents API |
Gemini est une famille de modèles d'IA génératifs développés par Google DeepMind et conçus pour des cas d'utilisation multimodaux. L'API Gemini vous donne accès aux modèles Gemini Pro et Gemini Pro Vision. En février 2024, le service Bard de Google est devenu Gemini .
| Modèle | Taper | Accéder | Détails |
|---|---|---|---|
| Gémeaux | Propriétaire | API [13] | Une IA multimodale propriétaire de Google DeepMind, comprenant des modèles avancés tels que Gemini Pro et Gemini Pro Vision. L'accès est limité à l'utilisation de l'API ; des informations supplémentaires peuvent être obtenues via le document et le site Web. [1][2] |
| Gemme | Source ouverte | Téléchargeable API gratuite | Un modèle de langage texte-texte open source adapté aux tâches telles que l'assurance qualité et la synthèse. Les poids sont téléchargeables pour une utilisation sur site, et une documentation détaillée est fournie via le document et le site Web. [3][4] |
| Code Gemma | Source ouverte | Téléchargeable | Conçu spécifiquement pour les tâches de programmation, ce modèle open source propose des pondérations téléchargeables pour aider les développeurs dans la génération de code et les activités similaires. Reportez-vous à l'article associé, à l'article de blog et à la collection Hugging Face pour plus d'informations. [5][6][7] |
Il s'agit d'un wrapper Python dérivé du projet API Bard, conçu pour récupérer les réponses de Gemini Web au format REST. Les clients synchrones sont préférés aux clients asynchrones pour Gemini en raison de problèmes de limitation de débit et de blocage.
pip install python-gemini-api
pip install git+https://github.com/dsdanielpark/Gemini-API.git
Pour la version mise à jour, utilisez comme suit :
pip install -q -U python-gemini-api
Visitez https://gemini.google.com/
Une fois le navigateur ouvert, essayez d’abord de collecter automatiquement les cookies.
from gemini import Gemini
client = Gemini ( auto_cookies = True )
# Testing needed as cookies vary by region.
# client = Gemini(auto_cookies=True, target_cookies=["__Secure-1PSID", "__Secure-1PSIDTS"])
# client = Gemini(auto_cookies=True, target_cookies="all") # You can pass whole cookies
response = client . generate_content ( "Hello, Gemini. What's the weather like in Seoul today?" )
print ( response . payload ) (Manuellement) F12 pour la console du navigateur → Session: Application → Cookies → Copiez la valeur de certains ensembles de cookies fonctionnels. Si cela ne fonctionne pas, passez à l'étape 3.
Essayez d’abord __Secure-1PSIDCC seul. Si cela ne fonctionne pas, utilisez __Secure-1PSID et __Secure-1PSIDTS . Toujours pas de succès ? Essayez ces quatre cookies : __Secure-1PSIDCC , __Secure-1PSID , __Secure-1PSIDTS , NID . Si aucun résultat ne fonctionne, passez à l’étape 3 et envisagez d’envoyer l’intégralité du fichier cookie.
(Recommandé) Exportez les cookies du site Gemini via une extension de navigateur. Par exemple, utilisez l'extension Chrome ExportThisCookies, ouvrez et copiez le contenu du fichier txt.
Important
Expérimentez avec différents comptes Google et paramètres de navigateur pour trouver un cookie fonctionnel. Le succès peut varier selon l'adresse IP et le statut du compte. Une fois connecté, un cookie reste généralement efficace pendant un mois. Continuez à tester jusqu'à ce que vous réussissiez.
Générer du contenu : renvoie la réponse analysée.
from gemini import Gemini cookies = { "" : "" } # Cookies may vary by account or region. Consider sending the entire cookie file. client = Gemini ( cookies = cookies ) # You can use various args response = client . generate_content ( "Hello, Gemini. What's the weather like in Seoul today?" ) response . payload
Générer du contenu à partir d'une image : vous pouvez utiliser l'image comme entrée.
from gemini import Gemini cookies = { "" : "" } client = Gemini ( cookies = cookies ) # You can use various args response = client . generate_content ( "What does the text in this image say?" , image = 'folder/image.jpg' ) response . payload
Note
Si la méthode generate_content renvoie une charge utile vide, essayez de l'exécuter à nouveau sans réinitialiser l'objet Gemini.
Définition de la langue et de la version Gemini à l'aide de variables d'environnement :
Définition de la langue de réponse Gemini (facultatif) : vérifiez les langues prises en charge ici. La valeur par défaut est l'anglais.
import os
os . environ [ "GEMINI_LANGUAGE" ] = "KR" # Setting Gemini response language (Optional)
os . environ [ "GEMINI_ULTRA" ] = "1" # Switch to Gemini-advanced response (Experimental, Optional)
# In some accounts, access to Gemini Ultra may not be available. If that's the case, please revert it back to "0". Veuillez déclarer explicitement cookies au format dict. Vous pouvez également saisir le chemin d'accès au fichier contenant le cookie avec cookie_fp (*.json, *.txt pris en charge). Vérifiez les exemples de fichiers de cookies dans le dossier des actifs.
from gemini import Gemini
cookies = {
"__Secure-1PSIDCC" : "value" ,
"__Secure-1PSID" : "value" ,
"__Secure-1PSIDTS" : "value" ,
"NID" : "value" ,
# Cookies may vary by account or region. Consider sending the entire cookie file.
}
client = Gemini ( cookies = cookies )
# client = Gemini(cookie_fp="folder/cookie_file.json") # (*.json, *.txt) are supported.
# client = Gemini(auto_cookies=True) # Or use auto_cookies paprameter Pour que auto_cookie soit défini sur True et ajustez target_cookies . Gemini WebUI doit être actif dans le navigateur. Le browser_cookie3 permet la collecte automatique des cookies, même si les mises à jour ne sont peut-être pas encore terminées.
Renvoie la réponse de Gemini, mais la première peut être vide.
from gemini import Gemini
cookies = {}
client = Gemini ( cookies = cookies )
prompt = "Tell me about Large Language Model."
response = client . generate_content ( prompt )
print ( response . payload )Important
N'envoyez PAS la même invite à plusieurs reprises. Si la session se connecte avec succès et generate_content fonctionne bien, FERMER le site Web Gemini. Si Gemini Web reste ouvert dans le navigateur, les cookies peuvent expirer plus rapidement.
La sortie de la fonction generate_content est GeminiModelOutput , avec la structure suivante :
Gemini-API/gemini/src/model/output.py
Ligne 16 dans fdf064c
Envoyer la demande : renvoie la charge utile et le status_code de la demande, ce qui facilite le débogage.
from gemini import Gemini
cookies = {}
client = Gemini ( cookies = cookies )
response_text , response_status = client . send_request ( "Hello, Gemini. Tell me about Large Language Models." )
print ( response_text ) Vous pouvez suivre le nombre total de requêtes effectuées en accédant à la propriété request_count dans la classe Gemini .
Renvoie le texte généré par Gemini.
from gemini import Gemini
cookies = {}
client = Gemini ( cookies = cookies )
prompt = "Hello, Gemini. Tell me about Large Language Models."
response = client . generate_content ( prompt )
print ( response . text )Renvoie les images générées par Gemini.
Téléchargeur asynchrone
from gemini import Gemini , GeminiImage
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Hello, Gemini. Tell me about Large Language Models." )
generated_images = response . generated_images # Check generated images [Dict]
await GeminiImage . save ( generated_images , "output" , cookies )
# image_data_dict = await GeminiImage.fetch_images_dict(generated_images, cookies)
# await GeminiImage.save_images(image_data_dict, "output")Afficher des images dans IPython Vous pouvez afficher l'image ou la transmettre à une autre application au format octet.
import io
from gemini import Gemini , GeminiImage
from IPython . display import display , Image
cookies = {}
client = Gemini ( cookies = cookies )
bytes_images_dict = GeminiImage . fetch_images_dict_sync ( generated_images , cookies ) # Get bytes images dict
for image_name , image_bytes in bytes_images_dict . items ():
print ( image_name )
image = Image ( data = image_bytes )
display ( image )Synchroniser le téléchargeur
from gemini import Gemini , GeminiImage
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Create illustrations of Seoul, South Korea." )
generated_images = response . generated_images # Check generated images [Dict]
GeminiImage . save_sync ( generated_images , save_path = "output" , cookies = cookies )
# You can use byte type image dict for printing images as follow:
# bytes_images_dict = GeminiImage.fetch_images_dict_sync(generated_images, cookies) # Get bytes images dict
# GeminiImage.save_images_sync(bytes_images_dict, path="output") # Save to dirWrapper de téléchargement asynchrone
import asyncio
from gemini import GeminiImage
async def save_generated_images ( generated_images , save_path = "output" , cookies = cookies ):
await GeminiImage . save ( generated_images , save_path = save_path , cookies = cookies )
# Run the async function
if __name__ == "__main__" :
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Create illustrations of Seoul, South Korea." )
generated_images = response . generated_images
asyncio . run ( save_generated_images ( generated_images , save_path = "output" , cookies = cookies )) Logique de la méthode GeminiImage.save
import asyncio
from gemini import Gemini , GeminiImage
async def save_generated_images ( generated_images , save_path = "output" , cookies = cookies ):
image_data_dict = await GeminiImage . fetch_images_dict ( generated_images , cookies ) # Get bytes images dict asynchronously
await GeminiImage . save_images ( image_data_dict , save_path = save_path )
# Run the async function
if __name__ == "__main__" :
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Create illustrations of Seoul, South Korea." )
generated_images = response . generated_images
asyncio . run ( save_generated_images ( generated_images , save_path = "output" , cookies = cookies ))Note
Utilisez GeminiImage pour le traitement des images. web_images fonctionne sans cookies, mais pour les images comme generated_image de Gemini, transmettez les cookies. Les cookies sont nécessaires pour télécharger des images depuis le stockage de Google. Vérifiez la réponse ou utilisez la variable de cookies existante.
Renvoie des images en réponse de Gemini.
Téléchargeur asynchrone
from gemini import Gemini , GeminiImage
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Give me a picture of Stanford." )
response_images = response . web_images # Check generated images
await GeminiImage . save ( response_images , "output" )
# image_data_dict = await GeminiImage.fetch_images_dict(response_images)
# await GeminiImage.save_images(image_data_dict, "output")Synchroniser le téléchargeur
from gemini import Gemini , GeminiImage
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Give me a picture of Stanford." )
response_images = response . web_images # Check response images
GeminiImage . save_sync ( response_images , save_path = "output" )
# You can use byte type image dict as follow:
# bytes_images_dict = GeminiImage.fetch_bytes_sync(response_images) # Get bytes images dict
# GeminiImage.save_images_sync(bytes_images_dict, save_path="output") # Save to pathWrapper de téléchargement asynchrone
import asyncio
from gemini import Gemini , GeminiImage
async def save_response_web_imagse ( response_images , save_path = "output" ):
await GeminiImage . save ( response_images , save_path = save_path )
if __name__ == "__main__" :
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Give me a picture of Stanford." )
response_images = response . web_images
asyncio . run ( save_response_web_imagse ( response_images , save_path = "output" )) Logique de la méthode GeminiImage.save
import asyncio
from gemini import Gemini , GeminiImage
async def save_response_web_imagse ( response_images , save_path = "output" ):
image_data_dict = await GeminiImage . fetch_images_dict ( response_images ) # Get bytes images dict asynchronously
await GeminiImage . save_images ( image_data_dict , save_path = save_path )
# Run the async function
if __name__ == "__main__" :
cookies = {}
client = Gemini ( cookies = cookies )
response = client . generate_content ( "Give me a picture of Stanford." )
response_images = response . web_images
asyncio . run ( save_response_web_imagse ( response_images , save_path = "output" ))Prend une image en entrée et renvoie une réponse.
image = 'folder/image.jpg'
# image = open('folder/image.jpg', 'rb').read() # (jpg, jpeg, png, webp) are supported.
# Image file path or Byte-formatted image array
response = client . generate_content ( "What does the text in this image say?" , image = image )
print ( response )Pour commencer, vous devez lier Google Workspace pour activer cette extension via l'extension web Gemini. Veuillez vous référer à l'avis officiel et consulter les politiques de confidentialité pour plus de détails.
drapeaux d'extension
@Gmail, @Google Drive, @Google Docs, @Google Maps, @Google Flights, @Google Hotels, @YouTube
response = client . generate_content ( "@YouTube Search clips related with Google Gemini" )
response . response_dictEspace de travail Google
Google Cartes
Vols Google
Google Hôtels
YouTube
Vous pouvez spécifier une réponse particulière en définissant son ID de candidat de réponse (RCID).
# Generate content for the prompt "Give me some information about the USA."
response1 = client . generate_content ( "Give me some information about the USA." )
# After reviewing the responses, choose the one you prefer and copy its RCID.
client . rcid = "rc_xxxx"
# Now, generate content for the next prompt "How long does it take from LA to New York?"
response2 = client . generate_content ( "How long does it take from LA to New York?" )
# However, RCID may not persist. If parsing fails, reset `client.rcid` to None.
# client.rcid = NoneDans Gemini, generate_content renvoie la première réponse. Cela peut varier en fonction de la longueur ou du tri. Par conséquent, vous pouvez spécifier l'index de la réponse choisie de 0 à n comme suit. Cependant, s’il n’y a qu’une seule réponse, remettez-la à 0.
from gemini import GeminiModelOutput
GeminiModelOutput . chosen = 1 # default is 0
response_choice_1 = client . generate_content ( "Give me some information about the USA." )
# If not all Gemini returns are necessarily plural, revert back to 0 in case of errors.
# GeminiModelOutput.chosen = 0Analysez le texte de la réponse pour extraire les valeurs souhaitées.
À l'aide de Gemini.generate_custom_content , spécifiez une analyse personnalisée pour extraire des valeurs spécifiques. Utilisez ParseMethod1 et ParseMethod2 par défaut et vous pouvez transmettre des méthodes d'analyse personnalisées comme arguments si vous le souhaitez. Reportez-vous à custom_parser.py.
# You can create a parser method that takes response_text as the input for custom_parser.
response_text , response_status = client . send_request ( "Give me some information about the USA." )
# Use custom_parser function or class inheriting from BaseParser
response = client . generate_custom_content ( "Give me some information about the USA." , * custom_parser )Gemini-API/gemini/client.py
Ligne 323 en 31b8424
Si vous souhaitez éviter les demandes bloquées et les interdictions, utilisez Smart Proxy de Crawlbase. Il transmet vos demandes de connexion à une adresse IP tournant de manière aléatoire dans un pool de proxys avant d'atteindre le site Web cible. La combinaison de l’IA et du ML permet d’éviter plus efficacement les CAPTCHA et les blocages. L’argument au niveau SSL (Secure Sockets Layer) devra peut-être être ajouté à l’en-tête. Utilisez-le conjointement avec verify=False .
# Get your proxy url at crawlbase https://crawlbase.com/docs/smart-proxy/get/
proxy_url = "http://xxxxx:@smartproxy.crawlbase.com:8012"
proxies = { "http" : proxy_url , "https" : proxy_url }
client = Gemini ( cookies = cookies , proxies = proxies , timeout = 30 , verify = False )
client . session . header [ "crawlbaseAPI-Parameters" ] = "country=US"
client . generate_content ( "Hello, Gemini. Give me a beautiful photo of Seoul's scenery." )Pour les cas standards, utilisez la classe Gemini ; pour les exceptions, utilisez des objets de session. Lors de la création d'un nouveau serveur bot Gemini, ajustez Headers.MAIN.
import requests
from gemini import Gemini , Headers
cookies = {}
session = requests . Session ()
session . headers = Headers . MAIN
for key , value in cookies . items ():
session . cookies . update ({ key : value })
client = Gemini ( session = session ) # You can use various args
response = client . generate_content ( "Hello, Gemini. Tell me about Large Language Model." )Découvrez les fonctionnalités supplémentaires dans ce document.
Si vous souhaitez développer votre propre code simple, vous pouvez partir de cet exemple de code simple.
Préparez les éléments nécessaires et obtenez une clé API sur Google AI Studio. Installez sur Python 3.9 ou supérieur et entrez la clé API émise. Reportez-vous au didacticiel pour plus de détails.
pip install -q -U google-generativeai
import google . generativeai as genai
GOOGLE_API_KEY = ""
genai . configure ( api_key = GOOGLE_API_KEY )
model = genai . GenerativeModel ( 'gemini-pro' )
response = model . generate_content ( "Write me a poem about Machine Learning." )
print ( response . text )Si vous disposez de ressources GPU suffisantes, vous pouvez télécharger les pondérations directement au lieu d'utiliser l'API Gemini pour générer du contenu. Considérez Gemma et Code Gemma, des modèles open source disponibles pour une utilisation sur site .
Les modèles Gemma sont des modèles de langage texte-texte avancés et légers de Google, basés uniquement sur un décodeur, dérivés de la recherche Gemini. Disponibles en anglais, ils proposent des pondérations et des variantes ouvertes, idéales pour des tâches telles que la réponse aux questions et la synthèse. Pour plus d'informations, visitez la carte modèle Gemma-7b.
from transformers import AutoTokenizer , AutoModelForCausalLM
tokenizer = AutoTokenizer . from_pretrained ( "google/gemma-7b" )
model = AutoModelForCausalLM . from_pretrained ( "google/gemma-7b" )
input_text = "Write me a poem about Machine Learning."
input_ids = tokenizer ( input_text , return_tensors = "pt" )
outputs = model . generate ( ** input_ids )
print ( tokenizer . decode ( outputs [ 0 ]))CodeGemma, qui est une version officielle de Google pour les LLM de code, a été publiée le 9 avril 2024. Elle propose trois modèles spécifiquement conçus pour générer et interagir avec du code. Vous pouvez explorer les modèles Code Gemma et consulter la fiche modèle pour plus de détails.
from transformers import GemmaTokenizer , AutoModelForCausalLM
tokenizer = GemmaTokenizer . from_pretrained ( "google/codegemma-7b-it" )
model = AutoModelForCausalLM . from_pretrained ( "google/codegemma-7b-it" )
input_text = "Write me a Python function to calculate the nth fibonacci number."
input_ids = tokenizer ( input_text , return_tensors = "pt" )
outputs = model . generate ( ** input_ids )
print ( tokenizer . decode ( outputs [ 0 ]))OpenRouter propose une inférence gratuite temporaire pour certains modèles. Obtenez une clé API auprès de l'API Open Router et vérifiez les modèles gratuits sur les modèles Open Router. Utilisez principalement des modèles avec un coût symbolique de 0 dollar ; d'autres modèles peuvent entraîner des frais. Pour en savoir plus, consultez le guide gratuit de l'API LLM open source.
Le client de synchronisation est préféré à l'asynchrone pour Gemini en raison de problèmes de limitation de débit et de blocage , mais OpenRouter propose des LLM open source fiables pour la mise en œuvre asynchrone. (Limite gratuite : 10 requêtes/minute)
from gemini import OpenRouter
OPENROUTER_API_KEY = ""
gemma_client = OpenRouter ( api_key = OPENROUTER_API_KEY , model = "google/gemma-7b-it:free" )
prompt = "Do you know UCA academy in Korea? https://blog.naver.com/ulsancoding"
response = gemma_client . create_chat_completion ( prompt )
print ( response )
# payload = gemma_client.generate_content(prompt)
# print(payload.json())La liste des modèles gratuits comprend :
google/gemma-7b-it:free - google/gemma-7b de Google ***mistralai/mistral-7b-instruct:free - mistralai/Mistral-7B-Instruct-v0.1 pour les instructions de Mistral AI ****huggingfaceh4/zephyr-7b-beta:free - HuggingFaceH4/zephyr-7b-beta ***openchat/openchat-7b:free - openchat/openchat pour le chat **openrouter/cinematika-7b:free - Jondurbin/cinematika-7b-v0.1undi95/toppy-m-7b:free - Undi95/Toppy-M-7Bgryphe/mythomist-7b:free - Gryphe/MythoMist-7bnousresearch/nous-capybara-7b:free - NousResearch/Nous-Capybara-7B-V1 de Nous Research Utilisez l'API Crawlbase pour une récupération efficace des données afin de former des modèles d'IA, avec un taux de réussite de 98 % et une disponibilité de 99,9 %. Il est rapide à démarrer, conforme au RGPD/CCPA, prend en charge l'extraction massive de données et bénéficie de la confiance de plus de 70 000 développeurs.
Examinez d’abord HanaokaYuzu/Gemini-API et l’API officielle de Google Gemini avant d’utiliser ce package. Vous pouvez trouver la plupart de l'aide sur les pages FAQ et Problème.
Sincèrement reconnaissant pour tout rapport sur de nouvelles fonctionnalités ou bugs. Vos précieux commentaires sur le code sont très appréciés. Des erreurs fréquentes peuvent survenir en raison de modifications apportées à l'interface de l'API du service Google. Les rapports de problèmes et les demandes de tirage contribuant aux améliorations sont toujours les bienvenus. Nous nous efforçons de maintenir une communauté ouverte, active et courtoise.
creusez le puits avant d’avoir soif.
Nous tenons à exprimer notre sincère gratitude à tous les contributeurs.
Ce package vise à réimplémenter la fonctionnalité de l'API Bard, qui a été archivée pour les contributions de la bien-aimée communauté open source, bien que l'API officielle de Gemini soit déjà disponible.
Contributeurs à l'API Bard et à l'API Gemini.
Des modifications du client asynchrone utilisant ma logique sont nécessaires, ainsi qu'une collecte automatique de cookies via browser_cookie3 et la mise en œuvre d'autres fonctionnalités de l'API Bard (telles que l'extraction de code, l'exportation vers Replit, le dessin de graphiques, etc.).
Veuillez noter que lors de l'examen de la collecte automatique des cookies, il semble que les cookies expirent immédiatement après l'envoi d'une demande de collecte. Les efforts visant à le rendre plus convivial ont échoué. De plus, la valeur _sid semble fonctionner normalement même lorsqu'elle est renvoyée comme Aucun.
Enfin, si les algorithmes CustomParser et ResponseParser ne fonctionnent pas correctement, de nouvelles méthodes d'analyse peuvent être mises à jour via des instructions conditionnelles dans les sections concernées.
Je n'ai pas l'intention de gérer activement ce référentiel. Veuillez d'abord consulter HanaokaYuzu/Gemini-API.
Merci et bonne journée.
Licence MIT, 2024. Par la présente, nous déclinons fortement toute responsabilité légale explicite ou implicite liée à nos travaux. Les utilisateurs sont tenus d'utiliser ce package de manière responsable et à leurs propres risques. Ce projet est une initiative personnelle et n'est ni affilié ni approuvé par Google. Il est recommandé d'utiliser l'API officielle de Google.
Avertissement Les utilisateurs assument l'entière responsabilité légale de GeminiAPI. Non approuvé par Google. Une utilisation excessive peut entraîner des restrictions de compte. Les modifications des politiques ou de l'état du compte peuvent affecter les fonctionnalités. Utilisez les pages de problèmes et de discussions.
Python 3.7 ou supérieur.
