KenJes · Proyectos & Demos

GitHub

Repositorios

5 repositorios públicos · 178 contribuciones

TraceTrash

⭐ 1

Sistema integral de rastreo GPS en tiempo real para la recolección municipal de residuos. App móvil Android y panel web.

TypeScript React Native Expo SDK 54 Firebase OpenStreetMap

TypeScript 97% Axoloit

RayGPT · Raymundo

Agente IA multimodal con GPT-4o Vision, Llama 3.3 70B y Whisper STT. Bot de WhatsApp, Google Workspace, Spotify y más.

Python Groq / Llama 3.3 GPT-4o Flask WhatsApp API

Python 96% MIT

PythonProjects

ML, redes neuronales y algoritmos genéticos desde cero. Notebooks Jupyter con implementaciones propias, activo con 15 commits en abril 2026.

Python Jupyter Machine Learning Algoritmos Genéticos

Jupyter 67% · Py 33% Activo

Recursos Pedagógicos

Recursos educativos interactivos con IA generativa: planeadores UAEMéx, juegos de Business Intelligence y generadores de prompts para docentes.

HTML JavaScript IA Generativa Educación

HTML 90% UAEMéx

Pizzapilco

Sitio web para pizzería local. Proyecto de aplicación práctica de desarrollo web con catálogo de productos, pedidos y diseño responsive.

HTML CSS JavaScript

HTML 2024

Demos interactivos

Ve el código en acción

Visualizaciones reales de cada proyecto

TraceTrash · Simulación GPS

3 camiones de recolección en ruta simulada — Tejupilco de Hidalgo, Estado de México

En vivo

Camión 1 · Ruta Norte

Camión 2 · Ruta Centro

Camión 3 · Ruta Sur

Algoritmo Genético · Visualización

Evolución de una población resolviendo el problema del viajante (TSP)

Generación

∞

Mejor distancia

Mejora acumulada

AG Interactivo · Construye tu TSP

Haz clic en el canvas para colocar ciudades, ajusta parámetros y evoluciona

Población: 50

Mutación: 10%

Velocidad: 5x

Clic en el canvas para añadir ciudades

Generación

—

Mejor distancia

Ciudades

Añade 5+ ciudades · El AG usa cruce OX + mutación swap · Selección por torneo

Arquitectura RayGPT · Multi-Agente

Flujo de datos entre componentes del sistema Raymundo

Arquitectura modular de RayGPT · Ver repo completo

Snippets de código

Fragmentos reales de PythonProjects

algoritmos_geneticos/tsp_ga.py

# Algoritmo Genético — Problema del Viajante (TSP)
# PythonProjects · KenJes / Kenneth Alcalá

import random
import math

def distance(a, b):
    return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)

def total_distance(route, cities):
    return sum(distance(cities[route[i]], cities[route[(i+1) % len(route)]])
               for i in range(len(route)))

def crossover(parent1, parent2):
    """Order crossover (OX)"""
    size = len(parent1)
    a, b = sorted(random.sample(range(size), 2))
    child = [-1] * size
    child[a:b] = parent1[a:b]
    remaining = [g for g in parent2 if g not in child]
    j = 0
    for i in range(size):
        if child[i] == -1:
            child[i] = remaining[j]; j += 1
    return child

def mutate(route, rate=0.02):
    """Intercambio aleatorio de dos ciudades"""
    for i in range(len(route)):
        if random.random() < rate:
            j = random.randint(0, len(route)-1)
            route[i], route[j] = route[j], route[i]
    return route

def evolve(population, cities, elite=5):
    scored = sorted(population, key=lambda r: total_distance(r, cities))
    next_gen = scored[:elite]
    while len(next_gen) < len(population):
        p1, p2 = random.choices(scored[:20], k=2)
        child = mutate(crossover(p1, p2))
        next_gen.append(child)
    return next_gen

redes_neuronales/feedforward.py

# Red Neuronal Feedforward desde cero
# PythonProjects · KenJes / Kenneth Alcalá

import numpy as np

class NeuralNetwork:
    def __init__(self, layers):
        self.weights = [np.random.randn(layers[i], layers[i+1]) * 0.1
                        for i in range(len(layers)-1)]
        self.biases  = [np.zeros((1, l)) for l in layers[1:]]

    def sigmoid(self, x): return 1 / (1 + np.exp(-x))
    def sigmoid_d(self, x): s = self.sigmoid(x); return s * (1 - s)

    def forward(self, X):
        self.activations = [X]
        for W, b in zip(self.weights, self.biases):
            X = self.sigmoid(X @ W + b)
            self.activations.append(X)
        return X

    def backward(self, X, y, lr=0.01):
        m = X.shape[0]
        delta = (self.forward(X) - y) * self.sigmoid_d(
            self.activations[-1])
        for i in reversed(range(len(self.weights))):
            dW = self.activations[i].T @ delta / m
            db = delta.mean(axis=0, keepdims=True)
            if i > 0:
                delta = (delta @ self.weights[i].T *
                         self.sigmoid_d(self.activations[i]))
            self.weights[i] -= lr * dW
            self.biases[i]  -= lr * db

core/ai_clients.py (fragmento)

# RayGPT · Cliente de IA multi-modelo
# KenJes/RayGPT · Axoloit

from groq import Groq
import os

client_groq = Groq(api_key=os.environ["GROQ_API_KEY"])

MODELS = {
    "primary":   "llama-3.3-70b-versatile",   # Groq (rápido, gratuito)
    "vision":    "gpt-4o",                      # GitHub Models
    "fallback":  "qwen2.5:7b",                  # Ollama local
}

def chat(messages: list[dict], model_key="primary") -> str:
    """Envía mensajes al modelo activo con fallback automático."""
    model = MODELS[model_key]
    try:
        resp = client_groq.chat.completions.create(
            model=model,
            messages=messages,
            temperature=0.7,
            max_tokens=2048,
        )
        return resp.choices[0].message.content
    except Exception as e:
        # Fallback a Ollama local
        return chat_ollama(messages, MODELS["fallback"])

def build_context(user_id: str, query: str) -> list[dict]:
    """Construye contexto con memoria de conversación por usuario."""
    from core.conversation_db import load_history
    history = load_history(user_id, limit=10)
    return [
        {"role": "system", "content": SYSTEM_PROMPT},
        *history,
        {"role": "user", "content": query},
    ]

KenJes ·

Habla con Raymundo