SDSC/open-pulse-hackathon-data-analysis huggingface dataset:
Repository: MarkusUrbanPersonal/connect_global_app
Description: A new app to connect with people developed at LauzHack 2024
Primary language: JavaScript
Topics: application, flowbite, html, javascript, tailwindcss

<p align="center">
  <img style="margin-left:auto;margin-right:auto;" src="https://github.com/user-attachments/assets/7d653a56-c534-48ae-8bb6-f9de00d57656" alt="drawing" width="250" />
</p>
<br>
<p align="center">
<img src="https://github.com/user-attachments/assets/cf338bc9-883f-48a0-8ca8-bc6f802f58c4" width="400">
</p>

![Banner](https://github.com/user-attachments/assets/7b7b13a8-68ab-4ad2-998a-b61804584fc2)

<!--<img src="https://github.com/user-attachments/assets/748ac5a9-5cf6-4d2b-a5fd-0324609400ab">-->

### **The concept** ☀️
Meeting people can be challenging, especially when travelling or attending events like Hackathons. This is where **Connect** comes in. 

### **How it works** 📱

#### **1. Create an account**
To join the app, you'll have to fill some basic information. 

<img src="https://github.com/user-attachments/assets/16ad260a-cd0e-48a8-931f-6f1aea2e89e2" width="200">

#### **2. Join a group**
After joining, you can select the event that you're attending, that could be almost anything. There could even be groups for university classes, office employees or even neighbourhoods!

<img src="https://github.com/user-attachments/assets/2de92139-a682-4c0e-9959-3f894dd16135" width="200">

#### **3. Select your interests**
This interests include main topics, but the list can be tailored to any specific event. There's also a search bar to find more interests. 

<img src="https://github.com/user-attachments/assets/fca1718b-c911-4a20-a8bf-9fe89dc55105" width="200">

#### **4. Discover similar users**
After adding your interests, other members with similar interests start to appear on the main screen. Hooray! 

<img src="https://github.com/user-attachments/assets/f9c4d4a7-4cfc-49b6-a29f-364083830f6d" width="200">

#### **5. Make new connections**
You can check your common interests and start a conversation. **Making new connections has never been easier!** ☀️

<img src="https://github.com/user-attachments/assets/c3d04c1c-89c1-43b0-9ee9-28a5e8af3559" width="200">


### Tech Stack
The web-app has been created using:
  
  🔵 **HTML**
  
  🟢 **CSS**
  
  🟨 **Javascript**
  
  ✨ **Flowbite** *(UI Components)*

  🐍 **Python** *(basic backend)*


### **The future** ✨
What about going one step further, and using *bluetooth* to actually connect users, as they're walking through common areas? The phone could display the common interests and conversation would start instantly. That is a future vision for this project. Until then, **Connect** is a great way to meet with new people at all kind of events. 

<p align="right">
  <img src="https://github.com/user-attachments/assets/4eefaf24-f4ca-4d93-a199-249804f0ed41" width="200">
</p>
Repository: MarognaLorenzo/lauzhack
Primary language: Kotlin

# PawPilot - Your AI Assistant

Welcome to PawPilot, an intelligent Android application developed for LauzHack. Pilot is designed to be your personal AI companion, using computer vision and text to speech to understand your environment and help you navigate it.

## Key Features

- **Visual Analysis:** Pilot can periodically capture images from your device's camera to analyze and understand your surroundings.
- **Intuitive & Responsive UI:** The app features a clean, minimalistic interface with a central pulsating button that visually communicates its current state: inactive (gray), capturing images (blue).
- **Haptic Feedback:** Enjoy subtle vibrations that provide tactile confirmation of your actions, making the experience more intuitive.

## How to Use

1.  **Start/Stop Visual Analysis:** Tap the central button to begin or end the visual analysis. When active, the button will turn blue and pulsate.
3.  **View Transcription:** The recorded audio will be automatically transcribed, and the resulting text will be read to the user outloud.

## Setup for Developers

1.  **Clone the Repository:**
    ```bash
    git clone <repository-url>
    ```
2.  **Open in Android Studio:** Open the cloned project in Android Studio.
3.  **Add Your API Key:** To enable audio transcription, you'll need to add your Together AI API key. Open the `MainActivity.kt` file and replace the placeholder with your actual key:
    ```kotlin
    // In app/src/main/java/com/example/lauzhack/MainActivity.kt
    
    // ... inside the handleLongPressEnd function
    val text = TogetherTranscription.transcribeAudio(
        filePath = outputFile,
        apiKey = "YOUR_API_KEY_HERE" // <-- Add your key here
    )
    ```
4.  **Build and Run:** Build and run the app on an Android device or emulator.

---

*This project was proudly created during the LauzHack event, showcasing the power of combining modern Android development with cutting-edge AI.*
Repository: Marta0805/2025LauzHack_SBB_Challenge-AETT
Primary language: JavaScript

AETT – Anonymous E-Ticket Toolkit

LauzHack 2025 project – privacy-friendly public transport tickets.

1. Idea

Today: every digital ticket is linked to a real identity (credit card, app account, phone).
Goal: anonymous but verifiable tickets.

AETT = small end-to-end prototype:

User Wallet – buy & store multiple QR tickets

Conductor Scanner – validate tickets (camera or “simulate scan” input)

Backend (FastAPI) – stateless tickets signed with HMAC

2. What problem do we solve?

- Passenger can buy a ticket without account or name

- Ticket can be checked by many conductors, many times

- Copying the QR is useless (backend state + signature)

- Optional “virtual card” for perks, still pseudonymous

3. Architecture
Backend (FastAPI, Python)

Issues signed tokens (mini-JWT, HS256) with:

ticket_type (single, day, monthly)

zone

origin, destination (free-text addresses)

optional personalized_id and card_id

validity window (iat, exp)

Endpoints:

POST /tickets/buy – create ticket

POST /tickets/verify – validate token, return metadata

GET /health – health check

Stateless: everything is in the token + HMAC.

In-memory “cybertrack” chain for extra tamper-evidence (optional).

User Wallet App (React)

Buy anonymous ticket from address → address

Show Google Maps iframe preview of the route

Generate QR code from the opaque token

Store multiple tickets in a local wallet (localStorage)

Split into:

Active tickets (countdown, status pill)

Expired history

Optional:

Personalized ID (nickname / SwissPass-like id)

Virtual AETT Card tab:

creates local CARD-… id

shows QR + card id

future tickets can embed card_id (pseudonymous perks)

Conductor Scanner App (React)

Live camera scan (react-qr-reader)

Simulate scan text input:

paste token from wallet

click “Verify” → calls /tickets/verify

perfect for the demo when camera is flaky

Shows:

VALID / INVALID

reason (expired / bad signature / wrong issuer…)

route, ticket type, zone, expiry time

first check vs. re-check for the same ticket

4. Demo Flow

Start backend: uvicorn main:app --reload

Start wallet app on port 3000

buy a day ticket

show QR + map preview + countdown

Start conductor app on port 3001

copy token from wallet

paste into “Simulate scan” → ✅ VALID

show that multiple scans are allowed, with “already checked at …” info

5. Why this matters

Copy-safe: each ticket has unique ID + state, backend detects duplicates.

Anonymous by default: no name, no card, only route + type + time.

Optional identity: virtual card + personalized ID for discounts or loyalty.

Realistic: aligns with Swiss public transport setup (multi-leg trips, multiple checks, address-based travel).

6. Tech stack

Backend: Python, FastAPI, HMAC mini-JWT

Frontend: React, qrcode.react, react-qr-reader

Storage: in-memory + browser localStorage (for demo)
Repository: MatscoSan/Detection_for_bank_employee
Primary language: HTML

# Bank Employee Fraud Detection

A lightweight system analyzing bank employee transactions and
identifying suspicious behavior.

## What is This?

This project provides a simple interface for viewing employee risk
levels, transaction patterns, and network connections. It highlights
unusual activity based on transaction volume, countries, and
salary-adjusted metrics.

## Quick Start

### Start the Server

``` bash
python3 -m http.server 8000
```

Then open:

    http://localhost:8000

## Features

### Risk Analysis

-   Detects transactions inconsistent with salary
-   Flags international or unusual transfers
-   Categorizes employees by risk level

### Network Graph

-   Visualizes connections between customers 
-   Clickable nodes for quick navigation
-   Filtration by countries 


## Structure

    /
    ├── index.html
    ├── employees/
    ├── data/
    └── assets/
Repository: Mycelium-Lauzhack2023/WebUI
Primary language: Vue

# Mycelium WebUi

# Description
Project Mycelium Frontend is a Vue.js-based user interface designed to
seamlessly interact with our autonomous mobile robot fleet. This intuitive web
application empowers users to effortlessly assign zones for AGVs (Automated
Guided Vehicles) to navigate, while providing real-time visibility into the
solution returned by the advanced path planner.

# Key Features
- Zone Assignment: Easily define target zones for AGVs to navigate within various environments.
- Real-time Visualization: Instantly visualize the solution generated by the path planner for optimized navigation.
- Mobile Compatibility: Accessible on a range of devices, including iPads and smartphones, for on-the-go logistics management.

# Getting Started
- Clone the repository: git clone https://github.com/Mycelium-Lauzhack2023/WebUI
- Install dependencies: npm install
- Start the development server: npm run serve
- Open the application in your browser at http://localhost:8080

# Usage
- Access the web UI through your preferred browser.
- Define target zones by interacting with the user-friendly interface.
- Witness real-time updates as AGVs autonomously navigate to assigned zones.

# Dependencies
- ependencies listed in package.json

# License
- This project is licensed under the [MIT License](LICENSE).

# Contact
- For inquiries and support, contact me at [aman.tifli@gmail.com](mailto:aman.tifli@gmail.com)

## NPM commands
```
npm install
```

### Compiles and hot-reloads for development
```
npm run serve
```

### Compiles and minifies for production
```
npm run build
```

### Lints and fixes files
```
npm run lint
```

### Customize configuration
See [Configuration Reference](https://cli.vuejs.org/config/).
Repository: Mycelium-Lauzhack2023/restapi
Primary language: Go

# Project Mycelium RESTful service

# Description
This project is a Golang-based RESTful web service using GIN,
serving as the intermediary between the path planner and the frontend. This
service efficiently retrieves information from the planner, processes it, and
prepares the data for seamless integration with the Vue.js frontend.

# Key Features
- RESTful API: Exposes a clean and efficient API for communication with the frontend.
- Data Processing: Gathers information from the path planner and formats it for real-time consumption by the frontend.
- Scalable and Performant: Built on GIN, known for its speed and minimalistic design, ensuring optimal performance.

# Getting Started
- Clone the repository: git clone https://github.com/Mycelium-Lauzhack2023/restapi
- Install dependencies: go get ./...
- Build and run the server: go run main.go
- The server will be accessible at http://localhost:8081

# API Endpoints
- GET /api/path: Retrieve path information from the path planner.
- Add any additional endpoints as needed.

# Configuration
- Modify the config.yaml file to adjust server settings, planner connection details, etc.

# Dependencies
- GIN: github.com/gin-gonic/gin
- Add any other dependencies to go.mod

# License
- This project is licensed under the [MIT License](LICENSE).

# Acknowledgments
- Mention any third-party libraries, tools, or frameworks used.

# Contact
- For inquiries and support, contact us at [your-email@example.com](mailto:your-email@example.com).
Repository: Mycelium-Lauzhack2023/robot-simulator
Primary language: Python

# Project Mycelium: robot-simulator

Project Mycelium addresses the problem of logistic bottleneck by introducing a fleet of autonomous robots capable of dynamically navigating diverse environments.
This fleet of autonomous robots have applications in multiple sectors, such as healthcare, retail, manufacturing and entertainment.

In this repository, a bespoke robot simulator is implemented to simulate a fleet of autonomous robots.
It also contains a bespoke navigation stack to enable these robots to navigate to any predifined target position.

## Demo

The 3 agents (blue) in the GIF below are navigating to their goal position autonomously.
There is no pre-programmed path.

![Fleet of autonomous agents](https://github.com/Lauzhack2023/robot-simulator/blob/main/autonomous_multi_agent_navigation.gif)

For this demo, the RRT* Algorithm is used as the planner in the navigation stack.

![RRT visualization](https://github.com/Lauzhack2023/robot-simulator/blob/main/RRT.gif)

This project is developed as part of the LauzHack 2023 event.
Team members: Dominic Wong, Muhammad Aman
Repository: Olivera2708/VibeCodingAgent
Description: LauzHack Hackathon project
Primary language: TypeScript

# LauzHack API

A React component generator API powered by AI agents. This system uses an orchestrator to plan components and parallel junior dev agents to implement them.

## Setup

### Backend Setup

1. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```

2. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

3. Create a `.env` file with your API keys:
   ```env
   # API Keys
   TOGETHER_API_KEY=your_together_api_key_here
   GEMINI_API_KEY=your_gemini_api_key_here
   OPENAI_API_KEY=your_openai_api_key_here

   # Model Configuration
   ORCHESTRATOR_MODEL=gemini-3-pro-preview
   JUNIOR_DEV_MODEL=Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8

   # Base URLs
   ORCHESTRATOR_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/
   JUNIOR_DEV_BASE_URL=https://api.together.xyz/v1
   ```

### Frontend Template

The frontend template is a React + TypeScript + Vite + Tailwind CSS + shadcn/ui setup located at `app/frontend_template/`.

Components included:
- Button, Card, Input, Label, Select, Textarea
- Dialog, Dropdown Menu, Avatar, Badge, Switch, Checkbox

## Running the App

### Start the Backend Server

```bash
uvicorn app.main:app --reload
```

The API will be available at `http://127.0.0.1:8000`.

### Run the Frontend Template (Optional)

```bash
cd app/frontend_template
npm install
npm run dev
```

The frontend will be available at `http://localhost:5173`.

## Documentation

Interactive API documentation is available at:
- Swagger UI: `http://127.0.0.1:8000/docs`
- ReDoc: `http://127.0.0.1:8000/redoc`

## API Endpoints

### `POST /api/v1/instructions/process`

Process natural language instructions and generate a React component template.

**Request Body:**
```json
{
  "instructions": "Create a user profile card with avatar, name, and email",
  "session_id": "optional-session-id"
}
```

**Response:**
- If the orchestrator needs clarification: Returns a question
- If successful: Returns a zip file containing the generated React template

## Architecture

1. **Orchestrator Agent**: Analyzes user instructions and creates a detailed component plan
2. **Junior Dev Agents**: Multiple agents work in parallel to implement each component
3. **Template Builder**: Combines implementations with the base template and returns a zip file

## Features

- 🤖 AI-powered component generation
- ⚡ Parallel implementation for faster generation
- 🎨 Consistent design with shadcn/ui components
- 📦 Complete project template output
- 💬 Interactive clarification when needed
Repository: R4oulDuk3/bober
Primary language: Python

# Bober Stack 🦫
### LausHack 2024 - BOBST Challenge Project

## Overview
Bober Stack is a full-stack monitoring and control system developed for BOBST packaging company during LausHack 2024. The project name comes from "bober" (beaver) - our mascot representing BOBST's connection to paper and cardboard packaging.

The system provides real-time control and monitoring of a miniature Arduino-operated packaging conveyor belt through a Raspberry Pi interface.

## Architecture
![Architecture Diagram Placeholder]()
- Angular Frontend for user interface
- Spring Boot Backend API
- Prometheus for metrics collection
- Python service on Raspberry Pi
- Arduino-controlled conveyor belt

## Features
- **Real-time Control Panel**
 - 5-step speed control (10-14 units)
 - Power management
 - System status monitoring

   <br>
 
- **Live Metrics Dashboard**: PU usage and frequency, Memory utilization,  Disk usage, System load, Custom application metrics
   
    <br>

- **Alert System**: Real-time system alerts, Multiple severity levels, Visual indicators, Configurable alert rules
   
    <br>

- **Logging Interface**: System events tracking, Operation logs, Error monitoring
   
    <br>

- **BOBST Platform Integration**: Direct access to BOBST operator equipment portal

## Tech Stack
### Frontend
- Angular 17
- TypeScript
- Angular Material UI
- Chart.js
- SCSS

### Backend
- Java 17
- Spring Boot
- Prometheus
- Docker
- Maven

### IoT
- Python
- Raspberry Pi
- Arduino

## Setup Instructions

### Prerequisites
- Node.js and npm
- Java 17
- Maven
- Docker
- Python 3
- Raspberry Pi
- Arduino setup

### Frontend Setup
1. Install dependencies:
```bash
npm install
Repository: R4oulDuk3/lauzhack-2024
Primary language: TypeScript

# Bober Stack 🦫
### LausHack 2024 - BOBST Challenge Project

## Overview
Bober Stack is a full-stack monitoring and control system developed for BOBST packaging company during LausHack 2024. The project name comes from "bober" (beaver) - our mascot representing BOBST's connection to paper and cardboard packaging.

The system provides real-time control and monitoring of a miniature Arduino-operated packaging conveyor belt through a Raspberry Pi interface.

## Architecture
![Architecture Diagram Placeholder]()
- Angular Frontend for user interface
- Spring Boot Backend API
- Prometheus for metrics collection
- Python service on Raspberry Pi
- Arduino-controlled conveyor belt

## Features
- **Real-time Control Panel**
 - 5-step speed control (10-14 units)
 - Power management
 - System status monitoring

   <br>
 
- **Live Metrics Dashboard**: PU usage and frequency, Memory utilization,  Disk usage, System load, Custom application metrics
   
    <br>

- **Alert System**: Real-time system alerts, Multiple severity levels, Visual indicators, Configurable alert rules
   
    <br>

- **Logging Interface**: System events tracking, Operation logs, Error monitoring
   
    <br>

- **BOBST Platform Integration**: Direct access to BOBST operator equipment portal

## Tech Stack
### Frontend
- Angular 17
- TypeScript
- Angular Material UI
- Chart.js
- SCSS

### Backend
- Java 17
- Spring Boot
- Prometheus
- Docker
- Maven

### IoT
- Python
- Raspberry Pi
- Arduino

## Setup Instructions

### Prerequisites
- Node.js and npm
- Java 17
- Maven
- Docker
- Python 3
- Raspberry Pi
- Arduino setup

### Frontend Setup
1. Install dependencies:
```bash
npm install
Repository: Sagar-CK/ubs-lauzhack
Description: team andy
Primary language: Jupyter Notebook

# LauzHack - 2024 
## Team Andy
> Members: Neel Lodha, Manu Gautam, Sagar Chethan Kumar, Atilla Colak

This repository contains the solution for the LauzHack 2024 hackathon UBS challenge. We document our exploratory data analysis, model building, and submission process in this repository.

Thanks to the challenge organizers for providing us with the opportunity to work on this interesting problem statement!

*Note: The contents of the `data/` directory have been omitted from this repository due to the large file sizes. If trying to replicate, please source the ubs challenge files and place them in the root `data/` directory before running the code.*
Repository: SpaceMercury/LauzHawkathon
Primary language: Jupyter Notebook

# LauzHawkathon



# LauzHawkathon

This project will be for time series forecasting. It aims to develop models and algorithms to predict future values based on historical data.# LauzHawkathon

## Tasks

- [ ] **Define the Problem Statement**
  - [x] Clearly outline the objectives and goals of the forecasting project.
  - [ ] Identify the key metrics for evaluation.

- [x] **Data Collection**
  - [x] Gather historical data relevant to the forecasting problem.
  - [x] Ensure data quality and completeness.

- [x] **Data Preprocessing**
  - [x] Handle missing values and outliers.
  - [x] Normalize or standardize the data if necessary.
  - [x] Split the data into training and testing sets.

- [x] **Exploratory Data Analysis (EDA)**
  - [x] Visualize the data to understand trends, seasonality, and patterns.
  - [x] Perform statistical analysis to gain insights.

- [x] **Feature Engineering**
  - [x] Create new features that may help improve the model's performance.
  - [x] Select the most relevant features for the model.

- [] **Model Selection**
  - [ ] Choose appropriate time series forecasting models (e.g., ARIMA, LSTM, Prophet).
  - [ ] Justify the choice of models based on the problem and data characteristics.

- [ ] **Model Training**
  - [ ] Train the selected models on the training data.
  - [ ] Tune hyperparameters to optimize model performance.

- [ ] **Model Evaluation**
  - [ ] Evaluate the models using the testing data.
  - [ ] Compare model performance using metrics such as MAE, RMSE, and MAPE.

- [ ] **Model Deployment**
  - [ ] Deploy the best-performing model to a production environment.
  - [ ] Set up a pipeline for continuous monitoring and updating of the model.
Comprehensive User Interface (UI):

- [x] **Intuitive UI**
  - [x]Includes visualization features for historical data, trends, and exploratory analysis.
  - [x]Responsive design for seamless use across various devices.
  - [x]Code Clarity and Maintainability:

- [x] **Maintainability**
  - [x]Well-documented functions and modules for ease of understanding and collaboration.
  - [x]Modular architecture to enable scalability and ease of updates.
  - [x]Test-Driven Development (TDD):

- [x] **Code reliability**
  - [x] High test coverage achieved across key modules.
  - [x] Continuous integration pipeline set up for automated testing and error detection.
  - [x] Data Quality and Integrity: Comprehensive preprocessing pipeline to handle missing values, outliers, and data inconsistencies. Statistical and visual checks integrated to ensure data completeness and readiness for modeling.
  
- [x] **Documentation**
  - [x] Document the entire process, including data sources, preprocessing steps, model selection, and evaluation results.
  - [x] Update the `README.md` file with relevant information and instructions.

- [ ] **Maintenance**
  - [ ] Monitor the model's performance over time.
  - [ ] Update the model as new data becomes available or as the underlying patterns change.
Repository: Stargix/UBS-LauzHack
Primary language: Jupyter Notebook

# Entity Resolution System

## Transaction Identity Matching for Financial Services

An advanced entity resolution model developed during LauzHack 2024 in Switzerland that identifies and groups transactions belonging to the same external entities, even when their true identities are obscured.

## Project Overview

This project was created in response to UBS's challenge at LauzHack 2024. Our system employs sophisticated modeling techniques to uncover hidden relationships between financial transactions, allowing for accurate entity mapping despite identity obfuscation.

## Key Features

- **Identity Matching**: Identifies when seemingly separate transactions belong to the same external entity
- **Transaction Clustering**: Groups related transactions to reveal patterns and relationships
- **Entity Resolution**: Uncovers true identities of external parties across multiple transactions
- **Pattern Recognition**: Detects common signatures that indicate same-entity origin

## Technical Challenge

The project presented several complex technical hurdles:
1. Working with obfuscated identity data
2. Creating reliable matching algorithms despite limited identifiers
3. Balancing precision and recall in entity resolution
4. Processing and analyzing large transaction datasets efficiently

## Development Process

Our team tackled this ambitious challenge by:
- Analyzing transaction patterns to identify potential identity markers
- Developing algorithmic approaches to match entities across different transactions
- Creating clustering methods to group transactions by probable entity
- Testing and refining our models under tight hackathon constraints

## Applications

This entity resolution system has potential applications in:
- Anti-money laundering (AML) operations
- Fraud detection
- Customer relationship management
- Regulatory compliance
- Risk assessment

## Team Members

- Paula Esteve
- Sergi Flores
- Clàudia Gallego

## Acknowledgements

Special thanks to UBS for presenting such a challenging and educational problem, and to the LauzHack 2024 organizers for creating an outstanding event environment that fostered innovation and collaboration.

## Learning Outcomes

The project provided valuable experience in:
- Advanced modeling techniques
- Problem-solving under pressure
- Cross-functional team collaboration
- Handling complex financial data structures
- Entity resolution methodologies
Repository: TuanDangNguyen2003/UBS-Oracle-Lauzhack2025
Primary language: Python

# UBS — Oracle Agent Spec: Fraud & Money Laundering Detection

Project applying Oracle's Agent Spec to detect fraudulent activity and money laundering patterns in a transaction dataset provided by UBS.

## Purpose
- Prototype an agent-driven pipeline that combines Oracle Agent Spec orchestration with data science and ML techniques to:  
    - detect anomalies and suspicious transaction patterns  
    - prioritize alerts for analyst review  
    - provide explainable signals to support compliance workflows

## Key Features
- Agent-based orchestration using Oracle Agent Spec principles (modular agents for ingestion, feature engineering, detection, and explainability)
- Supervised and unsupervised detection models (rule-based, anomaly detection, graph analysis, classifiers)
- Explainability artifacts for flagged cases (feature importances, counterfactual hints)
- Audit-friendly logging and data handling to meet compliance/privacy requirements

## Dataset
- Uses the transaction dataset provided by UBS (sensitive; access restricted)
- All data processing follows privacy and compliance constraints (anonymization, minimal retention, role-based access)
- Do not commit raw data to the repo

## Architecture (high-level)
- Ingestion Agent: validates and normalizes incoming transaction feeds
- Feature Agent: computes time-window features, aggregations, network/graph features
- Detection Agent(s): ensemble of detectors (rules, clustering/anomaly, supervised models)
- Triage Agent: scores and ranks alerts, attaches explanations
- Orchestration: agents communicate via standard Agent Spec messages; retries and audit logs

## Evaluation
- Metrics: precision, recall, F1, ROC-AUC for labeled cases; precision@k and alert workload for operational tuning
- Backtesting on historical labeled incidents; synthetic scenarios for edge cases
- Human-in-the-loop validation and feedback loop to retrain models

## Quickstart
1. Place UBS dataset in a secure, local directory (do NOT commit).
2. Create a virtual environment and install dependencies:
     - python >= 3.9
     - pip install -r requirements.txt
3. Configure credentials and sensitive paths in config/.env (examples provided in config/.env.example)
4. Run ingestion and a short pipeline run:
     - python -m agents.ingest --input /path/to/data
     - python -m agents.run_pipeline --config config/pipeline.yaml

(See docs/ for full deployment and agent-spec mapping.)

## Ethics & Compliance
- Designed for lawful, privacy-preserving use only
- Sensitive-data handling, access control, and explainability prioritized
- Intended to assist analysts — final decisions remain human responsibility

## Contributing & License
- Contributing: follow internal compliance and data handling guidelines before submitting code or experiments
- License: MIT (or internal UBS license as required)

Contact: project owners and compliance team listed in docs/OWNERS
Repository: VictorPaniello/bms-lauzhack-2024
Primary language: JavaScript

This project is a Next.js application developed to display interactive time series forecasting for the sales data of Bristol Myers Squibb. The primary dataset used for this analysis is INNOVIX_Floresland.xlsx.

First of all, we have made an intense preprocessing with Python in order to have all the data in one sheet, instead of having one variable per sheet. With this preprocessing, we have used a KNN in order to impute missing values. Then, three distinct models were explored to forecast the time series:

- Long Short-Term Memory (LSTM): A neural network-based approach suited for sequential data.
- Exponential Smoothing State Space Model (ETS): A robust statistical method for time series analysis.
- Autoregressive Integrated Moving Average (ARIMA): A widely-used statistical model for forecasting time-dependent data.

After evaluating the performance of these models, ARIMA emerged as the most accurate model. It was subsequently chosen for forecasting the sales data.

We also have made a webpage in Next.js in where we can upload our data and it will forecast it automatically by connecting to a Node.js backend. You can also change data interactively in the page, and arrange some parameters. It is visually attractive and simple. 

It is a user-friendly interface, designed to be visually attraactive and straightforward.

This is a [Next.js](https://nextjs.org) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).

## Getting Started

First, run the development server:

```bash
npm run dev
# or
yarn dev
# or
pnpm dev
# or
bun dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

You can start editing the page by modifying `app/page.js`. The page auto-updates as you edit the file.

This project uses [`next/font`](https://nextjs.org/docs/app/building-your-application/optimizing/fonts) to automatically optimize and load [Geist](https://vercel.com/font), a new font family for Vercel.

## Learn More

To learn more about Next.js, take a look at the following resources:

- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial.

You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js) - your feedback and contributions are welcome!

## Deploy on Vercel

The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js.

Check out our [Next.js deployment documentation](https://nextjs.org/docs/app/building-your-application/deploying) for more details.
Repository: bogdan-boucher/Smoles
Description: Smart insole connected to an app
Primary language: C++

# Smoles
Smart insole connected to an app for a Hackathon.
In developpement (things should be added later)

A preview of the thing so far :

<img src="https://github.com/user-attachments/assets/4b3697a9-4754-47d6-a3e2-e28d80166c97" width="500"/>
Repository: abilevi5/FitHeart-with-Kangi
Description: App for HCM patients

# FitHeart-with-Kangi
#App for HCM patients, created as part of Bristol Myers Squibb challenge for LauzHack 2023

#LINK TO FIGMA

https://www.figma.com/file/wtt9Iwa307vSEpyLXssNGc/Lauzhack-BMS?type=design&node-id=0-1&mode=design&t=y20aqk0HELj5z5iS-0

#LINK TO MIRO

https://miro.com/app/board/uXjVNHhUUs8=/
Repository: acanadil/LauzRaspberry
Primary language: C++

# LauzBerry

## Backend

To exectute the backend code, you need to have the following libraries installed: HOLA

- gpiozero
- rpi-lgpio
- ina219
- azure-iot-device
- flask

Run the following command to start the backend server:

```bash
cd Backend && python3 main.py
```

## Frontend

The frontend is built using Dart and Flutter. Use any IDE that supports Flutter to run the frontend code.
Repository: baldwinboy/plv
Description: SBB Transportation Efficient Route Generator
Primary language: Python

# SBB Transportation Efficient Route Generator

An application to generate routes that connects travellers to a station within one mile of their location. Made using Solito, Python, GraphHopper, and Docker.

What it can do:
- [X] Search for stations within a 1 mile radius of the traveller's origin
- [] Profile traveller for route priorities, including bicycle use, low emission, reliability, cost, simplicity, and accessibility.
- [] Check parking availability
- [] Identify most efficient station entrances
- [] Live updates
Repository: alexball970/LauzHack2023
Primary language: Jupyter Notebook

# EPFL Polling 🚀

## Goal 🎯
1. Conduct a poll to gather questions for central services (VPT / Presidency).
   - Develop a user-friendly voting platform.
2. Create a project list based on participants' affirmative responses, including available time commitments.
   - Implement a voting platform.
   - Motivate students to engage actively.
3. Foster initiative and inspire community action.

## Implementation 🛠️
  - Reward system for poll participation.
  - Plant a tree on campus for every 5 polls completed.