API Gêmeos
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 completo.
(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 = { "" : "" } # 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
Gere conteúdo a partir da imagem: você pode usar a imagem como entrada.
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
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 = ""
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 obter mais informações, visite o cartão modelo 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, que é um lançamento oficial do Google para LLMs de código, foi lançado em 9 de abril de 2024. Ele fornece três modelos projetados especificamente para gerar e interagir com código. Você pode explorar os modelos do Code Gemma e visualizar o cartão do modelo para obter mais detalhes.
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 oferece inferência gratuita temporária para modelos selecionados. Obtenha uma chave API da API Open Router e verifique os modelos gratuitos em modelos Open Router. Use principalmente modelos com custo de token de 0 dólares; outros modelos podem incorrer em cobranças. Veja mais no guia LLM API de código aberto gratuito.
O cliente de sincronização é preferido ao assíncrono para Gemini devido a problemas de limitação e bloqueio de taxa , mas o OpenRouter oferece LLMs de código aberto confiáveis para implementação assíncrona. (Limite gratuito: 10 solicitações/minuto)
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())A lista de modelos gratuitos inclui:
google/gemma-7b-it:free - google/gemma-7b do Google ***mistralai/mistral-7b-instruct:free - mistralai/Mistral-7B-Instruct-v0.1 para instruções da Mistral AI ****huggingfaceh4/zephyr-7b-beta:free - HuggingFaceH4/zephyr-7b-beta ***openchat/openchat-7b:free - openchat/openchat para bate-papo **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 da Nous Research Use a API Crawlbase para coleta de dados eficiente para treinar modelos de IA, apresentando uma taxa de sucesso de 98% e tempo de atividade de 99,9%. É rápido de iniciar, compatível com GDPR/CCPA, suporta extração massiva de dados e conta com a confiança de mais de 70 mil desenvolvedores.
Primeiro revise HanaokaYuzu/Gemini-API e a API oficial do Google Gemini antes de usar este pacote. Você pode encontrar mais ajuda nas páginas de perguntas frequentes e problemas.
Sinceramente grato por quaisquer relatórios sobre novos recursos ou bugs. Seu valioso feedback sobre o código é muito apreciado. Podem ocorrer erros frequentes devido a alterações na interface da API de serviço do Google. Tanto relatórios de problemas quanto solicitações pull que contribuem para melhorias são sempre bem-vindos. Nós nos esforçamos para manter uma comunidade aberta ativa e cortês.
cave o poço antes que tenha sede.
Gostaríamos de expressar nossa sincera gratidão a todos os colaboradores.
Este pacote visa reimplementar a funcionalidade da API Bard, que foi arquivada para contribuições da amada comunidade de código aberto, apesar da API oficial do Gemini já estar disponível.
Colaboradores da API Bard e da API Gemini.
São necessárias modificações no cliente assíncrono usando minha lógica, juntamente com a coleta automática de cookies via browser_cookie3 e a implementação de outros recursos da API Bard (como extração de código, exportação para Replit, desenho de gráfico, etc.).
Observe que ao analisar a coleta automática de cookies, parece que os cookies expiram imediatamente após o envio de uma solicitação de coleta. Os esforços para torná-lo mais fácil de usar não tiveram sucesso. Além disso, o valor _sid parece funcionar normalmente mesmo quando retornado como None.
Por último, se os algoritmos CustomParser e ResponseParser não funcionarem corretamente, novos métodos de análise poderão ser atualizados por meio de instruções condicionais nas seções relevantes.
Não pretendo fazer a curadoria ativa deste repositório. Revise HanaokaYuzu/Gemini-API primeiro.
Obrigado e tenha um ótimo dia.
Licença MIT, 2024. Por este meio, isentamo-nos veementemente de qualquer responsabilidade legal explícita ou implícita relacionada aos nossos trabalhos. Os usuários são obrigados a usar este pacote de forma responsável e por sua própria conta e risco. Este projeto é uma iniciativa pessoal e não é afiliado nem endossado pelo Google. Recomenda-se usar a API oficial do Google.
Aviso Os usuários assumem total responsabilidade legal pela GeminiAPI. Não endossado pelo Google. O uso excessivo pode levar a restrições de conta. Mudanças nas políticas ou no status da conta podem afetar a funcionalidade. Utilize páginas de problemas e discussões.
Python 3.7 ou superior.
