💎 Google Gemini

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

from google import generativeai as genai
from langchain_google_genai import ChatGoogleGenerativeAI

# Direct API usage
genai.configure(api_key=os.environ["GOOGLE_API_KEY"])

model = genai.GenerativeModel('gemini-1.5-pro')

# Long document processing (1M context)
response = model.generate_content([
    "Analyze this patent document:",
    entire_patent_text,  # 50K+ tokens
    "Extract key claims and prior art references."
])

# Multi-modal (text + images)
response = model.generate_content([
    "Describe the architecture in this diagram:",
    image,  # PIL Image or bytes
    "And how it relates to the following code:",
    code_snippet
])

# LangChain integration
llm = ChatGoogleGenerativeAI(
    model="gemini-1.5-pro",
    temperature=0.1,
    max_output_tokens=8192
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class ModelRouter:
    def __init__(self):
        self.gemini = ChatGoogleGenerativeAI(model="gemini-1.5-pro")
        self.gpt4 = ChatOpenAI(model="gpt-4-turbo")
        self.claude = ChatAnthropic(model="claude-3-opus")
    
    def select(self, task: Task) -> BaseChatModel:
        # Long context → Gemini
        if task.token_count > 100_000:
            return self.gemini
        
        # Multi-modal → Gemini
        if task.has_images:
            return self.gemini
        
        # Complex reasoning → GPT-4
        if task.complexity == "high":
            return self.gpt4
        
        # Creative/nuanced → Claude
        if task.type == "creative":
            return self.claude
        
        # Default: cost optimize
        return self.select_cheapest(task)
    
    def with_fallback(self, primary: str):
        """Create fallback chain"""
        return primary.with_fallbacks([
            self.gemini,
            self.gpt4,
            self.claude
        ])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from vertexai.generative_models import GenerativeModel
import vertexai

# Initialize Vertex AI
vertexai.init(project="your-project", location="us-central1")

# Enterprise-grade Gemini access
model = GenerativeModel("gemini-1.5-pro")

# With safety settings for enterprise
response = model.generate_content(
    prompt,
    generation_config={
        "temperature": 0.1,
        "max_output_tokens": 8192,
    },
    safety_settings={
        "HARM_CATEGORY_HARASSMENT": "BLOCK_MEDIUM_AND_ABOVE",
        "HARM_CATEGORY_HATE_SPEECH": "BLOCK_MEDIUM_AND_ABOVE",
    }
)