Gemini API
2.4.12
Um * wrapper Python não oficial , python-gemini-api, está disponível para usuários que enfrentam problemas frequentes de autenticação ou que não conseguem usar a autenticação do Google. Este wrapper usa valores de cookies para interagir com o Google Gemini por meio de engenharia reversa. O projeto envolveu uma colaboração com Antonio Cheong.
Do lado oficial, o Google fornece APIs e SDKs oficiais Gemini parcialmente gratuitos e limpos, que podem ser acessados e utilizados perfeitamente por meio de pacotes Python, google-generativeai.
Dica
| 26/03/2024 | [Ver exemplos de código]
Confira APIs LLM de código aberto temporariamente gratuitas com Open Router. (Limite gratuito: 10 solicitações/minuto)
| 2024/05/20 | Existem algumas mudanças na lógica dependendo da região/país (IP) e da conta. Os usuários precisam verificar o seguinte para encontrar a lógica apropriada para si próprios. O pacote permanece adequado para os casos de uso mais comuns.
BOT_SERVER em const.pyself._sid em client.pyself._rcid em client.py| Papel | Site Oficial | API oficial | Documentos API |
Gemini é uma família de modelos generativos de IA desenvolvidos pelo Google DeepMind e projetados para casos de uso multimodais. A API Gemini dá acesso aos modelos Gemini Pro e Gemini Pro Vision. Em fevereiro de 2024, o serviço Bard do Google foi alterado para Gemini .
| Modelo | Tipo | Acesso | Detalhes |
|---|---|---|---|
| Gêmeos | Proprietário | API [13] | Uma IA multimodal proprietária do Google DeepMind, incluindo modelos avançados como Gemini Pro e Gemini Pro Vision. O acesso é restrito ao uso da API; informações adicionais podem ser obtidas por meio do artigo e do site. [1][2] |
| Gema | Código aberto | Para download API gratuita | Um modelo de linguagem de texto para texto de código aberto adequado para tarefas como controle de qualidade e resumo. Os pesos podem ser baixados para uso no local, e a documentação detalhada é fornecida por meio do documento e do site. [3][4] |
| Código Gemma | Código aberto | Para download | Projetado especificamente para tarefas de programação, este modelo de código aberto oferece pesos para download para ajudar os desenvolvedores na geração de código e atividades semelhantes. Consulte o artigo associado, a postagem do blog e a coleção Hugging Face para obter mais informações. [5][6][7] |
Este é um wrapper Python derivado do projeto Bard API, projetado para recuperar respostas do Gemini Web no formato REST. Os clientes síncronos são preferidos aos assíncronos para Gemini devido a preocupações com limitação e bloqueio de taxa.
pip install python-gemini-api
pip install git+https://github.com/dsdanielpark/Gemini-API.git
Para a versão atualizada, use o seguinte:
pip install -q -U python-gemini-api
Visite https://gemini.google.com/
Com o navegador aberto, tente primeiro coletar cookies automaticamente.
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 ) (Manualmente) F12 para console do navegador → Session: Application → Cookies → Copie o valor de alguns conjuntos de cookies funcionais. Se não funcionar, vá para a etapa 3.
Primeiro tente __Secure-1PSIDCC sozinho. Se não funcionar, use __Secure-1PSID e __Secure-1PSIDTS . Ainda sem sucesso? Experimente estes quatro cookies: __Secure-1PSIDCC , __Secure-1PSID , __Secure-1PSIDTS , NID . Se nada funcionar, prossiga para a etapa 3 e considere enviar o arquivo cookie inteiro.
(Recomendado) Exporte cookies do site Gemini por meio de uma extensão do navegador. Por exemplo, use a extensão ExportThisCookies do Chrome, abra e copie o conteúdo do arquivo txt.
Importante
Experimente diferentes contas do Google e configurações do navegador para encontrar um cookie funcional. O sucesso pode variar de acordo com o IP e o status da conta. Uma vez conectado, um cookie normalmente permanece em vigor por mais de um mês. Continue testando até obter sucesso.
Gerar conteúdo: retorna resposta analisada.
from gemini import Gemini
cookies = { "<key>" : "<value>" } # 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 . payloadGere conteúdo a partir da imagem: você pode usar a imagem como entrada.
from gemini import Gemini
cookies = { "<key>" : "<value>" }
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 Observação
Se o método generate_content retornar uma carga vazia, tente executá-lo novamente sem reinicializar o objeto Gemini.
Configurando o idioma e a versão do Gemini usando variáveis de ambiente:
Configurando o idioma de resposta do Gemini (opcional): verifique os idiomas suportados aqui. O padrão é inglês.
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". Por favor, declare explicitamente cookies no formato dict. Você também pode inserir o caminho para o arquivo que contém o cookie com cookie_fp (*.json, *.txt suportado). Verifique os arquivos de cookies de amostra na pasta de ativos.
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 Para que auto_cookie seja definido como True e ajuste target_cookies . Gemini WebUI deve estar ativo no navegador. O browser_cookie3 permite a coleta automática de cookies, embora as atualizações possam não estar concluídas ainda.
Retorna a resposta do Gemini, mas a primeira pode estar vazia.
from gemini import Gemini
cookies = {}
client = Gemini ( cookies = cookies )
prompt = "Tell me about Large Language Model."
response = client . generate_content ( prompt )
print ( response . payload )Importante
NÃO envie o mesmo prompt repetidamente. Se a sessão for conectada com sucesso e generate_content funcionar bem, FECHE o site do Gemini. Se o Gemini Web permanecer aberto no navegador, os cookies poderão expirar mais rapidamente.
A saída da função generate_content é GeminiModelOutput , com a seguinte estrutura:
Gemini-API/gemini/src/model/output.py
Linha 16 em fdf064c
Enviar solicitação: retorna o payload e o status_code da solicitação, facilitando a depuração.
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 ) Você pode acompanhar o número total de solicitações feitas acessando a propriedade request_count dentro da classe Gemini .
Retorna texto gerado pelo 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 )Retorna imagens geradas pelo Gemini.
Downloader assíncrono
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")Exibir imagens no IPython Você pode exibir a imagem ou transmiti-la para outro aplicativo em formato de byte.
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 )Sincronizar downloader
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 download assíncrono
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 )) Lógica do método 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 ))Observação
Use GeminiImage para processamento de imagens. web_images funciona sem cookies, mas para imagens como generated_image do Gemini, passe cookies. Os cookies são necessários para baixar imagens do armazenamento do Google. Verifique a resposta ou use a variável de cookies existente.
Retorna imagens em resposta de Gêmeos.
Downloader assíncrono
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")Sincronizar downloader
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 download assíncrono
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" )) Lógica do método 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" ))Pega uma imagem como entrada e retorna uma resposta.
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 )Para começar, você deve vincular o Google Workspace para ativar esta extensão por meio da extensão da web Gemini. Consulte o aviso oficial e revise as políticas de privacidade para obter mais detalhes.
sinalizadores de extensão
@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_dictGoogle Workspace
Google Mapas
Google Voos
Google Hotéis
YouTube
Você pode especificar uma resposta específica definindo seu ID de candidato de resposta (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 = NoneNo Gemini, generate_content retorna a primeira resposta. Isso pode variar dependendo do comprimento ou da classificação. Portanto, você pode especificar o índice da resposta escolhida de 0 a n da seguinte forma. No entanto, se houver apenas uma resposta, reverta-a para 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 = 0Analise o texto de resposta para extrair os valores desejados.
Usando Gemini.generate_custom_content , especifique a análise customizada para extrair valores específicos. Utilize ParseMethod1 e ParseMethod2 por padrão e você pode passar métodos de análise personalizados como argumentos, se desejar. Consulte 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 )API Gemini/gemini/client.py
Linha 323 em 31b8424
Se você quiser evitar solicitações bloqueadas e banimentos, use o Smart Proxy da Crawlbase. Ele encaminha suas solicitações de conexão para um endereço IP giratório aleatoriamente em um conjunto de proxies antes de chegar ao site de destino. A combinação de IA e ML torna mais eficaz evitar CAPTCHAs e bloqueios. O argumento no nível Secure Sockets Layer (SSL) pode precisar ser adicionado ao cabeçalho. Use-o em conjunto com 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." )Para casos padrão, use a classe Gemini; para exceções, use objetos de sessão. Ao criar um novo servidor bot Gemini, ajuste 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." )Explore recursos adicionais neste documento.
Se quiser desenvolver seu próprio código simples, você pode começar com este exemplo de código simples.
Prepare os itens necessários e obtenha uma chave API no Google AI Studio. Instale no Python 3.9 ou superior e insira a chave API emitida. Consulte o tutorial para obter detalhes.
pip install -q -U google-generativeai
import google . generativeai as genai
GOOGLE_API_KEY = "<your_gemini_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 )Se você tiver recursos de GPU suficientes, poderá baixar os pesos diretamente em vez de usar a API Gemini para gerar conteúdo. Considere Gemma e Code Gemma, modelos de código aberto disponíveis para uso local .
Os modelos Gemma são modelos de linguagem leves e avançados de texto para texto, somente decodificadores, derivados da pesquisa Gemini. Disponíveis em inglês, oferecem pesos e variantes abertas, ideais para tarefas como resposta a perguntas e resumos. Para mais informações, visite a placa modelo Gemma-7b.
