Construye un monitor de fitness Langchain: tu monitor personal de IA

Muchas personas golpean el recinto con pasión y creen que están en el camino correcto para obtener sus objetivos de acondicionamiento físico. Pero los resultados no están allí oportuno a la mala planificación de la dieta y la desatiendo de dirección. Contratar a un monitor personal contiguo con una costosa pila de gimnasios no siempre es una opción. Es por eso que he creado esta publicación de blog para mostrarle cómo construir su monitor de fitness usando el poder de Langchain. Con esto, ahora puede obtener consejos de entrenamiento y dieta personalizados para sus objetivos con un costo intrascendente. ¡Comencemos tomando una tecnología increíble y convirtiéndola en su copiloto de fitness!

¿Por qué usar Langchain?

Langchain le permite hacer mucho más al construir aplicaciones AI avanzadas combinando modelos de idiomas grandes (LLM) con herramientas, fuentes de datos y memoria. En extensión de invocar el LLM Con un mensaje de texto sin formato, puede crear agentes que invocen funciones, consulta información y administran conversaciones con el estado. Para un monitor de fitness, Langchain le permite combinar la inteligencia LLM con una dialéctica personalizada, por ejemplo, crear sugerencias de entrenamiento, rastrear el progreso y obtener datos de vitalidad, por lo que puede ser un monitor interactivo más inteligente sin tener que resolverlo todo.

Requisitos previos

Para crear su monitor de fitness usando Langchain, necesitará:

• Una esencia API de OpenAI para consentir a modelos de idiomas
• Una esencia para el servicio Serpapi para usar la búsqueda web
• Conocimiento nuclear de Pitón

Eso es todo, ahora estás presto para comenzar.

¿Cómo construir su monitor de fitness?

En esta sección, demostraré cómo hacer que su monitor de fitness use un agente Langchain. Asegúrese de tener todo preparado de acuerdo con los requisitos previos. Te guiaré a través del proceso paso a paso de construir la decisión y explicaré el papel que juega cada paso para obtener el resultado.

FitCoach Ai es un monitor de acondicionamiento físico conversacional que recopila los datos del favorecido de forma consistente y genera planes de entrenamiento y dieta personalizados utilizando agentes de Langchain con OpenAI.

Dependencias del núcleo

Para instalar todas las bibliotecas necesarias para construir el agente de fitness, ejecute el próximo comando en su tilde de comando:

pip install gradio langchain openai serper-dev python-doten

Una vez que todas las dependencias estén en su extensión, comenzaríamos importando todos los módulos relevantes para la tarea:

import os
import gradio as gr
import traceback
import datetime
from typing import List, Tuple, Optional

from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferMemory
from langchain.agents import initialize_agent, AgentType
from langchain.tools import BaseTool
import json
import requests
import dotenv

# Load environment variables
dotenv.load_dotenv()

SerperperSearchTool Clase

Funcionalidad: Proporciona la capacidad de tener capacidades de búsqueda web en tiempo auténtico para información actualizada de fitness/mantenimiento.

Características principales:

• Se integra con la API Serper para obtener resultados de búsqueda de Google
• Devuelve los 5 mejores resultados de búsqueda formateados que incluyen el título, el fragmento y la URL
• Tiene modos de error aceptables con protección de tiempo de prórroga
• Admite tanto sincronización como async

# ----------- SERPER SEARCH TOOL ------------

class SerperSearchTool(BaseTool):
    name: str = "search_web"
    description: str = "Searches the web for real-time information and returns structured results"

    def _run(self, query: str) -> str:
        """Search the web using Serper API"""
        try:
            api_key = os.getenv("SERPER_API_KEY")
            if not api_key:
                return "Error: SERPER_API_KEY not found in environment variables"

            url = "https://google.serper.dev/search"
            payload = json.dumps({"q": query})
            headers = {
                'X-API-KEY': api_key,
                'Content-Type': 'application/json'
            }

            response = requests.post(url, headers=headers, data=payload, timeout=10)
            response.raise_for_status()
            search_results = response.json()

            # Extract and format organic results
            results = ()
            if 'organic' in search_results:
                for item in search_results('organic')(:5):  # Limit to top 5 results
                    results.append({
                        "title": item.get('title', ''),
                        "link": item.get('link', ''),
                        "snippet": item.get('snippet', '')
                    })

            # Format results in a readable way
            if results:
                formatted_results = "Search Results:nn"
                for i, result in enumerate(results, 1):
                    formatted_results += f"{i}. {result('title')}n"
                    formatted_results += f"   {result('snippet')}n"
                    formatted_results += f"   URL: {result('link')}nn"
                return formatted_results
            else:
                return "No search results found."

        except requests.exceptions.RequestException as e:
            return f"Error performing search - Network issue: {str(e)}"
        except Exception as e:
            return f"Error performing search: {str(e)}"

    async def _arun(self, query: str) -> str:
        """Async version of search"""
        return self._run(query)

Clase de usuarios

Funcionalidad: Obtenga toda la información necesaria antiguamente de crear cualquier plan de acondicionamiento físico

Required Data Fields (in order):
Fitness goal (weight loss, muscle gain, etc.)
Age (in range 10-100 validation)
Gender (male/female/other)
Weight (in units, - kg/lbs)
Height (in cm or feet/inches)
Activity Level (5 predefined levels)
Diet Preferences (vegetarian, vegan, etc.)
Diet Restrictions/allergy
Workout-Preferencing & limitations

Características principales:

• Empuje de campo: Cada entrada se validará con funciones de nervio personalizadas.
• Flujo secuencial: Nadie puede saltar delante.
• Manejo de errores: Proporcione mensajes de error específicos para entradas no válidas.

# ----------- USER DATA TRACKER CLASS ------------

class UserDataTracker:
    def __init__(self):
        self.data = {}
        # Define required fields with their validation functions and question prompts
        self.required_fields = {
            'fitness_goal': {
                'question': "What is your primary fitness goal? (e.g., weight loss, muscle gain, normal fitness)",
                'validate': self._validate_fitness_goal
            },
            'age': {
                'question': "How old are you? (Must be between 10-100)",
                'validate': self._validate_age
            },
            'gender': {
                'question': "What is your gender? (male/female/other)",
                'validate': self._validate_gender
            },
            'weight': {
                'question': "What is your current weight? (e.g., 150 lbs or 68 kg)",
                'validate': self._validate_weight
            },
            'height': {
                'question': "What is your height? (e.g., 5'10" or 178 cm)",
                'validate': self._validate_height
            },
            'activity_level': {
                'question': "What is your activity level? (sedentary, lightly active, moderately active, very active, extremely active)",
                'validate': self._validate_activity_level
            },
            'dietary_preferences': {
                'question': "Do you follow any specific diet? (e.g., vegetarian, vegan, keto, none)",
                'validate': self._validate_dietary_preferences
            },
            'dietary_restrictions': {
                'question': "Any food allergies or dietary restrictions? (e.g., nuts, dairy, gluten, none)",
                'validate': self._validate_dietary_restrictions
            },
            'workout_preferences': {
                'question': "What are your workout preferences? (e.g., gym, home workouts, equipment available, any injuries?)",
                'validate': self._validate_workout_preferences
            },

        }
        self.current_step = 0

Configuración del agente de Langchain

Inicialización del agente:

• Maniquí: GPT-4O-Mini con temperatura 0.3 para consistencia.
• Memoria: Conversación Buffermemoria para consistencia del contexto.
• Herramientas: Búsqueda web para dejar que el agente busque información en tiempo auténtico.

El initialize_fitcoach_agent La función configura Fitcoach, un agente de conversación Langchain que sirve como monitor de fitness y mantenimiento supuesto. Se conecta al maniquí de idioma GPT-4O-Miniestá potencialmente aumentado por las herramientas de búsqueda web, y realiza un seguimiento de la memoria de conversación para el contexto. El agente sigue una estricta continuidad del diálogo basado en reglas: hace a los usuarios preguntas específicas una a la vez para extraer toda la información importante sobre los objetivos de aptitud física, la etapa, las métricas corporales, los hábitos alimenticios e historial médico, entre otros. Solo luego de todo lo que necesitaba entender que se ha reunido y confirmado, el agente se comprometerá a no producir ningún plan de aptitud o dieta. De esta forma, el agente permite las instrucciones seguras, precisas y personalizadas que los usuarios desean en un agente. Una vez que se ha reunido toda la información necesaria, FitCoach genera rutinas de entrenamiento integrales y planes de comidas basados ​​en el favorecido, al tiempo que ofrece un plan de entrenamiento interactivo y atractivo.

# ----------- LANGCHAIN AGENT SETUP ------------

def initialize_fitcoach_agent():
    """Initialize the FitCoach agent with error handling"""
    try:
        # Check for OpenAI API key
        openai_key = os.getenv("OPENAI_API_KEY")
        if not openai_key:
            raise ValueError("OPENAI_API_KEY not found in environment variables")

        # Initialize the language model with correct model name
        llm = ChatOpenAI(
            model="gpt-4o-mini",
            temperature=0.3,
            openai_api_key=openai_key
        )

        # Initialize tools
        tools = ()
        try:
            if os.getenv("SERPER_API_KEY"):
                search_tool = SerperSearchTool()
                tools.append(search_tool)
                print("✅ Search tool initialized successfully")
            else:
                print("⚠️ SERPER_API_KEY not found - search functionality will be limited")
        except Exception as e:
            print(f"⚠️ Could not initialize search tool: {e}")

        # Initialize memory
        memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

Gradio Chatbot Logic

• IS_PLAN_CONTENT: Determina si un texto determinado tiene un plan de aptitud o mantenimiento detallado al comprobar múltiples palabras esencia, como días de la semana, nombres de comidas y comparaciones de entrenamiento. Ayuda a separar los planes de las conversaciones informales sobre la aptitud física.
• format_plan_for_text: Formatea los textos del plan de acondicionamiento físico en bruto en secciones más limpias mientras se conserva encabezados, listas y párrafos, para mejorar la legibilidad e idoneidad para compartir en el chat o el correo electrónico.
• chat_function: Administra el flujo de chat Fitcoach. Recopila información del favorecido en pasos (objetivo de acondicionamiento físico del favorecido, preferencias de comidas), lumbre al agente de IA para producir un plan de entrenamiento y comidas personalizados y maneja los errores de forma segura para surtir ininterrumpido el flujo de chat.

 ----------- GRADIO CHATBOT LOGIC ------------

def is_plan_content(text: str) -> bool:
    """Check if the text contains a fitness plan with detailed content"""
    if not text or len(text.strip()) < 100:  # Too short to be a complete plan
        return False

    # Check for common plan indicators
    plan_indicators = (
        'workout plan', 'exercise routine', 'training program',
        'meal plan', 'nutrition plan', 'diet plan', 'weekly schedule',
        'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday',
        'sets x reps', 'rest between sets', 'warm up', 'cool down',
        'day 1', 'day 2', 'day 3', 'day 4', 'day 5', 'day 6', 'day 7',
        'breakfast', 'refrigerio', 'dinner', 'snacks', 'meals', 'nutrition',
        'exercise', 'workout', 'training', 'routine', 'program', 'plan'
    )

    # Check for multiple indicators to reduce false positives
    text_lower = text.lower()
    matching_indicators = (ind for ind in plan_indicators if ind in text_lower)

    # Require at least 3 matching indicators to consider it a plan
    return len(matching_indicators) >= 3

Nota: Solo he mostrado partes del código en el artículo. Mi código completo está habitable aquí.

Interfaz de favorecido

Cuando se prostitución de la interfaz de favorecido, puede usar soluciones como Streamlit o Gradio para mantenerla simple. Utilicé Gradio, ya que me permite crear una aplicación web pulida con un diseño personalizado, actualizaciones automáticas y una interfaz rápida y receptiva que se adapte a las aplicaciones de vitalidad y acondicionamiento físico. Hacer clic aquí Para ver el código fuente.

Casos de uso para Langchain

• Bots de soporte al cliente: Cree un asistente que pueda apañarse bases de conocimiento de atención al cliente para encontrar respuestas a las preguntas del cliente.
• Chatbots asistidos por búsqueda: Malicea mapas a fuentes de conocimiento en tiempo auténtico como Google y Wikipedia.
• Preguntas y respuestas de documentos: Permita que el favorecido cargue un PDF y recupere automáticamente respuestas precisas con citas.
• Asistentes de manipulación de datos: Permitir a los usuarios cargar y explorar datos en una hoja de cálculo mientras hace preguntas relacionadas con los datos.
• Herramientas de engendramiento de contenido: Genere contenido, incluidos blogs, correos electrónicos o publicaciones en redes sociales.
• Sistemas de múltiples agentes: Cree sistemas en los que los agentes de IA puedan colaborar o especializarse en la tarea.

Conclusión

Cuando todo está dicho y hecho, AI no se prostitución de tecnología; ¡Se prostitución del funcionamiento interno de cómo disfrutar la tecnología como un poder para mejorar nuestra vida cotidiana! Ya sea para ponerse en forma, engullir admisiblemente o mantenerse motivado, diseñar su propio monitor de acondicionamiento físico personal único es un ejemplo valentísimo de cómo la IA puede apoyar y motivar, pero aún así nos mantiene responsables de nuestras acciones para cumplir con nuestros objetivos. ¡Y la mejor parte es que no tienes que ser un asistente tecnológico para comenzar a construir tu aplicación! Hay una serie de herramientas como Langchain para el avance, OpenAI para capacidades de IA y Gradio para implementar su aplicación inteligente, solo por mencionar algunas, que pueden ayudar a cualquiera a construir aplicaciones inteligentes y únicas para sí mismos. ¡El futuro de la aptitud física, así como muchas otras áreas de la vida, está habitable para nosotros!