Hier is een stapsgewijze gids en voorbeeldcode om je LangChain-agent te integreren met de OpenWeatherMap API, inclusief authenticatie, response-verwerking, en foutafhandeling: 1. Authenticatie: Gebruik de Bearer token methode door je API-sleutel mee te sturen in de Authorization-header. 2. API-aanroepen: Gebruik een HTTP-client zoals `httpx` om API-verzoeken te doen en de responses te verwerken. 3. Limieten en foutafhandeling: Houd rekening met de limiet van 100 calls/uur. Implementeer exponentiële backoff bij fouten. Voorbeeldcode: ```python import time import httpx from langchain.tools import Tool # Je API-sleutel (vervang door je werkelijke sleutel) API_KEY = "jouw_openweathermap_api_key" # Basis URL voor OpenWeatherMap API BASE_URL = "https://api.openweathermap.org/data/2.5/weather" # API-limiet en tracking MAX_CALLS_PER_HOUR = 100 call_count = 0 reset_time = time.time() + 3600 # 1 uur in de toekomst def get_weather(location: str) -> str: global call_count, reset_time # Limietcontrole current_time = time.time() if current_time >= reset_time: # Reset de teller na een uur call_count = 0 reset_time = current_time + 3600 if call_count >= MAX_CALLS_PER_HOUR: return "API-limiet bereikt. Probeer later opnieuw." headers = { "Authorization": f"Bearer {API_KEY}" } params = { "q": location, "appid": API_KEY, "units": "metric" # Voor temperatuur in Celsius } # Exponentiële backoff parameters retries = 0 max_retries = 5 backoff_time = 1 # starttijd in seconden while retries < max_retries: try: response = httpx.get(BASE_URL, headers=headers, params=params, timeout=10) call_count += 1 # Tel de call if response.status_code == 200: data = response.json() weather_desc = data["weather"][0]["description"] temp = data["main"]["temp"] return f"Het weer in {location} is {weather_desc} met een temperatuur van {temp}°C." elif response.status_code == 429: # API-limiet bereikt, wacht en probeer opnieuw time.sleep(backoff_time) backoff_time *= 2 retries += 1 else: return f"Fout bij ophalen weergegevens: {response.status_code}" except httpx.RequestError as e: # Netwerkfout, wacht en probeer opnieuw time.sleep(backoff_time) backoff_time *= 2 retries += 1 return "Kon geen weergegevens ophalen na meerdere pogingen." # Definieer een Tool voor LangChain weather_tool = Tool( name="OpenWeatherMap", description="Haalt het actuele weer op voor een gegeven locatie via de OpenWeatherMap API.", func=get_weather ) ``` Integratie in je LangChain-agent: - Voeg deze tool toe aan je agent. - Vraag de agent om de tool te gebruiken wanneer weerinformatie nodig is. - Bijvoorbeeld: in je prompt of keten logica, roep `OpenWeatherMap` aan met de gewenste locatie. Foutafhandeling en beperkingen: - De code stopt niet, maar wacht bij 429 of netwerkfouten met exponentiële backoff. - Houd de call-teller bij en reset elke uur. - Informeer de gebruiker als het API-limiet is bereikt. Let op: - Vervang `"jouw_openweathermap_api_key"` door je echte API-sleutel. - Pas waar nodig de prompt of logica aan om de tool dynamisch te gebruiken. Heeft u verdere hulp nodig bij het integreren in een volledige LangChain-setup?

Hier is een complete integratiehandleiding voor OpenWeatherMap API met je LangChain agent: ## Authenticatie Configuratie ```python from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent from langchain.requests import RequestsWrapper from langchain.tools import BaseTool import requests import time import os from typing import Optional, Dict, Any # Configuratie (gebruik environment variables voor security) OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY") BASE_URL = "http://api.openweathermap.org/data/2.5" ``` ## Authenticatie Handler ```python class OpenWeatherMapAuth: def __init__(self, api_key: str): self.api_key = api_key self.headers = { "Authorization": f"Bearer {api_key}", "Content-Type": "application/json" } def get_auth_headers(self) -> Dict[str, str]: return self.headers ``` ## API Tool met Foutafhandeling ```python class OpenWeatherMapTool(BaseTool): name = "openweathermap_api" description = "Haal real-time weergegevens op voor een specifieke locatie" def __init__(self): super().__init__() self.auth = OpenWeatherMapAuth(OPENWEATHER_API_KEY) self.call_count = 0 self.last_reset = time.time() def _check_rate_limit(self): """Controleer en handel rate limiting af""" current_time = time.time() if current_time - self.last_reset >= 3600: # Reset elk uur self.call_count = 0 self.last_reset = current_time if self.call_count >= 100: raise Exception("Rate limit bereikt: maximaal 100 calls per uur") self.call_count += 1 def _exponential_backoff(self, attempt: int): """Exponentiële backoff implementatie""" wait_time = (2 ** attempt) + (random.randint(0, 1000) / 1000) time.sleep(wait_time) def _make_request(self, endpoint: str, params: Dict[str, Any], max_retries: int = 3) -> Optional[Dict]: """Maak API request met foutafhandeling""" for attempt in range(max_retries): try: self._check_rate_limit() response = requests.get( f"{BASE_URL}/{endpoint}", headers=self.auth.get_auth_headers(), params=params, timeout=10 ) response.raise_for_status() return response.json() except requests.exceptions.HTTPError as e: if response.status_code == 401: raise Exception("Ongeldige API key of authenticatiefout") elif response.status_code == 404: raise Exception("Locatie niet gevonden") elif response.status_code == 429: self._exponential_backoff(attempt) continue else: raise Exception(f"HTTP fout: {e}") except requests.exceptions.RequestException as e: if attempt == max_retries - 1: raise Exception(f"Netwerkfout na {max_retries} pogingen: {e}") self._exponential_backoff(attempt) def _run(self, query: str) -> str: """Haal weergegevens op voor een locatie""" try: # Parse locatie uit query (bijv. "weer Amsterdam" -> "Amsterdam") location = self._parse_location(query) params = { "q": location, "units": "metric", # Celsius "lang": "nl" # Nederlandse beschrijvingen } data = self._make_request("weather", params) if not data: return "Kon geen weergegevens ophalen" return self._format_weather_data(data) except Exception as e: return f"Fout bij ophalen weergegevens: {str(e)}" def _parse_location(self, query: str) -> str: """Parseer locatie uit gebruikersquery""" # Eenvoudige parsing - kan uitgebreid worden naar behoefte location = query.replace("weer", "").replace("weather", "").strip() return location if location else "Amsterdam" # Default locatie def _format_weather_data(self, data: Dict) -> str: """Formatteer weergegevens voor de agent""" return f""" Weer in {data['name']}: - Temperatuur: {data['main']['temp']}°C - Gevoelstemperatuur: {data['main']['feels_like']}°C - Beschrijving: {data['weather'][0]['description']} - Vochtigheid: {data['main']['humidity']}% - Windsnelheid: {data['wind']['speed']} m/s - Luchtdruk: {data['main']['pressure']} hPa """ async def _arun(self, query: str) -> str: raise NotImplementedError("Async operatie niet ondersteund") ``` ## Agent Integratie ```python from langchain.agents import AgentType, initialize_agent from langchain.llms import OpenAI # Initialiseer tools weather_tool = OpenWeatherMapTool() tools = [weather_tool] # Configureer agent agent = initialize_agent( tools=tools, llm=OpenAI(temperature=0), agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True, handle_parsing_errors=True ) # Voorbeeld gebruik def get_weather_response(user_query: str) -> str: try: response = agent.run(user_query) return response except Exception as e: return f"Er is een fout opgetreden: {str(e)}" ``` ## Environment Configuratie ```bash # .env bestand OPENWEATHER_API_KEY=je_bearer_token_hier ``` ```python # requirements.txt langchain==0.0.235 openai==0.27.8 requests==2.28.2 python-dotenv==1.0.0 ``` ## Gebruiksvoorbeeld ```python # Voorbeeld interactie result = get_weather_response("Wat is het weer in Rotterdam?") print(result) # Output zal zijn: # Weer in Rotterdam: # - Temperatuur: 15°C # - Beschrijving: licht bewolkt # - etc... ``` ## Belangrijke Beperkingen en Foutafhandeling 1. **Rate Limiting**: Maximaal 100 calls per uur 2. **Authenticatie**: Bearer token vereist 3. **Retry Logic**: Exponentiële backoff bij netwerkfouten 4. **Timeout**: 10 seconden timeout per request 5. **Foutcodes**: - 401: Ongeldige API key - 404: Locatie niet gevonden - 429: Too Many Requests - 500+: Serverfouten ## Monitoring en Logging ```python import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # Voeg logging toe aan de _make_request methode logger.info(f"API call naar OpenWeatherMap: {endpoint}") ``` Deze implementatie zorgt voor robuuste integratie met propere foutafhandeling, rate limiting, en dynamische verwerking van real-time weergegevens in je LangChain agent.