Ronny Schrader

In FileMaker große Datenmengen zu verarbeiten, kann schnell zu Performance-Problemen führen. Besonders wenn FileMaker noch im Hintergrund sortiert oder aggregiert, kann die Benutzeroberfläche einfrieren oder es dauert mehrere Sekunden, bis die Daten sichtbar sind. Das Problem stellt sich immer wieder bei Altlösungen die 10 oder 20 Jahre alt sind. Häufig sind diese Datenbanken bis ins kleinste an die Kunden-Prozesse angepasst. Ein Neubau unrealistisch bis unbezahlbar. Performance-Probleme nur in den langen Listenansichten mit Unmengen an Datensätzen, diese dann noch mit Sortierungen und Formelfeldern.

Doch es gibt eine Möglichkeit, Daten sofort anzuzeigen, auch wenn FileMaker noch weiterarbeitet: Daten per POST an einen WebViewer übergeben und dort asynchron anzeigen.

Warum nicht einfach FileMaker-Listen?

Standardmäßig lädt FileMaker Listenansichten synchron – das heißt, es wartet, bis alle Datensätze verarbeitet sind. Das führt zu Problemen, wenn: • Tausende Datensätze geladen werden, • FileMaker noch sortiert, • eine Suche viele Treffer hat, • Zusatzinformationen aus mehreren Tabellen geladen werden müssen.

Die Lösung: Daten mit -X POST effizient an eine externe Webanwendung übergeben und dort direkt rendern – unabhängig davon, ob FileMaker noch weiter rechnet.

Datenübergabe aus FileMaker: So geht’s richtig

Wir nutzen den Insert from URL-Befehl, um die Daten per POST an eine Webanwendung zu übergeben. Hierbei setzen wir auf application/x-www-form-urlencoded, da diese Methode stabil mit großen Datenmengen arbeitet.

Set Variable [ $url ; Value: "http://meinserver.de/daten.php" ]  
Set Variable [ $payload ; Value:  
    "projects=" & $id_projects &  
    "&staff=" & $id_staff &  
    "&anlage=" & $anlage &  
    "&status=" & $status &  
    "&task=" & $id_task &  
    "&image=" & $image &  
    "&inhalt=" & $inhalt &  
    "&historyColors=" & $historyColors &  
    "&planungsmonat=" & $planungsmonat &  
    "&date_von=" & $date_von &  
    "&date_bis=" & $date_bis &  
    "&zeit_von=" & $zeit_von &  
    "&zeit_bis=" & $zeit_bis &  
    "&anzahl_staff=" & $anzahl_staff &  
    "&staff2=" & $id_staff_2 &  
    "&staff3=" & $id_staff_3 &  
    "&erstellt=" & $erstellt &  
    "&prio=" & $prio &  
    "¬es=" & $notes  
]  

Insert from URL [  
    $url ;  
    "-X POST " &  
    "--header \"Content-Type: application/x-www-form-urlencoded\" " &  
    "--data " & Zitat ( $payload )  
]  

Der Vorteil, ich kann unabhängig von URL-Begrenzungen Daten übergeben, ich erspare mir den Aufbau komplexer JSON-Strukturen innerhalb von FileMaker. Datentrennung geschieht bei mir vorzugsweise mit einem Pipe. Es ist natürlich auch anderes möglich. Datensammlung innerhalb von FileMaker über Schleifen, das verspricht bessere Kontrolle oder wenn es mal schnell gehen soll, geht natürlich auch die List-Funktion. Das ist aber Geschmacksache.

Unser PHP-Script empfängt die Daten und kann mit der Verarbeitung beginnen. Sobald die Daten per POST an PHP gesendet wurden, werden sie in einzelne Arrays zerlegt, sodass sie flexibel weiterverarbeitet werden können. Durch das entdecken von Strings anhand eines Trennzeichens (z. B. |) lassen sich in einer einzigen Anfrage übertragen:

$projects = isset($_POST['projects']) ? explode('|', $_POST['projects']) : [];  
$staff = isset($_POST['staff']) ? explode('|', $_POST['staff']) : [];  
$anlage = isset($_POST['anlage']) ? explode('|', $_POST['anlage']) : [];  
$status = isset($_POST['status']) ? explode('|', $_POST['status']) : [];  
$task = isset($_POST['task']) ? explode('|', $_POST['task']) : [];  
$image = isset($_POST['image']) ? explode('|', $_POST['image']) : [];  
$inhalt = isset($_POST['inhalt']) ? explode('|', $_POST['inhalt']) : [];  
$planungsmonat = isset($_POST['planungsmonat']) ? explode('|', $_POST['planungsmonat']) : [];  

Die Daten aus PHP werden dann über eine Schleife in HTML überführt. In diesem Beispiel erzeugen wir eine dynamische Tabelle, die aus den übergebenen Daten generiert wird:

<table border="1">
    <tr>
        <th>Projekt</th>
        <th>Aufgabe</th>
        <th>Mitarbeiter</th>
        <th>Status</th>
    </tr>
    <?php foreach ($task as $index => $taskName): ?>
        <tr>
            <td><?= htmlspecialchars($projects[$index] ?? 'Unbekannt') ?></td>
            <td><?= htmlspecialchars($taskName) ?></td>
            <td><?= htmlspecialchars($staff[$index] ?? 'Kein Mitarbeiter') ?></td>
            <td><?= htmlspecialchars($status[$index] ?? 'Unbekannt') ?></td>
        </tr>
    <?php endforeach; ?>
</table>

Mit ein wenig CSS kann die Liste angepasst werden, Zwischesortierungen, Statusfarben, nichts was nicht möglich ist.

.task-list { width: calc(100% - 20px); /* Verhindert das Überlaufen nach rechts / max-width: 100%; margin: 10px auto; background: white; padding: 10px; border-radius: 5px; box-shadow: 0px 0px 5px rgba(0, 0, 0, 0.2); font-size: 14px; overflow-x: hidden; / Falls nötig, um Überlauf zu vermeiden */ }

	.task-group {
		margin-top: 15px;
		padding: 8px;
		background: #3773B5;
		font-size: 14px;
		font-weight: bold;
		color: white;
		border-radius: 5px;
		text-align: left;
	}
	
	.task-item {
		width: 98%; /* Damit es nicht über den Container hinausragt */
		max-width: 100%;
		display: flex;
		align-items: center;
		justify-content: space-between;
		padding: 5px 10px;
		border-radius: 3px;
		box-shadow: 1px 1px 3px rgba(0, 0, 0, 0.1);
		font-size: 13px;
		line-height: 1.2;
		background-color: white;
		flex-wrap: wrap;
		box-sizing: border-box; /* Sorgt dafür, dass Padding berücksichtigt wird */
	}

Eine sequentielle Suche, die in ihrer Schnelligkeit niemals in FileMaker abzubilden ist, runden die Tabelle ab.

<script>
document.getElementById("taskSearch").addEventListener("keyup", function() {
    let searchQuery = this.value.toLowerCase();
    let taskGroups = document.querySelectorAll(".task-group-container");
    let resultCount = 0; // Zähler für die Anzahl der gefundenen Datensätze

    taskGroups.forEach(group => {
        let hasMatch = false;
        let tasks = group.querySelectorAll(".task-item");

        tasks.forEach(task => {
            let text = task.innerText.toLowerCase(); // Gesamten Inhalt durchsuchen
            if (text.includes(searchQuery)) {
                task.style.display = ""; // Zeigen
                hasMatch = true;
                resultCount++; // Treffer zählen
            } else {
                task.style.display = "none"; // Verstecken
            }
        });

        // Gruppe ausblenden, wenn keine Aufgabe übrig ist
        group.style.display = hasMatch ? "" : "none";
    });

    // Anzeige der Trefferanzahl aktualisieren
    document.getElementById("searchResultsCount").textContent = resultCount + " Ergebnisse gefunden";
});
</script>

Natürlich darf die Möglichkeit aus dem WebViewer heraus mit FileMaker zu kommunizieren nicht fehlen. In diesem Fall noch mit einer Bedingung.

document.addEventListener("DOMContentLoaded", function () {
    document.querySelectorAll(".status-dropdown").forEach(function (dropdown) {
        dropdown.addEventListener("change", function () {
            let taskId = this.getAttribute("data-task-id");
            let newStatus = this.value;

            if (newStatus === "Angebot folgt") {
                // PopOver anzeigen
                let modal = document.getElementById("offerModal");
                modal.style.display = "flex";

                // Speichern-Button im PopOver
                document.getElementById("confirmOffer").onclick = function () {
                    let priority = document.getElementById("offerPriority").value;
                    let note = document.getElementById("offerNote").value.trim();

                    if (note === "") {
                        alert(" Bitte eine Notiz eingeben!");
                        return;
                    }

                    modal.style.display = "none"; // Fenster schließen

                    // FileMaker-Skript aufrufen mit Priorität & Notiz
                    let fileMakerScriptURL = "fmp://$/AVAGmbH?script=UpdateTaskStatus¶m=" +
                        encodeURIComponent(taskId + "|" + newStatus + "|" + priority + "|" + note);

                    console.log(" FileMaker-Skript aufrufen:", fileMakerScriptURL);
                    window.location = fileMakerScriptURL;
                };

                // Abbrechen-Button im PopOver
                document.getElementById("cancelOffer").onclick = function () {
                    modal.style.display = "none"; // Fenster schließen
                    dropdown.value = "In Planung"; // Status zurücksetzen
                };

                return; // Stoppe die normale Ausführung, solange PopOver offen ist
            }

            // Falls NICHT "Angebot folgt", normales Verhalten
            let fileMakerScriptURL = "fmp://$/AVAGmbH?script=UpdateTaskStatus¶m=" +
                encodeURIComponent(taskId + "|" + newStatus);

            console.log("FileMaker-Skript aufrufen:", fileMakerScriptURL);
            window.location = fileMakerScriptURL;

            // Seite nach kurzer Verzögerung aktualisieren
            setTimeout(function () {
                window.location.reload();
            }, 1000);
        });
    });
});

Es gibt unendliche Optimierungsmöglichkeiten. Das wichtigste ist aber, wir können mit recht wenig Aufwand, alte schwergewichtige FileMaker-Anwendungen wieder flott machen.

Die Evolution einer Kanban-Ansicht in FileMaker: Vom GET zum POST

In der kontinuierlichen Weiterentwicklung von Arbeitsprozessen und deren Darstellung in FileMaker ergibt sich oft die Notwendigkeit, bestehende Lösungen zu optimieren und an neue Anforderungen anzupassen. Genau dieser Gedanke begleitete die Entwicklung der Kanban-Ansicht, die sich ursprünglich auf GET-Parameter zur Datenübertragung stützte, nun aber auf POST umgestellt wurde. Ein scheinbar kleiner Wechsel, der jedoch große Auswirkungen hat – sowohl auf die Performance als auch auf die Flexibilität der Anwendung. Der wichtigste Aspekt, alle weiteren Daten die der Kunde jetzt in noch in den Kacheln sehen möchte, kann ich ohne Probleme übertragen. Ob 100 oder nur 50 Aufgaben. Das System benötigt keinerlei Vorfilterung innerhalb von FileMaker.

Ursprünglich wurde die Kanban-Ansicht über eine URL-basierte GET-Abfrage mit Daten versorgt. Die Vorteile lagen auf der Hand: einfache Implementierung, transparente Debugging-Möglichkeiten und eine schnelle Integration in den bestehenden Webviewer von FileMaker. Doch mit wachsendem Datenvolumen und steigenden Anforderungen an die übertragene Information stieß diese Methode an ihre Grenzen. Die maximale URL-Länge wurde zu einem Problem, und die Strukturierung komplexer Daten – insbesondere in Bezug auf Statusfarben, Aufträge und historische Änderungen – wurde zunehmend unübersichtlich.

Die logische Konsequenz war der Wechsel auf eine POST-Übertragung, die nicht nur größere Datenmengen bewältigen kann, sondern auch eine flexiblere Handhabung ermöglicht. Dabei stellte sich heraus, dass die Umstellung zwar in der Theorie simpel erschien, in der Praxis aber einige Herausforderungen mit sich brachte. FileMaker musste so konfiguriert werden, dass die Daten nicht mehr direkt als URL-Parameter übergeben wurden, sondern als strukturierte POST-Daten in die Webanwendung flossen. Das bedeutete, dass die gesamte Datenkette angepasst werden musste – von der Generierung der Werte in FileMaker über die Verarbeitung in PHP bis hin zur Darstellung im Webviewer.

Nach einigen Anpassungen und Tests zeigte sich schnell: Die POST-Methode brachte nicht nur eine sauberere und robustere Datenübertragung mit sich, sondern auch eine spürbare Verbesserung der Ladegeschwindigkeit. Während GET oft dazu führte, dass die URL unnötig aufgebläht wurde, ermöglicht POST eine strukturierte und sichere Übermittlung, die auch größere Datensätze problemlos verarbeitet. Gerade im Kontext eines Kanban-Boards mit zahlreichen Aufgaben, Statusänderungen und Nutzerinteraktionen ist das ein entscheidender Vorteil.

Ein besonders interessanter Nebeneffekt der Umstellung war die Vereinfachung der Datenstruktur. Während bei der GET-Variante viele Variablen direkt in der URL codiert und dekodiert werden mussten, erlaubt die POST-Methode eine klarere Trennung zwischen Client und Server. Die Farbmarkierungen, Statushistorien und Task-IDs ließen sich nun effizienter verarbeiten, und die Fehlersuche gestaltete sich deutlich angenehmer. Zudem eröffnete sich durch die Umstellung die Möglichkeit, noch weitere Daten ohne zusätzliche URL-Komplikationen zu übertragen – ein Schritt, der langfristig gesehen weitere Optimierungen ermöglichen wird.

Rückblickend zeigt diese Anpassung einmal mehr, wie wichtig es ist, Prozesse stetig zu hinterfragen und weiterzuentwickeln. Was gestern noch gut funktionierte, kann heute durch eine andere Herangehensweise erheblich verbessert werden. Die Migration von GET zu POST mag auf den ersten Blick nur eine technische Feinheit sein, doch in der Praxis trägt sie entscheidend zu einer performanten und skalierbaren Lösung bei. Die Kanban-Ansicht in FileMaker ist damit nicht nur flexibler, sondern auch zukunftssicherer geworden – und das ist letztlich das Ziel jeder guten Softwareentwicklung.

Der eigentliche Vorgang innerhalb von FileMaker ist klar. Sammeln der Daten per Schleife unter Beachtung der spezifischen Vorstellungen und Kundenwünsche. Das eigentlich interessante Prozedere, der Befehl aus URL einfügen.

Angabe der URL mit dem Ziel der aufgerufenen PHP-Datei. Die cURL Eintragungen. Das Endergebnis. Durch viele Tests etwas durcheinander. Grundsätzliche Farbmuster zum erkennen der im Zusammenhang stehende Aufgaben und auf der linken Seite der Kacheln befindet sich ein Farbmuster das den Verlauf durch die verschiedenen Status-Änderungen zeigt.

In diesem Blog vergleichen wir zwei Ansätze zur automatischen Zuordnung von Mitarbeitern basierend auf Standort und Verfügbarkeit. Der erste Ansatz nutzt eine KI, um die besten Mitarbeiter auszuwählen, während der zweite Ansatz dies mithilfe von reinem PHP realisiert. Beide Methoden liefern wertvolle Ergebnisse, doch sie haben unterschiedliche Vor- und Nachteile. Eines aber gleich vorneweg, KI ist cool, es ist extrem flexibel, treibt aber mich persönlich an den Rand der Verzweiflung. Warum? Übergebe ich 5 mal die gleichen Daten an die KI, z.B. in meiner Anwendung in folgender Form:

testserver.de/php_calen…|Mario,52.5814763,13.3057333,9:30:00,11:00:00,24204|Mario,52.5346344,13.4224666,12:00:00,13:00:00,22664|Philipp,52.5346344,13.4224666,7:00:00,8:00:00,22664|Philipp,52.4702886,13.2930662,13:00:00,14:00:00,24500|David,52.4702886,13.2930662,10:00:00,11:00:00,24531|Jennifer,52.5035525,13.4176949,9:30:00,10:22:30,24542|Philipp,52.5035525,13.4176949,14:00:00,14:52:30,24543|André,52.5035525,13.4176949,7:30:00,8:22:30,24544|Jennifer,52.6053036,13.3540889,11:00:00,12:30:00,24495|Martin,52.5727963,13.4187507,15:00:00,16:00:00,24485

Dann habe ich zu mindesten zwei verschiedene Ergebnisse. Wenn es ganz schlecht läuft, habe ich 5 verschiedene Ergebnisse.

Code-Beispiel 1: Mitarbeiterzuordnung ohne KI Der folgende PHP-Code sortiert und bewertet Mitarbeiter basierend auf ihrer Entfernung, Verfügbarkeit und Priorität.

 $fields[0],
            'lat' => (float)$fields[1],
            'lng' => (float)$fields[2],
            'startTime' => $fields[3],
            'endTime' => $fields[4],
            'orderNumber' => $fields[5],
        ];
    }
}

if (empty($parsedData)) {
    die("Keine gültigen Mitarbeiterdaten empfangen.");
}

$supportRequest = $parsedData[0];
$remainingEmployees = array_slice($parsedData, 1);

// Entfernen des Anforderers aus der Liste
$remainingEmployees = array_filter($remainingEmployees, function ($employee) use ($supportRequest) {
    return $employee['name'] !== $supportRequest['name'] ||
           $employee['lat'] !== $supportRequest['lat'] ||
           $employee['lng'] !== $supportRequest['lng'];
});

// Entfernung und Priorität berechnen
foreach ($remainingEmployees as &$employee) {
    $employee['distance'] = round(haversine(
        $supportRequest['lat'], $supportRequest['lng'],
        $employee['lat'], $employee['lng']
    ), 2);

    $timeToReach = strtotime($supportRequest['startTime']) - strtotime($employee['endTime']);
    $timeToWait = strtotime($employee['startTime']) - strtotime($supportRequest['endTime']);

    if ($employee['distance'] <= 5 && $timeToReach >= 0 && $timeToReach <= 3600) {
        $employee['priority'] = "high";
    } elseif ($employee['distance'] <= 10) {
        $employee['priority'] = "medium";
    } else {
        $employee['priority'] = "low";
    }

    $employee['time'] = "{$employee['startTime']} - {$employee['endTime']}";
}

usort($remainingEmployees, function ($a, $b) {
    $priorityOrder = ['high' => 1, 'medium' => 2, 'low' => 3];
    return $priorityOrder[$a['priority']] <=> $priorityOrder[$b['priority']];
});

$analysisResult = $remainingEmployees;

?>

Vor- und Nachteile

Vorteile ohne KI: 1. Kosten: Keine Abhängigkeit von KI-Diensten wie GPT-4 reduziert die laufenden Kosten erheblich. 2. Kontrolle: Logik und Priorisierungsregeln können exakt definiert und angepasst werden. 3. Performance: Direkte Verarbeitung auf dem Server führt zu schnelleren Ergebnissen.

Nachteile ohne KI: 1. Flexibilität: Änderungen in den Anforderungen erfordern Anpassungen im Code. 2. Komplexität: Erstellen neuer Algorithmen für komplexere Szenarien erfordert Zeit und Fachwissen.

Code-Beispiel 2: Mitarbeiterzuordnung mit KI Hier wird eine KI verwendet, um Mitarbeiter basierend auf Standort und Verfügbarkeit zu priorisieren. Der PHP-Code sendet die Daten an eine KI-API und verarbeitet die Antwort.

Mitarbeiterzuordnung: Ein PHP-basiertes Tool zur Optimierung

Vor- und Nachteile

Vorteile mit KI: 1. Flexibilität: Anpassungen an den Anforderungen können durch Änderungen der Anweisungen an die KI erfolgen. Dies kann sogar vom Kunden durchgeführt werden wenn z.B. die Anforderungen in FileMaker definiert werden und dann an die KI gesendet werden. 2. Intelligenz: Komplexere Logiken und Datenmuster können leichter berücksichtigt werden.

Nachteile mit KI: 1. Kosten: Jeder API-Aufruf verursacht Kosten, die sich bei häufiger Nutzung summieren können. 2. Abhängigkeit: Funktionalität hängt von der Verfügbarkeit des KI-Dienstes ab. 3. Performance: Zusätzliche Latenz durch API-Aufrufe.

Fazit

Beide Ansätze haben ihre Berechtigung. Der KI-gestützte Ansatz eignet sich für dynamische und komplexe Anforderungen, während die reine PHP-Lösung ideal für festgelegte und kostenbewusste Szenarien ist.

Welcher Ansatz für dich geeignet ist, hängt von deinen spezifischen Anforderungen und Prioritäten ab. Für mich ist nach dem Test klar, die KI werde ich integrieren, aber nur bei extrem komplexen Prozessen. Gedanklich gehe ich dann in die Richtung, Komplette Tagesplanung für ein Team aus z.B. 10-15 Mitarbeitern mit 30-40 Einsätzen in einem Stadtgebiet verstreut.

Dieses Projekt kombiniert PHP, die Haversine-Formel und die Google Maps API, um die besten Mitarbeiter für einen Unterstützungsantrag basierend auf Standort und Verfügbarkeit auszuwählen. Das Ergebnis wird auf einer interaktiven Karte dargestellt, und eine Mitarbeiterliste zeigt alle relevanten Details wie Entfernung und Priorität. Der Grund, viele Mitarbeiter sind bei unterschiedlichen Kunden im Einsatz. Es kann aber notwendig sein, das ein zweiter oder dritter Mitarbeiter für diesen Einsatz benötigt werden. Schwierig die Mitarbeiter aus dem Kopf heraus zuordnen zu wollen.

Überblick

Unser Ziel ist es, ein System zu erstellen, das: • Mitarbeiter basierend auf Entfernung und zeitlicher Verfügbarkeit priorisiert. • Standorte auf einer Karte visualisiert. • Überlappende Standorte automatisch verschiebt, um sie sichtbar zu machen. • Eine übersichtliche Mitarbeiterliste generiert.

PHP: Entfernung und Datenverarbeitung

Im folgenden PHP-Skript berechnen wir die Entfernung zwischen Standorten mit der Haversine-Formel, filtern die Mitarbeiter und senden die Daten an eine KI-Analyse.

 $fields[0],
			'lat' => (float)$fields[1],
			'lng' => (float)$fields[2],
			'startTime' => $fields[3],
			'endTime' => $fields[4],
		];
	}
}

// Wenn keine gültigen Daten vorhanden sind
if (empty($parsedData)) {
	die("Keine gültigen Mitarbeiterdaten empfangen.");
}

// Der Mitarbeiter, der Unterstützung benötigt
$supportRequest = $parsedData[0];
$remainingEmployees = array_slice($parsedData, 1);

// Entfernung berechnen und in das Array hinzufügen
foreach ($remainingEmployees as &$employee) {
	$employee['distance'] = round(haversine(
		$supportRequest['lat'], $supportRequest['lng'],
		$employee['lat'], $employee['lng']
	), 2);
}

// Anfrage an KI zur Analyse senden
$payload = [
	'supportRequest' => $supportRequest,
	'employees' => $remainingEmployees,
];

// Die Anfrage an die OpenAI-API bleibt unverändert und liefert die Ergebnisse
// JSON-Analyse bleibt wie im Skript
?>

Visualisierung mit Google Maps API

Hier zeigen wir, wie die Ergebnisse visualisiert werden, einschließlich der dynamischen Verschiebung überlappender Marker und einer dynamischen Mitarbeiterliste.

<script>
	function initMap() {
		const map = new google.maps.Map(document.getElementById('map'), {
			zoom: 10,
			center: { lat: <?php echo $supportRequest['lat']; ?>, lng: <?php echo $supportRequest['lng']; ?> },
		});
	
		const employees = <?php echo json_encode($analysisResult); ?>;

		// Unterstützungsmarker hinzufügen
		new google.maps.Marker({
			position: { lat: <?php echo $supportRequest['lat']; ?>, lng: <?php echo $supportRequest['lng']; ?> },
			map: map,
			title: "Unterstützungsantrag",
		});

		// Mitarbeiter hinzufügen
		const OFFSET_DISTANCE = 0.001;
		const seenLocations = new Map();
		employees.forEach((employee) => {
			let key = `${employee.lat},${employee.lng}`;
			if (seenLocations.has(key)) {
				const offset = seenLocations.get(key) + 1;
				employee.lat += OFFSET_DISTANCE * offset;
				employee.lng += OFFSET_DISTANCE * offset;
				seenLocations.set(key, offset);
			} else {
				seenLocations.set(key, 0);
			}

			new google.maps.Marker({
				position: { lat: employee.lat, lng: employee.lng },
				map: map,
				title: `${employee.name} - ${employee.distance} km`,
			});
		});
	}
	window.onload = initMap;
</script>

Was übergeben wir aus FileMaker

https://deine_url.de/ki_calendar.php?data=André,52.5035525,13.4176949,7:30:00,8:22:30|Mario,52.5814763,13.3057333,9:30:00,11:00:00|Mario,52.5346344,13.4224666,12:00:00,13:00:00|,52.5346344,13.4224666,7:00:00,8:00:00|Philipp,52.4702886,13.2930662,13:00:00,14:00:00|David,52.4702886,13.2930662,10:00:00,11:00:00|Jennifer,52.5035525,13.4176949,9:30:00,10:22:30|Philipp,52.5035525,13.4176949,14:00:00,14:52:30|André,52.5035525,13.4176949,7:30:00,8:22:30|Jennifer,52.6053036,13.3540889,11:00:00,12:30:00|Martin,52.5727963,13.4187507,15:00:00,16:00:00

Fazit

Die Rolle der KI in unserem Projekt

Bei diesem Projekt haben wir die GPT-4 API von OpenAI genutzt, eine hochmoderne KI, die auf natürliche Sprachverarbeitung spezialisiert ist. Die KI übernimmt dabei eine entscheidende Rolle:

Aufgaben der KI 1. Analyse der Daten: Die KI wertet die übermittelten Daten aus, einschließlich der Standorte und Verfügbarkeiten der Mitarbeiter, sowie der geforderten Zeitspanne. Sie trifft Entscheidungen, welche Mitarbeiter am besten geeignet sind, basierend auf: • Geografischer Nähe (Entfernung). • Zeitlicher Verfügbarkeit (Überlappung mit der Anforderungszeit). • Priorisierungskriterien. 2. Priorisierung der Mitarbeiter: Die KI sortiert die Mitarbeiter in Prioritätsklassen (hoch, mittel, niedrig), um Entscheidungsprozesse zu erleichtern. Dies hilft besonders bei komplexen Szenarien mit vielen Teilnehmern und unterschiedlichen Anforderungen. 3. Flexible Verarbeitung: Mit der eingebauten Sprachverarbeitungsfähigkeit kann die KI auf benutzerdefinierte Regeln und neue Anforderungen reagieren. Im Falle unseres Projekts wird sichergestellt, dass: • Der Supportanforderer (Mario) nicht als Unterstützer in die Liste aufgenommen wird. • Die Ergebnisse stets im JSON-Format zurückgegeben werden, damit sie direkt weiterverarbeitet werden können.

Warum GPT-4? • Komplexe Entscheidungen: GPT-4 kann nicht nur einfache Regeln anwenden, sondern auch inhaltlich komplexe Daten wie geografische Koordinaten, Zeitfenster und Prioritäten verknüpfen. • Flexibilität: Änderungen in den Anforderungen (z. B. neue Priorisierungsregeln) lassen sich einfach umsetzen, indem wir die KI-Prompts anpassen. • Effizienz: Im Gegensatz zu einer festen Programmierung ermöglicht die KI schnelle Analysen und Rückmeldungen, ohne den PHP-Code manuell anzupassen.

Das Projekt zeigt, wie sich PHP, eine KI-API und Google Maps zu einem leistungsstarken Logistik-Tool kombinieren lassen. Dies ist natürlich nur eine erste Version und verarbeitet nur wenige Daten.

Das neue Jahr läuft an.

Das neue Jahr hat begonnen und ich sitze wieder am Rechner. FileMaker über Google Maps API verbinden, Daten sortieren und anzeigen.