Ruhmer, Martin: Informationsagenten für die SMART
Werbung
Informationsagenten für die SMART Agenten Plattform Überblick über die Agententechnologie und Entwurf einer Agenten Plattform basierend auf Java Technologie Martin Ruhmer Informationsagenten für die SMART Agenten Plattform Überblick über die Agententechnologie und Entwurf einer Agenten Plattform basierend auf Java Diplomarbeit an der Technischen Universität Graz vorgelegt von Martin Ruhmer Institut für Informationssysteme und Computer Medien (IICM) Technische Universität Graz A-8010 Graz, Österreich September 2005 © Copyright 2005, Martin Ruhmer Diese Arbeit ist in deutscher Sprache verfasst. Begutachter: o.Univ.-Prof. Dr. Dr.h.c.mult. Hermann Maurer Betreuer: Dipl.-Ing. Dr.tech. Christian Gütl Information agents for the SMART Agent Platform An overview about Agent technology and specification of an Agent Platform based on Java Master’s Thesis at Graz University of Technology submitted by Martin Ruhmer Institute for Information Systems and Computer Media (IICM) Graz University of Technology A-8010 Graz, Austria September 2005 © Copyright 2005, Martin Ruhmer This Thesis is written in german language. Advisor: o.Univ.-Prof. Dr. Dr.h.c.mult. Hermann Maurer Supervisor: Dipl.-Ing. Dr.tech. Christian Gütl Kurzfassung Das unüberschaubare und permanent wachsende Angebot von Informationen im Internet ermöglicht es den Menschen nicht mehr, dieses inhaltlich zu erfassen oder gezielt nach Informationen zu suchen. Einen Lösungsweg zur verbesserten Informationsauffindung stellt hierbei der Einsatz von so genannten Informationsagenten in Multiagentensystemen dar. Im ersten Teil dieser Arbeit, dem Untersuchungsbereich, wird versucht, einen Überblick über die Agententechnologie zu schaffen, und untersucht wie sich Software Agenten definieren. In weiterer Folge wird im Besonderen auf Informationsagenten eingegangen und es werden existierende Systeme vorgestellt. Die Betrachtung einiger wichtiger Aspekte die im Zusammenhang mit Multiagentensystemen auftreten bildet den Abschluss dieses Teils der Arbeit. Die im Untersuchungsbereich gewonnenen Erkenntnisse fließen in die Konzeptionierung und prototypische Implementierung einer Agenten Plattform ein, welche im ersten Teil des Gestaltungsbereiches vorgestellt wird. Diese Plattform trägt den Namen SMART (Sophisticated Mobile Agent Repository), und wurde in Java, unter Verwendung des am IICM (Institut für Informationssysteme und Computer Medien) der Technischen Universität Graz entwickelten Dino Frameworks, implementiert. Um die Grundfunktionalität der SMART Agenten Plattform zu testen, wird im zweiten Teil des Gestaltungsbereichs die Umsetzung eines einfachen Informationsagenten beschrieben, der mit dem, ebenfalls am IICM entwickelten Suchdienst xFIND (Extended Framework for Information Discovery) kommuniziert. Abschließend werden mögliche Verbesserungen und wünschenswerte Erweiterungen für SMART diskutiert. Abstract The unmanageable and permanently increasing amount of information found on the Internet prevents users from searching and identifying the adequate information. A promising approach for solving the complex problem is the use of so called “Information Agents” within multi-agent systems. The first part of this thesis, the theoretical section tries to give an overview about agent technology and to determine how the term Software Agent is defined. Subsequently, in particular the issue of Information Agents is addressed and existing systems are presented. Finally to this section some important aspects of multi-agent systems are examined. The results of the theoretical section will be incorporated in the conceptual design and prototypical implementation of an Agent Platform, which will be presented in the first part of the practical section of this thesis. This Agent Platform is called SMART (Sophisticated Mobile Agent Repository), and has been implemented in JAVA using the Dino Framework which was developed at IICM (Institute for Information Systems and Computer Media) at Graz University of Technology. To test the basic functionality of the SMART Agent Platform a simple Information Agent, which is able to communicate with the, also at IICM developed search system xFIND (Extended Framework for Information Discovery), has been implemented. A detailed instruction of the implementation steps will be introduced in the second part of the practical section. Finally to this section some possible suggestions and new ideas for the improvement and extension of the SMART System are discussed. Ich versichere hiermit, diese Arbeit selbständig verfasst, andere als die angegebenen Quellen und Hilfsmittel nicht benutzt und mich auch sonst keiner unerlaubten Hilfs-mittel bedient zu haben. I herby certify that the work presented in this thesis is on my own and the work performed by others is appropriately cited. Danksagung Hiermit möchte ich mich bei all jenen bedanken, die mich bei der Erstellung dieser Diplomarbeit mit Rat und Tat unterstützt haben. Mein besonderer Dank gilt den Mitarbeitern des IICM um Herrn Prof. Dr. Dr.hc.mult. Hermann Maurer für die Unterstützung in administrativen Angelegenheiten, sowie meinen Kollegen in der Web Application Group (WAG) für ihre aufmunternden Gespräche. Insbesondere danken möchte ich meinem Betreuer, Herrn Dipl. Ing. Dr. Christian Gütl, der mich durch zahlreiche Anregungen und Ratschläge bei der Erstellung dieser Arbeit unterstützt hat. Herzlichst möchte ich mich auch bei Andrea Kleinschuster für ihre Unterstützung und unermüdliche Aufmunterung bedanken. Ohne sie hätte ich diese Arbeit nie vollendet. Das SMART System wurde in Zusammenarbeit mit Stefan Kernbauer, ebenfalls Diplomand am IICM, entwickelt. Vielen Danke für dein Engagement und für die Diskussionen, die viele Unklarheiten beseitigt und viele Ideen konkretisiert haben. Herzlich bedanken möchte ich mich auch bei meinen Eltern, Gertrude und Johann, die mir durch ihre vielseitige Unterstützung über all die Jahre hinweg diese Ausbildung erst ermöglicht haben. Von ganzem Herzen möchte ich meiner Familie, meiner Frau Helene, meinem Sohn Daniel und meiner Tochter Katharina danken. Ihre Geduld mit mir und ihre Liebe zu mir waren in allen Situationen eine wertvolle Stütze. Martin Ruhmer Graz, September 2005 Inhaltsverzeichnis 1 Einleitung ...................................................................................... 1 1.1 1.2 Ausgangssituation-Motivation ................................................................. 1 Gliederung und Inhalt der Arbeit ............................................................. 2 I Untersuchungsbereich ................................................................. 4 2 Einführung in den Themenbereich und Begriffsbestimmung . 6 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 3 Motivation ................................................................................................ 6 Geschichtliche Betrachtungen ................................................................. 8 Agentendefinitionen............................................................................... 11 Eigenschaften von Agenten ................................................................... 13 Agenten und Objekte ............................................................................. 17 Agenten und Intelligenz ......................................................................... 19 Klassifikation von Agenten ................................................................... 21 Zusammenfassung ................................................................................. 25 Informationsagenten im Web.................................................... 27 3.1 Allgemeines ........................................................................................... 27 3.2 Grundlegende Struktur des Web ............................................................ 28 3.3 Suchdienste ............................................................................................ 28 3.3.1 Webkataloge .................................................................................. 29 3.3.2 Spider-basiert Suchdienste ............................................................. 29 3.3.3 Metasuchmaschinen ....................................................................... 30 3.4 Problembereiche der Suchdienste .......................................................... 31 3.5 Problembereiche bei der Wissensauffindung im Web ........................... 32 3.6 Informationsagenten .............................................................................. 37 3.7 Klassifikation von Informationsagenten ................................................ 38 3.7.1 Kooperative Informationsagenten und Systeme ............................ 39 3.7.2 Adaptive Informationsagenten ....................................................... 39 3.7.3 Mobile Informationsagenten .......................................................... 40 3.7.4 Informationsagenten für den elektronischen Handel ..................... 40 3.8 Beispiele von Informationsagenten ....................................................... 41 3.8.1 Letizia ............................................................................................ 41 3.8.2 Infosleuth ....................................................................................... 42 3.8.3 RETSINA....................................................................................... 43 3.8.4 Daffodil .......................................................................................... 45 3.9 Zusammenfassung ................................................................................. 47 4 Multiagentensysteme .................................................................. 49 4.1 Allgemeines ........................................................................................... 49 4.2 Eigenschaften von Multiagentensystemen............................................. 50 4.3 Mögliche Vorteile von Multiagentensystemen ...................................... 51 4.4 Agentenkommunikation......................................................................... 51 4.4.1 Sprechakte ...................................................................................... 53 4.4.2 Sprechaktbasierte Agentenkommunikationssprachen ................... 54 4.4.3 Interaktionsprotokolle .................................................................... 57 4.4.4 Ontologien ..................................................................................... 61 4.4.5 Vermittlung und Organisation durch Faciltiators .......................... 61 4.4.6 Regeln der Kommunikation ........................................................... 63 4.5 Agentenarchitekturen ............................................................................. 63 4.5.1 Komponentenarchitekturen ............................................................ 64 4.5.2 Geschichtete Architekturen............................................................ 64 4.5.3 Reaktive Architekturen .................................................................. 66 4.6 Standardisierungsbemühungen .............................................................. 66 4.6.1 Knowledge Sharing Effort ............................................................. 67 4.6.2 FIPA ............................................................................................... 67 4.6.3 Agent Society ................................................................................. 67 4.6.4 Object Management Group ............................................................ 67 4.7 Zusammenfassung ................................................................................. 68 II Gestaltungsbereich .................................................................... 69 5 SMART - Sophisticated Mobile Agent Repository ................. 70 5.1 Motivation .............................................................................................. 70 5.2 Anforderungen an ein Agentensystem ................................................... 71 5.3 SMART Philosophie .............................................................................. 72 5.4 Bausteine zur Entwicklung eines Agentensystems ................................ 74 5.4.1 Java ................................................................................................ 74 5.4.2 Dino ............................................................................................... 75 5.4.3 FIPA ............................................................................................... 76 5.5 Das SMART System .............................................................................. 77 5.6 Die SMART Plattform ........................................................................... 78 5.6.1 Kurzbeschreibung der Module....................................................... 79 5.7 SMART Konzepte ................................................................................. 83 5.7.1 SMART Agent (SAgent) ............................................................... 83 5.7.2 Kommunikation zwischen Agenten ............................................... 85 5.7.3 Mobilität von Agenten ................................................................... 86 5.7.4 SMART Komponenten .................................................................. 86 5.7.5 SMART Componentbase ............................................................... 87 5.7.6 SMART Agentbase ........................................................................ 88 5.7.7 SMART Bewertung ....................................................................... 88 5.7.8 User Interaktion ............................................................................. 89 5.8 Zusammenfassung ................................................................................. 89 6 Ein einfacher Informationsagent für die SMART Agenten Plattform ......................................................................................... 91 6.1 Das xFind Suchsystem ........................................................................... 91 6.2 Das xFind Beispielszenario ................................................................... 93 6.3 Beteiligte Agenten ................................................................................. 93 6.3.1 Der xFIND Indexer Wrapper Agent .............................................. 94 6.3.2 Der What’s New Agent................................................................ 104 6.4 Zusammmenfassung ............................................................................ 106 7 Zusammenfassung .................................................................... 108 7.1 Erkenntnisse und Ausblick .................................................................. 110 Abbildungsverzeichnis .................................................................... 113 Literaturverzeichnis ........................................................................ 115 Seite 1 Kapitel 1 Einleitung Kapitel 1 1 Einleitung 1.1 Ausgangssituation-Motivation Durch das rapide Wachstum des World Wide Web (WWW) und der damit zusammenhängenden Informationsfülle ist es für den Benutzer unmöglich geworden, die zur Verfügung stehende Information zu sichten und die für ihn wichtige und interessante Information herauszufiltern. Es besteht die Gefahr, in einer Unmenge irrelevanter Informationen zu versinken und das eigentliche Ziel der Informationssuche aus den Augen zu verlieren. Dies geht einher mit einem massiven Zeitverlust für das Auswerten letztendlich wertlosen Materials. Die gegenwärtigen „keyword search“ basierten Suchdienste im Internet leisten eine wichtige Hilfestellung für die Informationserschließung im World-Wide-Web (WWW), weisen jedoch eine Reihe von Schwächen auf. Diese Suchdienste liefern eine nahezu endlose Liste an Suchergebnissen. In ihren Suchmöglichkeiten wird nicht auf individuelle Bedürfnisse und Qualitätsanforderungen der Benutzer eingegangen, und sie stellen keinen Kontext zu den jeweiligen Aufgaben dar. Zumeist sind sie, für sich, isolierte Dienste, die mit dem enormen Informationsangebot und Wachstum im Internet nicht Schritt halten können. Weiters unterstützen sie den Benutzer zu wenig im Rechercheprozess. So sind sie z.B. nicht in der Lage vorhandene Metainformationsdienste zu berücksichtigen bzw. diese zu kombinieren und sie bieten auch keine Hilfestellung bei der Verwaltung von bereits vom Benutzer gesichteter Information. Einen weiteren Problembereich stellt das „Vertrauen in die Information“ bzw. deren Gültigkeit oder Aktualität dar, auch in diesen Bereichen erfährt der Benutzer zu wenig Hilfe. [Guetl 2002] Es besteht also der Bedarf an „intelligenten“ Suchwerkzeugen, die in verteilter Weise individuelle, personalisierte Informationen bzw. Dienste und Applikationen den jeweiligen Benutzern zur Verfügung stellen können. Diese Suchwerkzeuge sollen den Benutzer auch bei der Beurteilung der Qualität von Informationen unterstützen und je nach Wunsch noch zu den jeweiligen Inhalten Zusatzinformationen von den unterschiedlichsten Diensten (Metadiensten) anbieten können. [Guetl 2002] Bei diesen Metadiensten handelt es sich nicht immer nur um herkömmliche Suchdienste in den gegenwärtig bekannten Formen, sondern es sollen auch Übersetzungsdienste, Klassifizierungsdienste und Dienste aus andern Bereichen, die die Informationsauffindung erleichtern, zum Einsatz kommen. So ist unter anderem auch die Zusammenarbeit oder die Kombination von kommerziellen und nicht kommerziellen Diensten wünschenswert. [Gütl 2002] Seite 2 Der Einsatz von Agententechnologie ist ein viel versprechender Ansatz zur Lösung der oben skizzierten komplexen Probleme. Mit Hilfe dieser Technologie können Multiagentensysteme geschaffen werden in denen mehrere spezialisierte Agenten kooperieren, um gemeinsam die schwierigen Aufgaben, die bei der Informationsbeschaffung auftreten, zu lösen. Ziel dieser Arbeit ist es, die Grundlagen der Agententechnologie zu untersuchen. Insbesondere werden so genannte Informationsagenten, und einige wesentliche Aspekte die im Zusammenhang mit Multiagentensystemen auftreten, näher betrachtet. Die gewonnen Erkenntnisse fließen in die Entwicklung und Konzeption einer Agenten Plattform, die den Namen SMART (Sophisticated Mobile Agent Repository) trägt, ein. Beispielhaft wurde ein einfacher Suchagent auf der entwickelten Agenten Plattform umgesetzt. 1.2 Gliederung und Inhalt der Arbeit Die vorliegende Arbeit gliedert sich in einen Untersuchungsbereich und einem Gestaltungsbereich auf. Der erste Teil dieser Arbeit, der Untersuchungsbereich beginnt mit einer Einführung in den Themenbereich und Begriffsbestimmung in Kapitel 2. Zu diesem Zweck wird zunächst versucht einen kurzen Überblick über die Entwicklung der Agententechnologie zu gegeben. In weiterer Folge wird die vielschichtige Verwendung des Begriffs Agent, aufgezeigt. Dazu werden verschiedene Definitionen und Eigenschaften, wie sie in der Literatur zu finden sind, herangezogen. Aus dem Blickpunkt der Objektorientierten Programmierung ist es auf den ersten Blick nicht erkennbar welche neuen Ideen sich hinter dem Agentenparadigma verbergen, deshalb wird dieser Problematik ein eigener Absatz gewidmet. Häufig wird im Zusammenhang mit Agenten von „Intelligenten“ Agenten gesprochen. Hinter dieser Eigenschaft verbergen sich aber sehr unterschiedliche Sichtweisen, die ebenfalls in diesem Kapitel näher dargestellt werden. Die Vorstellung einer möglichen Klassifikation von Agenten und eine kurze Zusammenfassung bilden den Abschluss dieses Kapitels. Kapitel 3 befasst sich mit den gegenwärtigen Suchdiensten und deren Problembereichen. Im weiteren Verlauf dieses Kapitels werden Ergebnisse von Studien vorgestellt, die sich mit dem Benutzerverhalten bei der Wissensauffindung im Internet befassen. Daraus werden mögliche Einsatzgebiete von Informationsagenten abgeleitet. Es folgt die Vorstellung konkreter Beispiele von singulären Informationsagenten und Informationsagenten innerhalb eines Multiagentensystems. Eine kurze Zusammenfassung beschließt dieses Kapitel. Mit der Betrachtung von einigen wesentlichen Aspekten von Multiagentensystemen, dazu gehören unter anderem die generellen Eigenschaften solcher Systeme, die Kommunikation zwischen Agenten, die verschiedenen Architekturen von Agenten und Standardisierungsbemühungen in diesem Bereich, wird in Kapitel 4 der Untersuchungsbereich abgeschlossen. Die im Untersuchungsbereich gewonnenen Erkenntnisse fließen in die Entwicklung und Konzeption einer Agenten Plattform ein, welche im Zweiten Teil dieser Arbeit, dem Seite 3 Kapitel 1 Einleitung Gestaltungsbereich in Kapitel 5 vorgestellt wird. Um die Funktionalität dieser Plattform zu zeigen wird in Kapitel 6 ein einfacher Informationsagent spezifiziert und prototypisch implementiert, der mit dem am IICM entwickelten Suchdienst xFIND kommuniziert. Den Abschluss des Gestaltungsteiles bildet in Kapitel 7 eine kurze Zusammenfassung in der auch möglichen Verbesserungen bzw. Erweiterungen der SMART Plattform diskutiert werden. Seite 4 Untersuchungsbereich Seite 5 Kapitel 1 Einleitung Seite 6 Kapitel 2 2 Einführung in den Themenbereich und Begriffsbestimmung Objects do it for free; agents do it for money. [Jennings et al. 1998a] 2.1 Motivation Herkömmliche Software arbeitet nach dem Paradigma der „direkten Manipulation“, nichts passiert bis eine Person explizit Kommandos über die Tastatur eingibt. Der Computer ist also nur eine passive Einheit, der auf detaillierte Instruktionen wartet um diese dann auszuführen. Durch den Einsatz von Agententechnologie sollte sich dieser Zugang zum Rechner grundlegend ändern. Es wird ein kooperativer Prozess zwischen Benutzer und intelligentem Agenten stattfinden, indem beide Aktionen starten, Ereignisse betrachten, Aufgaben ausführen und kommunizieren können. Man spricht in diesem Zusammenhang von dem Paradigma der „indirekten Manipulation“. [Maes 1994] Damit ist es nur allzu verständlich, dass in Agenten und Multiagentensysteme große Hoffnungen gesetzt werden. Die Anwendungen reichen dabei von einfachen personalisierten Emailfiltern, Informationsmanagement, Workflowmanagement oder Netzwerkmanagement bis hin zu großen, komplexen aber auch ein hohes Maß an Verantwortung tragenden Systemen, wie zum Beispiel im Bereich der Flugverkehrskontrolle und Patientenüberwachung. [Ciancarini et al. 1998] Der Ursprung der Agententechnologie im Bereich der Künstlichen Intelligenz (KI) zu finden, allerdings ist die intensive Forschung auf dem Gebiet der Agententechnologie auch eng mit dem ständigem Wachstum und der steigenden Popularität des Internets verbunden. Einerseits haben heute immer mehr Anwender Zugang, die kein ausreichendes Verständnis über die zugrunde liegende Informations- und Kommunikationstechnik haben. Andererseits wird, durch die immer größer werdende Informationsflut, die den Benutzer aus dem World Wide Web (WWW) überrollt, die Informationssuche immer schwerer bzw. kostet den Benutzer sehr viel Zeit und Aufwand. So ist der Gedanke nahe liegend, diese Arbeiten an einen Agenten zu übertragen, der in der Lage ist aus den Interessen und Vorlieben des Benutzers zu lernen und ihn auf diese Weise optimal unterstützen zu können. [Murch et al. 2000] Bei der großen Breite an Anwendungsgebieten scheint es auf den ersten Blick unmöglich in all diesen Bereichen Gemeinsamkeiten zu erkennen, doch das verbindende Seite 7 Kapitel 2 Einführung in den Themenbereich Element, das allen diese neuen Möglichkeiten zugrunde liegt ist der Agent mit all seinen unterschiedlich ausgelegten Definitionen. [Jennings et al. 1998a] Dass der Begriff von vielen Leuten in den verschiedensten Forschungs- aber auch Anwendungsbereichen auf ebenso viele unterschiedliche Arten gebraucht wird, zeigt einerseits die große Dimension, die die Agententechnologie erreicht hat, führt andererseits aber auch zu einer Überstrapazierung des Begriffes Agent. So werden die Grenzen, die ohnehin schon sehr fließend sind, vor allem von Seiten der Industrie, der natürlich viel daran liegt, den Absatz durch „neuartige Agententechnologie“ zu fördern, noch weiter verwischt. Ein Zitat, das oben genanntes Problem voll zum Ausdruck bringt, stammt von Peter Wayner : „Vom Hilfesystem eines Textverarbeitungsprogramms bis zu mobilem Code der übers Netzwerk unser Geschäfte abwickelt, alles wird derzeit als Agent bezeichnet. Die Metapher ist so vielseitig verwendet worden, dass wir nur noch auf eine Firma warten, die ihre Computer-Netzschalter als Stromversorgungsagenten bewirbt.“1 [Wayner et al. 1995] Bis jetzt sind diese Befürchtungen zwar noch nicht eingetreten, aber dieses Zitat zeigt den großen Hype der rund um Agententechnologie entstanden ist, und die werbewirksame Nutzung die nun schon geraume Zeit stattfindet. Man sieht also bereits in welchen stark differierenden Bereichen Agententechnologie zur Anwendung kommt und kann sich somit auch vorstellen, welch unterschiedliche Sichtweisen der ganzen Agententechnologie zugrunde liegen. In diesem Kapitel wird zunächst in Abschnitt 2.2 ein kurzer Überblick über die geschichtliche Entwicklung der Agentenforschung gegeben. In Abschnitt 2.3 werden einige ausgewählte Definitionen des Begriffs Agent, wie sie in der Literatur zu finden sind, vorgestellt. Eine Aufzählung von möglichen Eigenschaften die ein Agent besitzen kann bzw. muss wird in Abschnitt 2.4 gemacht, und führt zu einer alternativen Definition des Begriffs, mittels Eigenschaften. Für die praktische Realisierung von Agenten stellt sich die Frage, wodurch sich ein Agent von herkömmlichen Objekten unterscheidet. Die Antwort auf diese Frage wird in Abschnitt 2.5 gesucht. Im Zusammenhang mit Agententechnologie wird oftmals der Begriff Intelligenz verwendet, mit dieser Problematik befasst sich Abschnitt 2.6. Schließlich wird in Abschnitt 2.7 eine von vielen möglichen Klassifikationen von Agenten vorgestellt, die als Grundlage für weitere Recherchen herangezogen wird. Mit einer kurzen Zusammenfassung wird dieses Kapitel abgeschlossen. Das Ziel dieses Kapitels ist, eine Annäherung an den Begriff Agent zu finden, eine Möglichkeit der Abgrenzung zwischen Agenten und herkömmlicher Software zu zeigen. „The buzzword agent has been used recently to describe everything from a word processor`s help system to mobile code that can roam networks to do our bidding. The metaphor has become so pervasive that we are waiting for some enterprising company to advertise its computer power switches as empowerment agents.” [Wayner et al. 1995] 1 Seite 8 2.2 Geschichtliche Betrachtungen Als 1950 Alan Turing in seinem berühmten Werk „Computing Machinery and Intelligence“ aus dem Jahr 1950 den nach ihm benannten Turing-Test veröffentlichte, bedeutete dies eine große Inspiration für die Anhänger der Künstlichen Intelligenz (KI). Der Turing-Test2 erlaubt eine anschauliche Darstellung maschineller Intelligenz. Danach gilt eine Maschine dann als intelligent, wenn ihr Antwortverhalten nicht von demjenigen eines Menschen unterschieden werden kann. Die Arbeit Turings trug entscheidend dazu bei, dass Ende der 1950’er Jahre die Forschungsrichtung KI3weiter Verbreitung fand. [Middleton 2001] Die Idee, die hinter dem Begriff Agent im Zusammenhang mit Softwaresystemen steckt, entstand nach Ansicht von Jeffrey M. Bradshaw [Bradshaw 1997] Mitte der 1950’er Jahre. John McCarthy und Oliver G. Selfridge, die zu dieser Zeit beide am Massachusetts Institute of Technology (MIT) gearbeitet haben, dachten dabei an ein System, das selbstständig, durch die Ermittlung geeigneter Computeroperationen, ihm gestellte Aufgaben lösen kann. Ein solches System sollte auch in der Lage sein Hilfe anzufordern, wenn es diese benötigt. Im Gegensatz zum, damals schon populären Bild vom Roboter sollte dieses System nicht in der physikalischen, „realen“ Welt agieren, sondern im Computer. [Bradshaw 1997] In den frühen Jahren der KI waren vor allem die Arbeiten folgender Forscher sehr bedeutend. Marvin Minsky, der sich zuvor mit Neuronalen Netzwerken beschäftigt hatte und dabei nicht zu einem zufrieden stellenden Ergebnis kam4, begann gemeinsam mit John McCarthy an Systemen zu forschen, die auf einfacher Suche in symbolischen Repräsentationen5 basierten. Zur gleichen Zeit machten Allen Newell und Herbert Simon mit Systemen, die auf Heuristischer Suche basierten, gute Fortschritte beim Beweis von logischen Theoremen. Diese anfänglichen Erfolge führten schließlich dazu, dass die Heuristische Suche in symbolischen Repräsentationen der dominante Ansatz in der Künstlichen Intelligenz wurde. [Middleton 2001] Die 1960’er Jahre waren sehr erfolgreich. McCarthy entwickelte die Programmiersprache LISP, begann die Welt mittels Symbolen zu beschreiben und verwendete Logik um Probleme zu lösen6. Newell entwickelte den „General Problem Solver“. Mit diesem konnte jedes Problem gelöst werden, vorausgesetzt es existiert eine geeignete symbolische Repräsentation dafür. Viele Aufgaben wurden damit gelöst, 2 Der Test sieht wie folgt aus: Ein Proband (Mensch) sitzt vor einem Computerterminal, welches entweder mit einem anderen Computer oder mit einem menschlichen Bediener verbunden ist. Sowohl Bediener als auch Computer behaupten, sie seien Menschen. Der Proband soll während eines Dialogs mit seinem Gegenüber herausfinden, ob er sich mit einer Maschine oder tatsächlich mit einem Menschen unterhält. Wenn er keine Unterschiede feststellen kann oder nur in der Hälfte der Fälle die richtige Antwort gibt, dann hat die Maschine den Test bestanden und kann als intelligent bezeichnet werden. [Ferber 2001] 3 Nach [Russel et al. 1995] wurde die Forschungsrichtung KI 1956 bei der Dartmouth College Konferenz (USA) gegründet. 4 Minsky Glaubte zu diesem Zeitpunkt, dass diese Arbeit umsonst war, weil er mit der Bestimmung der Lerngewichte Probleme hatte. [Middleton 2001] 5 So genante Symbolic Search-based Systems. [Middleton 2001] 6 In diesem Zusammenhang wird von der symbolischen KI gesprochen. Diese geht von der These aus, dass sich relevante Fakten und Abhängigkeiten der realen Welt in eine symbolische Ebene abbilden lassen. Mittels Methoden der mathematischen Logik sei es möglich, in dieser symbolischen Ebene neue Fakten und Abhängigkeiten zu erschließen. [Bradshaw 1997] Seite 9 Kapitel 2 Einführung in den Themenbereich allerdings nur in einfachen, fehlerfreien symbolischen Welten. Es wurde angenommen, dass diese Lösungen auf allgemeine Probleme der realen Welt übertragbar sind. Die Wissenschaftler machten sich aber keine praktischen Gedanken darüber, sondern nutzten den stetigen Anstieg der Rechenleistung zur Vergrößerung des möglichen Suchraums, und konnten damit immer komplexere Probleme lösen. [Middleton 2001] In den 1970’er Jahren wurden die ersten Roboter entwickelt, wie zum Beispiel Shakey, der in einer speziellen Bausteinwelt selbstständig herumnavigieren konnte und auch in der Lage war Bausteine zu stapeln. Solche einfachen Welten vermieden die Komplexität realer Probleme. Spätesten Mitte der 1970’er Jahre wurde klar, dass die Erweiterung kleiner Prototypen zu realen Anwendungen im Bereich der KI einen exponentiellen anstelle eines linear anwachsenden Aufwandes bedeutet, und daher alles andere als trivial zu gelten hat. [Middleton 2001] Nach Ansicht von Hyazinth S. Nwana [Nwana 1996] stammt das erste Konzept eines Softwareagenten aus dieser Zeit. Hewitt veröffentlichte in einem Artikel im Jahre 1977 das „Actor“-Modell. Er betrachtete dort eine Gesellschaft von Spezialisten, die durch Kommunikation, also durch das gegenseitige Senden von Nachrichten, gemeinsam ein Problem lösen. Damit zeigte er, das Kontrollstrukturen klassischer Sprachen als Muster für die Kommunikation zwischen autonomen Einheiten, den Aktoren7, dienen können. Auf diesem Aktorkonzept aufbauend wurden viele Aktorsprachen entwickelt, die wiederum als Basis für eine große Anzahl von Multiagenten-Plattformen Verwendung fanden. [Nwana 1996] [Ferber 2001] In den 1980’er Jahren wurde mit dem Einsatz von Expertensystemen, deren Entwicklung schon bis in die 1960’ er Jahre zurückverfolgbar ist, ein neuer Versuch gestartet, praktische Probleme zu lösen. McCarthy hatte erkannt, dass, um Probleme außerhalb der einfachen Mikrowelten angehen zu können, zusätzlich zum speziellen Wissen über die Domäne noch „gesunder Menschenverstand“ nötig war. Knowledge Engineering, eine Forschungsrichtung innerhalb der KI, die sich mit Wissensrepräsentation befasste, wurde durch diese Erkenntnis sehr populär. Mit den Methoden und Werkzeugen dieser Forschungsrichtung wurden Versuche gestartet, die reale Welt in einer Wissensbasis zu speichern8. Unglücklicherweise wurde bewiesen, dass diese Idee nicht realisierbar war. Dies führte zur verbreiteten Meinung, dass wissensbasierte Systeme nicht für die Lösung praktischer Probleme geeignet sind. Schließlich wurde der Backpropagation Algorithmus entdeckt und führte zu einer Wiederbelebung der konnektionistischen9 Ansätze, die zuvor als Fehlansatz galten. [Middleton 2001] Obwohl es in der Forschungsrichtung der Verteilten Künstlichen Intelligenz (VKI) seit deren Entstehung Ende der 1970‘er Jahre einen eigenen Bereich für Multiagentensysteme 7 Ein Aktor ist eine Einheit, die aus zwei Teilen besteht: einer Struktur, die die Adressen aller anderen ihm bekannten Akteure enthält und denen er Nachrichten zusenden kann, sowie einem aktiven Teil, das Skript, welches sein Verhalten beim Empfang von Nachrichten beschreibt. Das Verhalten jedes Aktors, das parallel zum Verhalten der anderen Aktoren abläuft, besteht aus einer Menge extrem verkürzter Aktionen: Nachrichten senden, Aktoren erzeugen, Zustand ändern. Das ist nicht viel, genügt aber, da jede parallele Berechnung als Kombination dieser primitiven Aktionen ausgedrückt werden kann. Die Kommunikation zwischen Aktoren erfolgt durch den Austausch asynchroner Nachrichten. [Müller 1998] 8 Seit 1984 wird im CYC-Projekt versucht, umfassendes „Weltwissen“ zu speichern. Bislang umfasst die Wissensdatenbank 100.000 generelle Konzepte und 1000.000 Axiome der menschlichen Wahrnehmungswelt, die per Hand kodiert wurden, und Millionen mehr, die das System automatisch daraus abgeleitet hat. [Nwana 1996][Ferber 2001] 9Systeme die auf künstlichen Neuronalen Netzwerken basieren werden auch als konnektionistische Systeme Bezeichnet. [Middleton 2001] Seite 10 gab, hat man sich auch dort bis in die späten 1980‘er Jahre nur wenig Gedanken über die praktische Anwendung von Agenten gemacht. Nach Meinung von [Bradshaw 1997] wurde erst durch Alan Kay, einem großen Befürworter der Agententechnologie 1984 die Idee von McCarthy und Selfridge wieder in Erinnerung gerufen. In einem Artikel der Zeitschrift Scientific American beschreibt er „persönliche Agenten“ als Objekte, die die Erweiterung des Willens und der Absichten des Benutzers darstellen und die in den Computer eingebettet sind. Zwei Jahre später beschreibt Marvin Minsky in seinem Buch „The Society in Mind“ die Psyche eines Wesens (menschlich oder künstlich) als Ergebnis der Interaktion zwischen kleinen individuellen Agenten. Er stellt Mechanismen dar, die aus Konflikten und Kooperationen zwischen diesen kleinen Einheiten, ohne Einsatz einer zentralen Kontrollinstanz, resultieren. Minsky war der Überzeugung, dass die Psyche eines Wesens nicht durch auf Symbole bezogene Inferenzen funktioniert sondern eher durch selbstorganisierte Abstimmung zwischen autonomen Einheiten. Minsky begründete damit einen neuen Ansatz in der KI, den Agentenbasierten Ansatz. Dieser Ansatz hatte auf nachfolgende Arbeiten erheblichen Einfluss. [Bradshaw 1997] Die späten 1980’er Jahre und der Anfang der 1990’er Jahre verzeichneten einen Rückgang des Interesses an auf Suche basierenden symbolischen Ansätzen. Brooks kritisierte überzeugend die grundlegenden Annahmen des Symbolischen Ansatzes10, und konstruierte konkrete anschauliche Systeme für Roboter, die die „Welt als ihr eigenes bestes Modell“ benutzen. Dieser bottom up Versuch, der im Gegensatz zum Wissensbasierten Ansatz kein explizites internes Modell voraussetzt, wird auch als nouvelle KI bezeichnet. Nach anfänglichen Erfolgen versagte auch dieser Ansatz bei komplexeren praktischen Problemen. Anfangs der 1990’er Jahre wurde versucht diesen Ansatz durch kombinieren mit konnektionistischen Ansätzen unter Einsatz paralleler Hardware zu Verbessern. Durch die komplexe Architektur war diesen Systemen jedoch kein kommerzieller Erfolg beschieden. Dies führte dazu, dass Knowledge Engineering nun weitgehend als teuer und nur schwer wieder verwendbar angesehen wurde, und durch Methoden des maschinellen Lernens ersetzt wurde. Seit Mitte der 1990’er Jahre können Mustererkennungsalgorithmen in gewissen Bereichen, wie zum Beispiel bei der Klassifizierung von Newsbeiträgen, Ergebnisse liefern, die annähernd die Qualität der von Menschen erreichen. Hybride Ansätze, die Methoden der traditionellen und der nouvellen KI vermischen, werden für neue Anwendungsgebiete verwendet. [Middleton 2001] Seit der zweiten Hälfte der 1990’er Jahre lässt sich ein neuer Trend bemerken, welcher als Agentenorientiertes Programmieren bezeichnet wird. Dieser basiert auf den Ideen von Minsky und soll den Traum von Kay, die Indirekte Manipulation, verwirklichen. Experimente mit Interfaceagenten, die aus dem Verhalten ihren Benutzer lernen11, und Multiagentensysteme in denen einfache Agenten miteinander interagieren um gemeinsam ihre Ziele zu erreichen12, dominieren die Forschung. Diese Agentensysteme werden nun großteils zum Lösen praktischer Probleme eingesetzt und verwenden bewährte Methoden der Künstlichen Intelligenz. Auch der Bereich der Benutzermodellierung unterzog sich einem großen Wandel, von statischen Repräsentationen hin zu dynamischen 10 Brooks fordert, dass intelligente Maschinen, um die reale Welt wirklich verstehen zu können, mit ihr über Sensoren interagieren und ihr Wissen inkrementell aufbauen müssen. Intelligentes Verhalten sei darüber hinaus auch ohne explizite symbolische Repräsentation und abstrakte Schlussfolgerungen erreichbar. Intelligenz sei vielmehr eine emergente Eigenschaft komplexer Systeme. [Bradshaw 1997] 11 Diese Arbeiten wurden sehr stark von Pattie Maes geprägt. [Maes 1995] 12 Sehr bekannt für Arbeiten auf diesem Gebiet sind Wooldridge und Jennings [Wooldridge et al. 1995] Seite 11 Kapitel 2 Einführung in den Themenbereich verhaltensbasierten Modellen. Es wurde gezeigt, dass mit Methoden des maschinellen Lernens, Muster im Benutzerverhalten gefunden werden können. [Middleton 2001] Dieser oben genannte neue Trend führte einerseits zu der eingangs beschrieben großen Popularität der Agententechnologie, brachte aber andererseits den Nebeneffekt mit sich, dass nun für Vermarktungszwecke die Begriffe Agent und Agententechnologie sehr stark strapaziert wurden. Aus diesem Grund wird nun im folgenden Abschnitt auf die Problematik der Definition des Begriffs Agent eingegangen. 2.3 Agentendefinitionen Etwas überspitzt könnte man sagen, dass es in etwa so viele Definitionen des Begriffes Agent gibt wie es Wissenschaftler und Entwickler gibt, die sich mit dieser Thematik befassen. Manche Forscher vertreten die Ansicht, dass es genauso schwierig ist eine allgemein akzeptierte Definition für den Begriff Agent zu finden wie eine Definition für Intelligenz. Gegenwärtig ist es also nicht möglich eine allgemein gültige Definition des Begriffes Agent zu geben. Trotzdem sind gewisse Vorstellungen und Erwartungen an künftige Programme mit dem Begriff Agent verbunden. Bisher gab es eher passive Systeme, auf eine Eingabe folgt die Ausgabe. Beim Agenten soll das selbständige Handeln erfolgen, wobei auch hier die Grenzen verschwimmen. So gab es auch bisher schon Programme, auf die das Bild des eigenständigen Handelns zutraf und im Gegensatz dazu gibt es auch Agentenprogramme, die traditionelle Züge aufweisen. Burkard 1998 Ein weiteres Problem, das eine eindeutige Definition des Begriffes Agent erschwert, ergibt sich durch die mannigfaltigen Einsatzgebiete von Agenten. Abhängig von welchem Forschungsschwerpunkt oder praktischer Anforderung der Agent betrachtet wird, natürlich auch in Bezug auf ihren interdisziplinären Charakter, ergeben sich die verschiedensten Ansätze von Definitionen. Nach Ansicht von [Burkard 1998] haben folgende Forschungsrichtungen wesentlichen Einfluss auf die Entwicklung von Softwareagenten: Künstliche Intelligenz Verteilte Künstliche Intelligenz Netzwerk und Kommunikationssysteme (verteilte Systeme) Entscheidungstheorie Psychologie Im Folgenden werden nun einige ausgewählte Definitionen des Begriffs Agent vorgestellt, die sich dem Begriff aus jeweils einer anderen Sichtweise nähern. Ziel dieses Abschnitts ist, zu zeigen wie stark diese Definitionen voneinander differieren. Die Definition nach Dragon „Ein Agent ist ein Stück Software, dass etwas für dich erledigt.“13 [Dragon 1997] Nach Meinung des Autors dieser Arbeit kann diese Definition nicht ausreichen um 13 “An Agent is a piece of software that does something for you.” [Dragon 1997] Seite 12 den Agentenbegriff zu definieren. Die Forderung, ein Agent sollte eine Aufgabe für den Benutzer erledigen, muss in dieser Form wohl an jede Art von Software gestellt werden. Die Definition nach Cheong „Agenten können als persönliche Softwareassistenten betrachtet werden, die von ihren Benutzern Befugnisse übertragen bekommen.“14 [Cheong 1996] Diese Definition fordert eine Art von Autorität oder Befugnis, die einem Agenten von seinem Benutzer übertragen werden soll, woraus diese Befugnis genau bestehen soll und was der Agent damit anfangen soll, bleibt unklar. Die Definition nach Russell „Ein Agent ist alles das, was seine Umgebung mittels Sensoren wahrnimmt und mittels Effektoren in dieser Umgebung agiert.“15 Russel et al. 1995 Die zentralen Punkte dieser Definition sind beobachten und handeln innerhalb einer Umgebung. Wobei eine genaue Spezifizierung von Umgebung aber auch von Beobachtung und Handlung fehlt. Daher wäre es notwendig weitere Einschränkungen bezüglich dieser drei Komponenten vorzunehmen. Die Definition nach Lingau, Drobnik, Dömel „Ein Agent ist ein Computerprogramm dessen Aufgabe es ist, einem Benutzer bei der Ausführung von Aufgaben zu helfen. Für diesen Zweck kann er mit seinem Benutzer, anderen Agenten und der Umgebung im Allgemeinen kommunizieren, und er besitzt einen dauerhaften Zustand.“16 [Lingau et al. 1995] In dieser Definition wird die Kommunikationsfähigkeit in den Vordergrund gestellt. Um sein Ziel zu erreichen, kann ein Agent mit seinem Besitzer, anderen Agenten und seiner Umgebung kommunizieren. Die Definition nach Maes „Autonome Agenten sind Computersysteme, die sich in einer komplexen, dynamischen Umgebung befinden, in dieser selbständig wahrnehmen und reagieren, und so jene Aufgaben erledigen, für die sie geschaffen wurden.“17 Maes 1995 Pattie Maes, Leiterin der Software Agents Group am MIT Media Lab, fordert, dass Agenten in komplexen und dynamischen Umgebungen agieren können sollen. Außerdem müssen Agenten selbstständig sein, das bedeutet, dass sie den Großteil ihrer Aufgaben ohne direkte Intervention von Menschen ausführen und Kontrolle über ihren eigenen Zustand haben. Es wird also die Autonomie in den Vordergrund gestellt. “Agents can be considered personal software assistants with authority delegated from their users.” [Cheog 1996] 15 "An agent is anything that can be viewed as perceiving its environment through sensors and acting upon that environment through effectors." Russel et al. 1995 16 “An agent is a computer program whose purpose is to help a user perform some task (or set of tasks). To do this, it contains persistent state and can communicate with its owner, other agents and the environment in general.” [Lingau et al. 1995] 17 „Autonomous agents are coputational systems that inhabit some complex dynamic environment, sense and act autonomously in this environment, and by doing so realize a set of oals or tasks for which they are designed” [Maes 1995] 14 Seite 13 Kapitel 2 Einführung in den Themenbereich Die Definition nach Wooldridge-Jennings „Ein Agent ist eine Hardware oder normalerweise ein softwarebasierendes Computersystem, das die folgenden Eigenschaften besitzt“18: Wooldridge et al. 1995 autonom: Agenten arbeiten ohne die direkte Intervention von Menschen oder anderen und haben eine gewisse Kontrolle über ihre Aktionen und ihrem internen Zustand. sozial: Agenten interagieren mit anderen Agenten oder möglicherweise mit Menschen mittels einer Agentenkommunikationssprache. reaktiv: Agenten nehmen ihre Umgebung (physikalische Welt, Benutzer, andere Agenten, Internet oder jede beliebige Kombination von diesen) wahr, und reagieren in einer zeitlichen Abhängigkeit auf Änderungen die dort geschehen. proaktiv:. Agenten agieren nicht nur als Reaktion auf ihre Umgebung, sondern sie sind in der Lage die Initiative zu übernehmen und dabei ein zielorientiertes Verhalten zu zeigen In [Wooldridge et al. 1995] werden zwei Ausprägungen des Begriffs Agent unterschieden. Die oben angeführte Definition beschreibt den so genannten „schwachen Agentenbegriff“. Die darin enthaltenen Eigenschaften werden von vielen Forschern als Grundvoraussetzung für einen Agenten angesehen. Im Gegensatz dazu gibt es allerdings auch den Begriff des „starken Agenten“. Dieser starke Agentenbegriff entspricht hauptsächlich dem Verständnis von Forschern aus dem Bereich der Künstlichen Intelligenz. In dieser zweiten Auslegung spielen menschenähnliche Merkmale wie zum Beispiel Wissen, Glauben, Intention oder Verpflichtung19 eine große Rolle. Es ist schon aus diesen wenigen Beispielen ersichtlich, dass die Definitionen stark voneinander abweichen, daher wird es wohl in naher Zukunft keine allgemeine Definition für den Begriff Agent geben. Jedoch findet der Autor dieser Arbeit den Ansatz von Wooldrige und Jennings, Agenten mittels Aufzählung von Eigenschaften zu definieren als sehr anschaulich. Im folgenden Abschnitt werden mögliche Eigenschaften von Agenten betrachtet, um auf diesem Wege ein genaueres Bild über das „Wesen“ eines Agenten zu bekommen. 2.4 Eigenschaften von Agenten In der Literatur finden sich verschiedenste Eigenschaften von Agenten, die dazu geeignet sind Agenten zu beschreiben. Dazu zählen natürlich auch die Eigenschaften, die in den vorangegangenen Definitionen bereits enthalten sind. An dieser Stelle werden diese unter dem Aspekt der Charakterisierung von Agenten mittels verschiedener Eigenschaften näher erklärt. “… a hardware or (more usually) software-based computer system that enjoys the following properties: autonomy: agents operate without the direct intervention of humans or others, and have some kind of control over their actions and internal state social ability: agents interact with other agents (and possibly humans) via some kind of agentcommunication language reactivity: agents perceive their environment, (which may be the physical world, a user via a graphical user interface, a collection of other agents, the INTERNET, or perhaps all of these combined), and respond in a timely fashion to changes that occur in it”. [Wooldridge et al.1995] 19 Im englischen werden diese Merkmale mittels Believe, Desire und Intention beschrieben, deshalb werden diese Agenten auch als BDI-Agenten bezeichnet. [Müller 1998] 18 Seite 14 Autonomie Autonomie kommt in sehr vielen Definitionen vor (siehe Abschnitt 2.3) Autonomie bedeutet, dass der Agent nicht durch einen Menschen gesteuert werden muss, d.h. er kann selbstständig handeln und Entscheidungen treffen ohne dass der Benutzer einschreiten muss. Der Agent muss, um autonom zu sein, die Kontrolle und den Überblick über seine Aktionen haben. Er muss dazu ein gewisses Grundwissen über die Aktionen die er ausführen will und kann, über deren Bedeutung und über Aktionen die er bereits ausgeführt hat, besitzen. Autonomie ist somit ein wesentliches Merkmal zur Unterscheidung zwischen einem Agenten und einem „herkömmlichen“ Programm. Für den Benutzer ist es dabei natürlich von großer Bedeutung wie weitreichend die Autonomie ist, mit der Aktionen ausgeführt werden. Der Grad der Autonomie ist dabei vom Aufgabengebiet und dem Vertrauen, dass der Benutzer dem Agenten entgegenbringt, abhängig und sollte deshalb auch vom Benutzer bestimmt werden können. [Schneeberger 2001a] Reaktivität Ein Agent soll angemessen auf Änderungen in seiner Umgebung reagieren. Die Umgebung eines Agenten kann dabei die physikalische Umgebung, der Benutzer, andere Agenten oder das Internet sein, wobei diese Umgebungsbedingungen auch frei kombinierbar sind, sodass im Extremfall alle diese Bereiche sogar gemeinsam als für den Agenten relevante Umgebung betrachtet werden können. Dabei tritt das Problem auf, dass fast alle interessanten Umgebungen dynamisch sind, d.h., dass sie sich permanent verändern, und dass nicht alle Veränderungen vom Agenten auch wahrgenommen werden können. Wir Menschen haben eine hervorragende Fähigkeit nur die Veränderungen unserer Umgebung wahrzunehmen, die für uns in der aktuellen Situation wirklich relevant sind. Für Agenten kann dies eine sehr schwierige Aufgabe sein. [Schneeberger 2001a] Proaktivität Die Proaktivität stellt gegenüber der Reaktivität eine qualitative Steigerung dar. Proaktivität bedeutet, dass ein Agent von sich aus aktiv wird, d.h. Aktionen ausführt. Um eine vernünftige Entscheidung für eine bestimmte Aktion treffen zu können, muss der Agent eine Beschreibung des Ziels besitzen, dem alle auszuführenden Aktionen dienen sollen. [Schneeberger 2001a] Persistenz Ein Agent ist in der Lage, seinen Zustand zu einem Zeitpunkt seiner Wahl persistent ablegen zu können. Dieses Abbild stellt den Agenten im deaktivierten Zustand dar. Wenn der Agent aktiviert wird, muss er die Arbeit nach der Position der Deaktivierung wieder aufnehmen. Die Eigenschaft der Persistenz bildet die Voraussetzung für die Mobilität. [Murch et al. 2000] Mobilität Der Agent ist in der Lage während seiner Ausführung, über ein Netzwerk, seinen Standort zu verändern, und dort seine Ausführung fortzusetzen20. Neben dem Programmcode muss für diesen Zweck auch die Statusinformation des Agenten transportiert werden. Der Agent kann so eine ganze Reihe von Servern besuchen und verteilte Informationen sammeln und analysieren. Dadurch wird je nach Anzahl der 20 In der Literatur wird in diesem Zusammenhang von Migration gesprochen. Seite 15 Kapitel 2 Einführung in den Themenbereich besuchten Server die Netzbelastung stark reduziert. [Murch et al. 2000] Zuverlässigkeit Da der Benutzer seinem Agenten vertrauen muss, ist es die Pflicht des Agenten, dass er die ihm gestellte Aufgabe in der Art und Weise ausführt, die sein Benutzer von ihm erwartet. Abhängig von den Bereichen in denen ein Agent eingesetzt wird gibt es natürlich ein größeres oder kleineres Risiko, das durch die Übertragung von Aufgaben an einen Agenten entsteht. [Bigus et al.2001] Adaptivität und Lernfähigkeit Ein Agent ist in der Lage sein Verhalten basierend auf seinen früheren Erfahrungen zu verändern, das heißt er passt sich an bzw. ist lernfähig. [Caglayan 1998] Pattie Maes stellt in ihrem Artikel Maes 1994 einen Ansatz vor, bei dem Agenten einen Lernprozess durchlaufen. Sie betrachtet dafür eine spezielle Form von Agenten, so genannte „persönliche Assistenten“, die ihrem Benutzer beim Umgang mit verschiedenen Softwareapplikationen helfen sollen. Diese Applikationen müssen dazu bestimmte Voraussetzungen erfüllen, damit der Lernansatz gegenüber der direkten Programmierung vorteilhaft ist: Wiederkehrende Verhaltensmuster: Die Benutzung der Applikation muss eine bestimmte Menge an immer wiederkehrenden Verhaltensmustern aufweisen. Verhaltensmuster müssen Benutzerabhängig sein: Die wiederkehrenden Verhaltensmuster müssen von Benutzer zu Benutzer verschieden sein. Ist dies nicht der Fall, so ist es effektiver, einen Agenten direkt zu programmieren, d. h. es ist der Wissensbasierte Ansatz vorzuziehen. Eine notwendige Voraussetzung für den Einsatz von Methoden des maschinellen Lernens ist das Auftreten von Regelmäßigkeiten im Verhalten des Benutzers. Im Falle von persönlichen Agenten, die von ihren Benutzern lernen, ist es sinnvoll wenn der Agent sein Verhalten gegenüber dem Benutzer begründen kann. Das gibt dem Benutzer die Möglichkeit, fehlerhaftes Verhalten zu analysieren. Kommunikationsfähigkeit Bei der Kommunikation unterscheidet man zwischen der Kommunikation mit dem Benutzer und der Kommunikation zwischen mehreren Agenten. Die Kommunikation mit dem Benutzer sollte dabei möglichst einfach sein. Der Idealfall wäre, wenn der Benutzer in natürlicher Sprache mit dem Agenten kommunizieren könnte. Dann müsste der Benutzer keine Kommandos erlernen, sondern er könnte mit seinen Worten Aufträge formulieren. Die Kommunikation zwischen Agenten erfordert eine standardisierte formale Sprache. Solche Sprachen werden auch als Agent Communication Language (ACL) bezeichnet. Nachrichten dieser Sprachen werden nach formalen Vorschriften formuliert, so dass sie auch von Agenten verstanden werden können, die von verschiedenen Programmierern implementiert wurden. [Murch et al. 2000] Viele Forscher sehen die Kommunikationsfähigkeit mittels einer Agent Communication Language als eine Schlüsseleigenschaft von Agenten. In Kapitel 4 wird auf diesen Aspekt näher eingegangen. Seite 16 Kooperationsfähigkeit Agenten, die zur Lösung bestimmter Aufgaben, die sie selbst nicht bewältigen können, mit anderen Agenten zusammenarbeiten, werden als kooperativ bezeichnet. Die Kooperationsfähigkeit kann dabei als Spezialisierung der Fähigkeit zur Kommunikation gesehen werden. Es gibt zwei grundlegende Formen der Kooperation. Die direkte Kommunikation, bei der Agenten die Koordination selbst durchführen oder die indirekte Kommunikation, bei der die Agenten sich auf ein spezielles Systemprogramm verlassen, welches die Koordination realisiert, solche Systeme werden auch als föderalistische Systeme bezeichnet (siehe Abschnitt 4.4.5). [Murch et al. 2000] Soziales Verhalten Neben der Fähigkeit zu kommunizieren wie es in der Definition nach WooldridgeJennings (siehe Abschnitt 2.3) nachzulesen ist, versteht man unter sozialem Verhalten eines Agenten auch die Fähigkeit eines Agenten sich kooperativ zu verhalten, auch wenn er selbst keinen Nutzen aus diesem Verhalten zieht. Ein Beispiel dafür wäre der Austausch von bereits gefundener Information, auf deren Suche sich ein anderer Agent gerade befindet. [Bigus et al.2001] Persönlichkeit Für die Interaktion mit dem Benutzer kann es sinnvoll sein, den Agenten mit menschenähnlichen oder zumindest lebewesenähnlichen Charakteristiken auszustatten. Diese Eigenschaft ist jedoch keine notwendige Eigenschaft für Agenten. Eben so wenig sind alle Programme, welche diese Eigenschaft besitzen als Agent zu bezeichnen. [Bigus et al. 2001] Rationalität Wenn ein Agent ein hilfreicher Assistent sein soll, dann muss er sich vernünftig, d.h. rational verhalten. Ein Agent sollte die Vergangenheit wahrnehmen. Ereignisse oder Dinge, die in der Vergangenheit vom Agenten bemerkt bzw. gesehen wurden, müssen durch den Agenten registriert und erinnert werden. Die registrierte Vergangenheit soll danach in die Aktionen des Agenten einfließen. Ein rationaler Agent muss Wissen über seine Handlungsmöglichkeiten haben. Ein Agent kann eine Reihe von Aktionen ausführen, und er muss sich darüber bewusst sein, dass er diese Möglichkeiten hat. Dieses Wissen ist auch Vorraussetzung für planvolles Handeln. Für Rationalität ist Wissen über die Umgebung notwendig. Außerdem muss der Agent bewerten können, ob er in Bezug auf das gesetzte Ziel erfolgreich handelt. [Schneeberger 2001a] Abschließend zu diesem Abschnitt stellt sich nun die Frage welche minimale Teilmenge der aufgelisteten Eigenschaften ein Softwaresystem besitzen muss, um als Agent bezeichnet werden zu können bzw. welche Eigenschaften muss ein Agent besitzen um von herkömmlicher Software unterschieden werden zu können. Wie nicht anders zu erwarten ist, existieren auch hier unterschiedliche Meinungen, so sehen manche Forscher die Mobilität, wieder andere die Adaptivität als Schüsseleigenschaft eines Agenten. Tendenziell vertritt aber die Mehrheit der Forschern die Meinung, dass folgende vier Eigenschaften, Agentensoftware von herkömmlicher Software, wie z.B. Expertensystemen, Verteilten Systemen, oder Objektorientierten Systemen abgrenzt (siehe z. B. [Jennings et al. 1998a], oder [Schneeberger 2001a]): Seite 17 Kapitel 2 Einführung in den Themenbereich Autonomie Proaktivität Reaktivität Kommunikationsfähigkeit Wichtig dabei ist, dass alle diese vier Eigenschaften erfüllt sein müssen, damit man von Agentensoftware sprechen kann, andernfalls hat man es mit einer anderen Softwarekategorie zu tun. Als ein Beispiel für eine solche Abgrenzung werden im nächsten Abschnitt die Unterschiede zwischen Agent und einem klassischen Objekt eingehend behandelt. 2.5 Agenten und Objekte Aus dem Blickwinkel der Objektorientierten Programmierung betrachtet ist es oft nicht möglich die neuen Ideen die sich hinter dem Agentenparadigma verbergen, zu erkennen. Dies ist auch nicht verwunderlich, da tatsächlich viele Gemeinsamkeiten zwischen Objekten und Agenten gefunden werden können. Im Folgenden sollen nun die prinzipiellen Unterschiede zwischen Agenten und Objekten erläutert werden. Weiters wird untersucht, inwiefern das Konzept eines Agenten als Erweiterung eines Objekts im objektorientierten Paradigma betrachtet werden kann. Die folgenden Betrachtungen sind vorwiegend aus [Schimkat 2003] entnommen. Abbildung 2.1: Datenstrukturen, Objekte und Agenten aus [Schimkat 2003] nach [Joseph et al. 2001] Objekte Im objektorientierten Paradigma spielt das Objekt die zentrale Rolle. Ein Objekt zeichnet sich durch zwei prinzipielle Eigenschaften aus: Zustand und Verhalten. Der Zustand eines Objekts wird – aus Sicht des Objekts – in internen Datenstrukturen abgelegt. Der Zugriff auf die Datenstrukturen und auf den Objektzustand erfolgt über Nachrichten, die an das Objekt gesendet werden. In der Nachricht ist festgelegt, welche Methoden oder Datenstrukturen des Objekts aufgerufen werden. Der Zugriff auf die privaten Daten ist von außen nur über freigegebene Methoden möglich, damit ist ein Seite 18 Objekt in Bezug auf seinen internen Zustand autonom, d.h. es besitzt die Kontrolle über seinen internen Zustand. Ein Objekt besitzt aber nicht die Kontrolle über sein Verhalten, d.h. wenn eine Methode des Objekts freigegeben ist, dann können andere Objekte - wann immer sie wollen - diese ausführen. Diese Art des Zugriffsmechanismus auf Objekte, wie es in Abbildung 2.1 illustriert ist, ermöglicht eine Kapselung von Daten bzw. Datenstrukturen in Objekten. Agenten In objektorientierter Hinsicht wird ein Agent als ein Objekt mit einer zusätzlichen Kapselungsschicht verstanden. Diese zusätzliche Schicht kontrolliert alle Zugriffe auf die Methoden und Datenstrukturen des Agenten, wie es in Abbildung 2.1 verdeutlicht ist. So werden sämtliche Nachrichten an einen Agenten durch diese Schicht geleitet. Dort wird entschieden, welche Methoden eines Agenten tatsächlich ausgeführt bzw. aktiviert werden. Dadurch erhält der Agent auch die Kontrolle über sein Verhalten, d.h. er ist auch autonom bezüglich seines Verhaltens. Diesen Entscheidungsprozeß in einem Agenten bezeichnet man auch als Verhaltensaktivierung. Objekte und Agenten stellen beide eine nachrichtenbasierte Schnittstelle zu ihren internen Datenstrukturen und Algorithmen (Methoden) zur Verfügung, dabei ist jedoch zu beachten, dass der Begriff der Nachricht unterschiedliche Bedeutungen bei Objekten und Agenten besitzt: Eine Nachricht im objektorientierten Sinne entspricht einem Aufruf von Methoden oder Datenstrukturen, die zu einem Objekt gehören. Dieser Aufruf setzt voraus, dass die syntaktischen Details der Methodensignatur und Datenstruktur bekannt sind. Falls sich beispielsweise die syntaktische Reihenfolge der Übergabeparameter einer Methode ändern sollte, sind alle Nachrichten bezüglich dieser Methode entsprechend anzupassen. Nachrichten werden zwischen Agenten in einem einheitlichen Format verschickt, d.h. jeder Agent benutzt unabhängig von der inhaltlichen Bedeutung die gleiche syntaktische Schnittstelle für den Austausch von Nachrichten. Nachdem der Inhalt der Nachricht von der zusätzlichen Zugriffsschicht eines Agenten analysiert worden ist, wird das entsprechende Verhalten im Agenten aktiviert, in dem die dafür notwendigen Methoden aufgerufen werden (siehe Abbildung 2.1). Nach dem Prinzip der Verhaltensaktivierung bei Agenten übernimmt der „aufgerufene“ Agent die Auswahl der entsprechenden Aktionen. Im Vergleich zu „objektorientierten Nachrichten“ werden in den Nachrichten von Agenten keine aufzurufenden Methodensignaturen, sondern bedeutungsvolle und komplexe Nachrichteninhalte hinterlegt. Auf der Grundlage der oben beschriebenen Eigenschaften und Charakteristika von Objekten und Agenten können folgende wesentlichen Unterschiede festgestellt werden: Im Allgemeinen sind Objekte passive Repräsentanten eines Abbilds der realen Welt. Damit ein Objekt selbst aktiv wird, muss zuerst eine Nachricht an das entsprechende Objekt gesendet werden. Proaktives Veralten ist im Objektmodell nicht definiert. Agenten sind durch ihre aktiven und proaktiven Eigenschaften wesentlich unabhängiger von den Kontroll- und Informationsflüssen ihrer Umgebung. Obwohl Objekte ihre Daten und Verhaltenseigenschaften in geeigneter Weise kapseln, bleiben die Aspekte der Verhaltensaktivierung davon unberücksichtigt. Methoden eines Objekts werden von außen aufgerufen, d.h. jede als öffentlich deklarierte Methode kann von anderen Objekten direkt aktiviert werden. Objekte besitzen keine Seite 19 Kapitel 2 Einführung in den Themenbereich weiteren Wahlmöglichkeiten, die Zugriffe auf ihre Methoden bzw. ihr Verhalten zu beeinflussen, somit sind Objekte im Gegensatz zu Agenten bezüglich ihres Verhaltens nicht Autonom. Ein weiterer Unterschied bezieht sich auf die Form der Kommunikation zwischen Objekten und Agenten untereinander. Im Mittelpunkt der Kommunikation zwischen Objekten stehen die syntaktischen Schnittstellen der Methodensignaturen und die internen Datenstrukturen. Der Aufruf einer bestimmten Objektmethode oder Datenstruktur impliziert gleichzeitig deren inhaltliche Bedeutung, d.h. zum Zeitpunkt des Methodenaufrufs müssen nicht nur die syntaktischen, sondern auch die semantischen Bedeutungen des Aufrufs bereits bekannt sein. Im Gegensatz dazu trennen Agenten syntaktische und semantische Details der Kommunikation. Agenten benutzen ein einheitliches und von der Bedeutung konkreter Nachrichteninhalte unabhängiges Nachrichtenformat. Dies gewährleistet die langfristige Gültigkeit von Kommunikationsschnittstellen im Hinblick auf die möglichen Änderungen der Methodensignaturen im Laufe eines Agentenlebens. Die inhaltliche Bedeutung einer Nachricht wird in einem separaten Schritt verarbeitet. Weiters kann auch bezüglich der Ausführung ein Unterschied festgestellt werden. Jeder Agent muss in einem eigenen Prozess ausgeführt werden um proaktives Verhalten zu ermöglichen, bei klassischen objektorientierten Systemen ist dies i.a. nicht der Fall, hier existiert ein Thread für das ganze System (für alle Objekte zusammen). Durch die Einführung und Unterstützung so genannter „aktiver Objekte“ in modernen objektorientierten Programmiersprachen wie z.B. JAVA ist diese Unterscheidung nur mehr beschränkt möglich. [Jennings et. al 1998a] Nach Ansicht des Autors dieser Arbeit bringt folgendes Zitat die Unterschiede zwischen Objekten und Agenten voll zum Ausdruck: „Objekte arbeiten freiwillig, Agenten für Geld.“21 [Jennings et. al 1998a] Bezüglich der Frage inwieweit das Konzept eines Agenten als Erweiterung eines Objekts im objektorientierten Paradigma betrachtet werden kann sind sich die Forscher nicht einig. Ein Ansatz für die Modellierung von Agenten beruht jedoch auf der Annahme, dass Agenten die konsequente Fortentwicklung von Objekten sind. Die Untersuchung von Methoden, die eine angemessene Entwicklung von Agenten unterstützen, und möglicherweise in Analogie zum objektorientierten Paradigma zu einem agentenorientierten Paradigma führen, ist derzeit noch nicht abgeschlossen. [Jennings et. al 1998a] In der Literatur wird häufig von intelligenten Agenten gesprochen, wobei man bei der Definition von Intelligenz wiederum auf Schwierigkeiten stößt. Dieser Problematik wird folgender Abschnitt gewidmet. 2.6 Agenten und Intelligenz Agentenbasierte Systeme werden gern als intelligent bezeichnet. Im Bereich der Künstlichen Intelligenz existiert jedoch derzeit keine allgemein akzeptierte Definition für 21 „Objects do it for free; agents do it for money.“ [Jennings et. al 1998a] Seite 20 Intelligenz, daher verbergen sich hinter dieser Eigenschaft verschiedene Sichtweisen. Häufig werden Agenten, die der Definition aus Abschnitt 2.4 genügen bereits als intelligente Agenten bezeichnet. Andere Forscher bezeichnen die Fähigkeit eines Agenten aus den Ergebnissen vorangegangener Problemlösungsprozesse zu lernen und, darauf aufbauend, selbstständig seine Lösungsstrategie zu verbessern als Intelligenz, wiederum andere vertreten die Ansicht, dass einzig der Einsatz von Techniken der Künstlichen Intelligenz bei der Implementation von Agenten dieses Attribut rechtfertigt. Die Österreichische Gesellschaft für Artificial Intelligence (OeGAI) 22 definiert diesen Sachverhalt folgendermaßen: Unter Intelligenz „[…] versteht man die Fähigkeit der Bewältigung einer neuartigen Situation in Bezug auf deren Erfassung, Bewertung, Anwendung und Zusammenhängen. Für Software kann nur bedingt von Intelligenz gesprochen werden, da Software keine Schlussfolgerungen erarbeiten kann, wohl aber Befehle des Benutzers entgegennehmen und in seinem Sinne ausführen kann, wobei Ziele und Regeln definiert sein müssen. Je besser die Vorgaben erfüllt werden, desto „intelligenter“ ist eine Software.“ Nach Meinung von M. Minsky [Minsky 1985] entsteht intelligentes Verhalten von Computerprogrammen erst aus der Zusammenarbeit vieler, eher „dummer“ Programme. Bezogen auf agentenbasierte Systeme bedeutet dies, dass ,,Intelligenz“ in einem Agentensystem durch die Interaktion und die Kommunikation zwischen einfachen Agenten entstehen kann. Die einzelnen Agenten müssen dabei kein Neuronales Netz oder ein Expertensystem enthalten. Intelligenz ist also eine Eigenschaft eines Systems von interagierenden Agenten. In der Literatur wird in diesem Zusammenhang auch von „emergenter Intelligenz“ gesprochen. [Bradshaw 1997] Diese Meinung schließt sich der Autor dieser Arbeit an. Die „Entstehung von Intelligenz“ kann in diesem Sinne anhand des folgenden einfachen Beispiels veranschaulicht werden: Ein Anwender plant sich ein Buch zu kaufen. Aus diesem Grund beauftragt er einen Softwareagenten Preis und Produktinformationen im Internet einzuholen. Als Ergebnis erwartet der Anwender eine übersichtliche Auflistung der Angebote, unter Berücksichtigung des Zolls, der Versankosten und der Lieferdauer. In einem ersten Schritt wird der Agent einen Suchagenten kontaktieren, um Adressen von Online-Bücher-Shops zu erfragen. Im nächsten Schritt wird der Agent Kontakt mit den Agenten der Online-Shops aufnehmen und ihnen in einer Anfrage die Daten des gewünschten Buchs mitteilen. Als Antwort erhält der Agent Produktinformationen, den Preis und zusätzliche Lieferinformationen, wie Versankosten, Zahlungsmöglichkeiten, Lieferzeit und Auslieferungsland. Das Auslieferungsland ist wichtig, da der Agent auch einen eventuellen Einfuhrzoll mitberücksichtigen soll. In einem weiteren Schritt wird der Agent den Agenten des Finanzministeriums kontaktieren um die nötigen Zollinformationen einzuholen. Weiters kontaktiert der Agent den Agenten einer OnlineBank, um den aktuell gültigen Wechselkurs zu ermitteln. Die Adresse der Online-Bank hat der Agent zuvor von einem Suchagenten erhalten. Im letzten Schritt erfolgt die Preisberechnung und die übersichtliche Aufstellung der gesammelten Daten. Zusammengefasst sehen die Schritte, die der Agent ausführt, folgendermaßen aus: 22 http://www.oegai.at Seite 21 Kapitel 2 Einführung in den Themenbereich 1. Kontaktiere Suchagenten und hole Adressen von Online-Shops ein. 2. Kontaktiere Agenten der Online-Shops, sende die Produktanfrage und hole Preis, Produkt und Lieferinformationen ein. 3. Kontaktiere Agenten des Finanzministeriums und hole Zollinformationen ein. 4. Kontaktiere Suchagenten und hole Adressen von Online-Banken ein. 5. Kontaktiere Agenten der Online-Banken und hole den aktuellen Wechselkurs ein. 6. Führe die Preisberechnung durch. 7. Stelle die gesammelten Informationen übersichtlich zusammen. Keiner dieser Einzelschritte benötigt ein Verfahren der künstlichen Intelligenz. Die erbrachte Leistung des Agenten kann man jedoch durchaus als intelligent bezeichnen. Die „Intelligenz“ entsteht aus der Interaktion mit den Service-Agenten im Netz. Dieses Beispiel zeigt die Stärken des Agenten Paradigmas auf. Durch die Zusammenarbeit vieler einfacher Einzelsysteme entstand ein Gesamtsystem, welches in der Lage ist, auch komplexe Probleme zu lösen [Reiff 2000]. Mit den bisherigen Erkenntnissen können nun einige wichtige Begriffe, die in dieser Arbeit Verwendung finden definiert werden. Der Begriff Agent oder Software Agent bezeichnet ein Programm, das zumindest die folgenden vier Eigenschaften - Autonomie, Proaktivität, Reaktivität und Kommunikationsfähigkeit - besitzt. Als agentenbasiertes System wird im folgenden Software, die auf Basis von Agenten entworfen und implementiert wurde, bezeichnet. Ein solches System besteht im Regelfall aus mindestens einem Agenten. Die Bezeichnung Agentensystem oder auch Multiagentensystem wird im weiteren Verlauf dieser Arbeit für ein agentenbasiertes System, das aus mehreren interagierenden Agenten besteht, verwendet. Im folgenden Abschnitt wird nun eine Klassifikation von Agenten vorgestellt. Diese soll zum einen als Orientierungshilfe dienen und zum anderen die Überleitung in das nächste Kapitel 3 (Informationsagenten) erleichtern. 2.7 Klassifikation von Agenten Eine einheitliche Typologie von Softwareagenten gibt es leider noch nicht, ähnlich wie es auch noch keine einheitliche Definition von Agenten gibt. So können Agenten nach verschieden Kriterien klassifiziert werden. Denkbar wäre zum Beispiel eine Klassifikation nach den bereits in Abschnitt 2.4 beschriebenen Eigenschaften. Man kann aber auch die Aufgabe die Agenten erfüllen (z.B. Filteragent, Suchagent, etc.), oder die Umgebung, in der Agenten wirken (z.B. Datenbank, Filesystem, Netzwerk, Internet, etc.), aber auch die zur Programmierung der Agenten verwendete Programmiersprache und viele andere Kriterien dazu heranziehen eine Klassifikation zu treffen. Die Folgenden Betrachtungen beziehen sich im Wesentlichen auf [Nwana 1996]. Alternative, oder ähnliche Klassifikationen sind z.B. in [Jennings et al. 1998b] [Gilbert 1997], oder [Caglayan 1998] zu finden. Bei Nwana finden folgende Dimensionen Verwendung: Seite 22 Mobilität: Agenten können anhand der Fähigkeit eingestuft werden, ob sie sich in Netzwerken bewegen können. Daraus lassen sich statische und mobile Agenten ableiten. Reaktivität / Deliberativität: Erfolgt das Handeln basierend auf eine interne symbolische Darstellung der Welt, so wird von einem deliberativen Agenten gesprochen. Werden Aktionen direkt durch aktuelle Informationen der Sensordaten ausgelöst, so verhält sich der Agent reaktiv. Primäre Attribute: Klassifizierung anhand primärer Eigenschaften. Diese sind zumindest Kooperation, Lernfähigkeit und Autonomie. Diese Eigenschaften können durchaus unterschiedlich ausgeprägt sein, je nach Aufgabe des Agenten. Kooperative, lernfähige Agenten brauchen natürlich die ersten beiden Eigenschaften. InterfaceAgenten sollten vor allem lernfähig (adaptiv) und autonom sein. Damit ein Agent wirklich smart ist, sollte er alle drei Eigenschaften kombinieren. Abbildung 2.2 veranschaulicht diesen Sachverhalt. Rollen: Agenten werden nach ihrer Rolle klassifiziert. Zum Beispiel Informationsoder Internetagenten, die das Internet nach Informationen durchsuchen. Hybride Agenten: Diese Agenten kombinieren verschiedene Ansätze. Abbildung 2.2: Typologie nach Nwana [Nwana 1996] Die Kombinationen oben genannter Dimensionen lässt eine riesige Anzahl von Agententypen zu. So kann es zum Beispiel stationäre deliberative Interfaceagenten geben, aber auch mobile deliberative Informationsagenten. Um die Übersicht zu behalten, reduziert Nwana all diese möglichen Typen zu einer Liste aus folgenden Typen, die die meisten gängigen existierenden Agententypen abdecken. Die folgenden Betrachtungen beziehen sich im Wesentlichen auf [Nwana 1996]. Kollaborative Agenten Wie aus Abbildung 2.2 ersichtlich ist, sind die zentralen Eigenschaften dieser Agenten Autonomie und Kooperation. Zum Erreichen ihrer Ziele kooperieren Kollaborative Agenten typischerweise mit anderen Agenten, dazu müssen sie unter Umständen auch in der Lage sein zu verhandeln. Kooperatives Verhalten kann nur erreicht werden, wenn ein Agent auch proaktiv handelt. Die Fähigkeit zu lernen, ist keine notwendige Eigenschaft Seite 23 Kapitel 2 Einführung in den Themenbereich dieser Agenten und zumeist sind diese Agenten statisch. Der Einsatz von kollaborativen Agenten ist für folgende Probleme und Aufgabenstellungen sinnvoll: Bei Problemen die für einen einzelnen zentralen Agenten zu umfangreich in Bezug auf die benötigten Ressourcen sind, oder bei sensiblen Problemen für die die ein zentralistischer Ansatz zu riskant ist. Für Problemstellungen die eine Zusammenführung von mehreren bereits bestehenden Programmen (z.B. Expertensysteme) fordern. Wenn eine Lösung für ein von Natur aus verteiltes Problem gesucht wird (z.B. Flugüberwachung). Für Aufgaben die im Bereich verteilter Information (z.B. verteilte Online-Quellen), oder verteilter Kompetenz (z.B. Gesundheitsversorgung) entstehen. Für Problemstellungen bei denen ein hohes Maß an Modularität, Geschwindigkeit, Zuverlässigkeit, Flexibilität und Widerverwendbarkeit gefordert wird. Interfaceagenten Bei Interface Agenten stehen die Eigenschaften Autonomie und Lernfähigkeit (siehe Abbildung 2.2) im Vordergrund. Im Gegensatz zu den zuvor besprochenen Kollaborativen Agenten kooperieren Interface Agenten typischerweise nur mit dem Benutzer (über das Interface) und wirken auch in der gleichen Umgebung wie sein Benutzer. Die Kooperation mit anderen Agenten findet, wenn überhaupt, auf sehr einfache Weise statt. Sehr häufig wird im Zusammenhang mit Interface Agenten von „Persönlichen Assistenten“ gesprochen, die dem Benutzer beim Umgang mit komplexen Anwendungen, wie z.B. Betriebssystemen oder Textverarbeitungsprogrammen, behilflich sind. Die Funktionsweise eines Interface Agenten ist in Abbildung 2.3 schematisch dargestellt. Abbildung 2.3: Die Funktionsweise von Interfaceagenten aus [Maes 1994] Der Interfaceagent beobachtet und überwacht die Aktionen des Benutzers im Interface. Aus diesen Beobachtungen lernt der Agent Aktionsfolgen, die der Benutzer im Umgang mit der Applikation durchführt. Möglicherweise kann er daraus neue Aktionsfolgen ableiten die schneller zum gleichen Ergebnis führen. Erkennt der Agent die Absicht des Benutzers, so schlägt er diesem seine erlernte Lösungsvariante gegebenenfalls vor, und kann auf diese Weise hilfreich sein. Der Benutzer muss aber immer die die Möglichkeit haben, direkt mit der Applikation zu kommunizieren, d.h. der Agent befindet sich nicht zwischen Applikation und Benutzter, sondern arbeitet parallel Seite 24 zum Benutzer. Die verschiedenen Möglichkeiten des Interfaceagenten an lernrelevante Information zu gelangen werden in Abbildung 2.3 durch ausgegraute Pfeile symbolisiert und können wie folgt beschrieben werden: Der Interface Agent beobachtet und imitiert den Benutzer. Der Interface Agent erhält positives oder negatives Feedback vom Benutzer. Der Interface Agent erhält explizite Anweisungen vom Benutzer. Der Interface Agent bittet andere Agenten um Hilfestellung. Dabei umspannen die eingesetzten Lerntechniken einen großen Bereich des maschinellen Lernens, vom Speicherbasierten Lernen23 bis hin zu evolutionären Lernalgorithmen. Damit sich der Einsatz von Lernalgorithmen überhaupt lohnt, müssen aber bestimmte Vorraussetzungen beim Umgang des Benutzers mit der Applikation gegeben sein, wie bereits in Abschnitt 2.4 erwähnt wurde. Die Motivation die hinter dem Einsatz von Interfaceagenten steckt ist, den in Abschnitt 2.1 beschriebenen Wechsel vom Paradigma der „direkten Manipulation“ hin zum Paradigma der „indirekten Manipulation“ zu vollziehen. Mobile Agenten Diese bewegen sich selbstständig im Netzwerk und finden selbst Wege zum Ziel. So können solche Agenten z.B. Informationen nach den Vorgaben des Benutzers sammeln und nach definierter Zeit, oder Beendigung der Aufgabe zum Benutzer zurückkehren. Die Einsatzmöglichkeiten reichen von Flugreservierungen hin zu Netzwerkmanagement. Der Einsatz mobiler Agenten bietet bei bestimmten Anwendungsszenarien erhebliche Vorteile gegenüber statischen Agenten. Diese Vorteile sind aber meist nicht Funktionaler Natur, d.h. man kann diese Funktionalität auch ohne Mobilität erreichen. Informationsagenten Informationsagenten existieren wegen der Notwendigkeit nach Werkzeugen, die uns Helfen die rasant wachsende Informationsflut im Internet zu verwalten. Sie verwalten, sammeln und passen Informationen nach den Bedürfnissen des Benutzers an. Man kann argumentieren, dass auch andere Agententypen Informationsagenten sind. Diese Überschneidungen sind unvermeidbar, da Informationsagenten danach definiert sind was sie tun, Interface- oder kooperierende Agenten danach eingeordnet sind was sie sind. Speziell mit diesen Agenten befasst sich das folgende Kapitel 3. Reaktive Agenten Eine weitere Klasse von Agenten sind reaktive Agenten. Solche Agenten verfügen nicht über eine interne, symbolische Beschreibung ihrer Umgebung, stattdessen reagieren sie nach stimulus-respone Manier direkt auf dem Zustand der Umgebung, in der sie sich befinden. Sie sind relativ einfach und interagieren mit anderen Agenten auf primitive Weise. Dennoch ermöglichen sie recht komplexe Verhaltenstrukturen, wenn das Verhalten aller Agenten global betrachtet wird. Ein Einsatzgebiet ist bei Simulationsprogrammen mit Echtzeit-Abläufen zu sehen. 23 memory-based learning Seite 25 Kapitel 2 Einführung in den Themenbereich Hybride Agenten Von einem hybriden Agenten wird gesprochen, wenn ein Agent in mindestens zwei der obigen fünf Klassen entspricht. Heterogene Agenten Die Klasse der heterogenen Agenten ist eine Erweiterung der kooperierenden Agenten. Heterogene Agenten können mit verschiedenartigen Agenten zusammenarbeiten und ermöglichen Wiederverwendung und Einbindung existierender Agenten. Smarte Agenten Aus Abbildung 2.2 wird deutlich, dass ein Smart Agent in Vereinigung aller primären Attribute autonom, kooperativ und lernfähig ist. 2.8 Zusammenfassung Der Begriff des Agenten im Bereich der Softwareentwicklung ist nun schon seit geraumer Zeit sehr populär. Es gibt jedoch bis heute kein allgemein einheitliches Verständnis dieses Begriffs. In unterschiedlichen Fachgebieten werden zum Teil stark abweichende Definitionen verwendet. Beispielsweise wird in [Dragon 1997] der Begriff Agent folgendermaßen definiert: „Ein Agent ist ein Stück Software, dass etwas für dich erledigt.“, in einer Auslegung von Wooldrige und Jennings [Wooldridge et al. 1995] spielen menschenähnliche Merkmale wie Wissen, Glauben, Intention oder Verpflichtung eine große Rolle. Die Ursache dafür ist einerseits der stark interdisziplinäre Charakter der Agententechnologie, der sich über die Forschungsgebiete Künstliche Intelligenz, Verteilte Künstliche Intelligenz, Entscheidungstheorie, Netzwerk- und Kommunikationssysteme, Psychologie und viele andere erstreckt, andererseits wird auch durch die weitreichenden Einsatzgebiete von Agenten, eine einheitliche Sichtweise erschwert. Die Anwendungsbereiche reichen dabei von einfachen personalisierten Emailfiltern, Informationsmanagement, Workflowmanagement oder Netzwerkmanagement bis hin zu großen, komplexen aber auch ein hohes Maß an Verantwortung tragenden Systemen, wie zum Beispiel im Bereich der Flugverkehrskontrolle und Patientenüberwachung. Nach Ansicht des Autors der vorliegenden Arbeit besteht eine alternative Möglichkeit sich dem Begriff des Agenten zu nähern durch die Betrachtung von Eigenschaften. In Abschnitt 2.4 wurden vielschichtige Eigenschaften behandelt, die man sich von einem Agenten erwarten könnte. Dazu gehören Beispielsweise die Autonomie, welche vom Agenten selbstständiges Handeln abverlangt oder die Mobilität, die den Agenten in die Lage versetzt über das Netzwerk seinen Ausführungsort zu wechseln. Diese Betrachtungen führten schließlich zum Ergebnis, dass ein Agent zumindest über folgende vier Eigenschaften verfügen muss- Autonomie, Proaktivität, Reaktivität und Kommunikationsfähigkeit. Damit kann Agentensoftware von herkömmlicher Software wie z.B. Expertensystemen, Verteilten Systemen oder klassischen Objektorientierten Systemen unterschieden werden. Als Beispiel wurden in Abschnitt 2.5 die Unterschiede zwischen Agenten und klassischen Objekten ausführlich dargestellt. In der Literatur werden Agentenbasierte Systeme gern mit dem Attribut Intelligenz versehen. Mangels einer allgemeingültigen Definition für den Begriff Intelligenz Seite 26 verstecken sich verschiedene Sichtweisen hinter dieser Eigenschaft. Der Autor dieser Arbeit vertritt die Meinung, dass intelligentes Verhalten von Agenten erst aus der Zusammenarbeit vieler, jeder für sich, eher „dummer“ Agenten entsteht. Diese Meinung wurde in Abschnitt 2.6 durch ein einfaches Beispiel belegt. Eine gibt viele Möglichkeiten eine Klassifikation von Agenten zu treffen. In dieser Arbeit wurde die Typologie nach [Nwana 1996] verwendet, die Agenten in 8 verschieden Typen unterteilt, Kollaborative Agenten, Interfaceagenten, Mobile Agenten, Informationsagenten, Reaktive Agenten, Hybride Agenten, Heterogene Agenten und Smarte Agenten. In der vorliegenden Arbeit sind Informationsagenten von besonderem Interesse, auf die nun im Folgenden Kapitel 3 näher eingegangen wird. Seite 27 Kapitel 3 Informationsagenten im Web Kapitel 3 3 Informationsagenten im Web „We are drowning in information but starved of knowledge” (John Naisbitt, Megatrends). Nach der allgemeinen Behandlung der Agententechnologie in Kapitel 2 wird in diesem Kapitel zunächst die Problematik des Suchens nach Information im Web behandelt. Im Anschluss daran wird in diesem Zusammenhang der Einsatz von so genannten Informationsagenten näher Betrachtet. 3.1 Allgemeines Mit dem World-Wide-Web (WWW oder Web) als Vereinigung vieler Dienste innerhalb des Internet hat sich ein völlig neuer Informationsraum gigantischen Ausmaßes ergeben. Das Fehlen zentraler Kontrollmechanismen hat zu vielen interessanten neuen Möglichkeiten aber gleichzeitig auch zu ebenso vielen Problemen geführt. Denn durch das rapide Wachstum des WWW und der damit zunehmenden Informationsfülle ist es für den Benutzer nicht nur unmöglich geworden, für ihn relevante Information zu sichten, sondern es besteht auch die Gefahr, in einer Unmenge irrelevanter Information zu versinken und das eigentliche Ziel der Informationssuche aus den Augen zu verlieren. Dies geht einher mit einem massiven Zeitverlust für das Auswerten letztlich wertlosen Materials, wodurch die Nützlichkeit des WWW für den Anwender und damit auch dessen Produktivität gesenkt wird. Die Unterstützung der Nutzer bei der gezielten Suche, Filterung und Klassifikation der Informationsangebote in dem weitgehend unstrukturierten und dynamischen Informationsmarkt des WWW wird zunehmend ein Schlüsselfaktor für ein erfolgreiches und effizientes Informationsmanagement. Klassische „keyword search“ basierte Suchdienste wie zum Beispiel Webverzeichnisse, Spiderbasierte Suchdienste und Metasuchmaschinen, können eine wichtige Hilfestellung für die Informationserschließung im WWW leisten [Teuteberg 1999]. Doch selbst mit Hilfe dieser Dienste, die Informationen nach Themenbereichen und Schlüsselwörtern gruppieren, ist die Informationsfindung immer noch eine Suche „auf gut Glück“24 Aufgrund der exponentiell anwachsenden Informationsmenge ist abzusehen, dass diese Problematik des „Information Overload“ in Zukunft noch stärker in Erscheinung treten wird. Um dieser Entwicklung entgegenzuwirken wird seit geraumer Zeit der Einsatz von so genannten Informationsagenten, die Informationen aus dem Internet nach den 24 Bezeichnend dafür ist der Suchbutton „Auf gut Glück“ im GOOGLE-Interface (http://www.google.at) Seite 28 Bedürfnissen des Benutzers suchen, finden und filtern, und dann in gewünschter Weise präsentieren, propagiert. [Teuteberg 1999]. 3.2 Grundlegende Struktur des Web Das Web besteht aus zahllosen, auf Rechnern der ganzen Welt gespeicherten multimedialen Dateien. Diese kombinieren Text mit Ton, Bild und Videosequenzen. Als Beschreibungssprache der Web-Seiten wurde ursprünglich HTML (HyperText Markup Language) definiert, welche nun aber allmählich von XML (Extended Meta Languge) abgelöst wird. Diese erlauben es Dokumente und multimediale Dateien mittels Hyperlinks beliebig zu verlinken, es ist dabei unerheblich, ob diese auf dem gleichen Server zur Verfügung stehen, oder sich auf einem entfernten Server befinden. Der Betrachter eines derartig verlinkten Dokuments hat die Möglichkeit, meist per Mausklick, diese Links zu verfolgen. Nichtlinearität und netzartige Strukturen sind die zentralen Eigenschaften solcher Hypertextsysteme. [Schneppe 2000] Bei der Verwendung von Hypertext können zwei grundsätzliche Probleme auftreten, die miteinander in Beziehung stehen. Zum einen die Orientierungsproblematik des Benutzers als Folge der nicht-linearen Darstellungsweise der Information („lost in Hyperspace“), zum anderen die Anforderung an den Benutzer, neben der Informationsaufnahme jeweils auch Navigationsentscheide für das weitere Vorgehen zu treffen. Um dem Benutzer die Navigation zu erleichtern können unterschiedliche Navigationshilfen eingesetzt werden, wie zum Beispiel Inhaltsverzeichnisse, Glossare, graphische Übersichten, autorendefinierte Wegweiser (der Autor stellt dem Benutzer einen Weg durch den Hypertext bereit), rückwärtsgerichtete Navigationshilfen (HistoryFunktion), Markierung gelesener Bereiche und selbstdefinierte Fixpunkte des Lesers in Form von Bookmarklisten. [Schneppe 2000] Im Internet ist dieses Hypertextprinzip im Web wieder zu finden, so dass oben genannte Probleme in vollem Umfang auch dort anwendbar sind [Schneppe 2000]. Aufgrund der gigantischen Ausmaße des Web sind diese Probleme jedoch mit den oben beschriebenen Navigationshilfen allein nicht mehr zu Lösen. Um im Web relevante Information zu finden ist die Verwendung von so genannten Suchdiensten derzeit unumgänglich. In folgendem Unterkapitel werden diese kurz behandelt. 3.3 Suchdienste Mittlerweile existiert eine unüberschaubare Menge an verschiedenen Suchdiensten im Web. Dies geht bereits soweit, dass eigene Suchdienste zum Auffinden von Suchdiensten existieren. Zum Zeitpunkt dieser Recherche (25.11.2004) etwa sind allein im Suchlexikon25 2559 spezielle deutschsprachige und länderspezifische Suchdienste verzeichnet. In diesem Abschnitt werden die drei klassischen Kategorien von 25 http://www.suchlexikon.de Seite 29 Kapitel 3 Informationsagenten im Web Suchdiensten , Webkataloge26, Spider-basierte Suchdienste (Suchmaschinen) und Metasuchmaschinen, allgemein beschrieben und deren Vorteile einander gegenübergestellt. Anschließend werden die Problembereiche dieser Dienste und Schwierigkeiten der Benutzer bei der Verwendung solcher Suchdienste identifiziert. 3.3.1 Webkataloge Hauptmerkmal von Webkatalogen ist die Organisation der Dokumente in hierarchischen Strukturen. Meist sind diese nach Inhalten sortiert, es gibt aber auch geographische, chronologische („What’s new“) oder nach Dokumenttypen geordnete Aufteilungen. Die Hierarchie wird nicht automatisch, sondern von Redakteuren erzeugt. Die Dienstanbieter bieten Verfassern die Möglichkeit ihre Seite zur Durchsicht anzumelden. Redakteure führen dann eine Bewertung durch (arbeitsaufwendig und zeitintensiv) und entscheiden ob eine Aufnahme in den Katalog erfolgt. Wenn ja, werden die Dokumente um Schlagworte und Zusammenfassungen ergänzt und in die vorhandene Hierarchie eingeordnet. Es gibt Webkataloge, die die Einordnung der Dokumente in die vorhandenen Verzeichnisstrukturen den Autoren selbst ermöglichen, verbunden mit dem Problem der einheitlichen Anwendung der Katalogisierung. [Schneppe 2000] Für den thematischen Überblick und Einstieg ist ein Webkatalog (gegenüber der Spider-basierten Suchdiensten) zu bevorzugen. Ausgangspunkt für den suchenden Anwender ist das interessierende Themengebiet. Nach Auswahl einer passenden und meist grob umfassenden Kategorie wird der Zielbereich anhand von Subkategorien schrittweise ausgewählt, d.h. in die Hierarchie wird schrittweise bis zur Dokumentenebene hineinnavigiert. Ergänzend bieten die Webkataloge häufig eine Schlagwortsuche in den redaktionell erstellten Dokumentbeschreibungen an. [Schneppe 2000] Vorteile von Webkatalogen Webkataloge bieten qualitativ hochwertige Dokumente an, die durch Stichwörter und eine kurze Zusammenfassung ergänzt werden 3.3.2 Spider-basiert Suchdienste Bei Spider-basierten Suchdiensten handelt es sich um umfangreiche, automatisiert erstellte invertierte Datenbanken mit Referenzen zu Millionen von Web-Seiten. Im Gegensatz zu Webkatalogen wird auf den Einsatz von Redakteuren zur qualitativen Einschätzung der Dokumente verzichtet, diese Aufgabe wird von Informationssammlern (oft Robot, Spider, Crawler genannt) und dem Indexer erledigt. Bei der Suche nach einzelnen oder mit logischen Operatoren verknüpften Suchwörtern (Stichworte, Schlagworte) wird der Index durchsucht und als Ergebnis eine Menge von, mittels eines Rankingalgorithmus bewerteten, Referenzen zurückgeliefert. Für die Relevanzbeurteilung und die damit verbundene Sortierung der Treffermenge werden fast nur statistische Methoden verwendet: [Schneppe 2000] 26 In der Literatur werden dafür auch die Bezeichnungen Webverzeichnis, Verzeichnisdienst, Internetkatalog oder Browsingdienst bzw. englisch „Web Directory“ verwendet. Seite 30 Die Anzahl gefundener Suchbegriffe in einem Dokument. Dabei wird die Gesamtanzahl aller Suchbegriffe gemessen. Dokumente, die alle Suchbegriffe beinhalten, werden als „besser“ bewertet. Die Gesamthäufigkeit eines Suchwortes bzw. Gesamtanzahl eines Suchbegriffs in allen Dokumenten. Die Funktion (Position) der gefundenen Begriffe. Zum Beispiel werden Begriffe aus der URL und dem Titel stärker gewichtet. Die Häufigkeit eines Suchwortes innerhalb eines Dokuments Die Nähe von Suchbegriffen innerhalb des Textes Eine weitere Möglichkeit der Relevanzbeurteilung ist die Bestimmung der Popularität eines Dokuments. Dabei wird die Popularität entweder aufgrund der Trefferhäufigkeit in vorangegangenen Suchergebnissen ermittelt, oder anhand einer Linkanalyse, d.h. der Anzahl an Verweisen von anderen Dokumenten auf dieses Dokument. [Schneppe 2000] Die meisten Spider-basierten Suchdienste bieten eine einfache und eine erweiterte Suchschnittstelle an. Neben der Eingabe von Suchbegriffen bietet die einfache Suche eine begrenzte Anzahl von Standardoperationen wie +String (Suchbegriff muss im Dokument enthalten sein), -String (Suchstring darf nicht enthalten sein), und „…“ (Phrasensuche). Bei der erweiterten Suche können boolesche Operatoren (AND, OR, NOT) zur Definition komplexerer Suchanfragen verwendet werden. Häufig wird auch die Verwendung von Wildcards innerhalb der Suchbegriffe unterstützt. [Schneppe 2000]. Eine Suchraumeingrenzung auf bestimmte Strukturelemente (z.B. Title, Author, Links), geographische Regionen, Sprachen oder Domänen wird ebenfalls häufig angeboten. [Schneppe 2000] Vorteile von Spider-basierten Suchdiensten Spider-basierte Suchdienste bieten einen höheren Abdeckungsgrad als Webkataloge aufgrund der großen Anzahl erfasster Dokumente Spider-basierte Suchdienste weisen eine relativ hohe Aktualität der erfassten Ressourcen auf, weil in periodischen Abständen der Index automatisch erneuert (reindexiert) wird. Spider-basierte Suchdienste stellen dem Benutzer umfangreiche Suchoptionen zur Verfügung 3.3.3 Metasuchmaschinen Metasuchmaschinen besitzen keine eigene Indexdatenbank, sondern greifen bei einer Anfrage auf mehrere Suchmaschinen zurück (zum Teil auch auf Webkataloge). Damit bieten sie ihren Nutzern eine Erweiterung des Suchraums (höhere Abdeckung) und damit auch eine eventuelle, nicht nur quantitative, Verbesserung der Ergebnisse (hit rate). Der Zugriff auf die Spider-basierten Suchdienste erfolgt dabei meist parallel. Die Zusammenführung der einzelnen Suchergebnismengen erfordert die Entfernung von Dubletten und erfolgt mitunter mit einem gemeinsamen Ranking. [Schneppe 2000] Metasuchmaschinen eignen sich besonders für eine Suche nach seltenen und Seite 31 Kapitel 3 Informationsagenten im Web speziellen Begriffen. [Schneppe 2000] Vorteile von Metasuchmaschinen Metasuchmaschinen bieten eine theoretisch hohe Abdeckung im Vergleich zu den größten Suchmaschinen Metasuchmaschinen ermöglichen eine gleichzeitige Befragung diverser verschiedenartiger Suchdienste Metasuchmaschinen bieten einen aktuellen Zugriff auf neue oder unbekannte Suchdienste Metasuchmaschinen stellen dem Benutzer ein einheitliches Suchformular für verschiedene Suchdienste zur Verfügung 3.4 Problembereiche der Suchdienste Den oben erwähnten Vorteilen der einzelnen Suchdienste steht eine Reihe von Nachteilen gegenüber, die oftmals gerade aus den vermeintlichen Vorteilen resultieren. In diesem Unterkapitel werden die Probleme von Suchdiensten kurz behandelt, wobei die Betrachtungen vorwiegend aus [Schneppe 2000] entnommen sind. Probleme von Webkatalogen Webkataloge verfügen über eine geringe Aktualität und Abdeckung der Dokumente. Angesichts des exponentiellen Wachstums des Informationsraumes Web kann eine manuelle Bewertung unmöglich schritt halten, daher bieten Webkataloge zwar hochwertige Inhalte, doch geht dies auf Kosten der Aktualität und Abdeckung. Bei Webkatalogen tritt das Problem der unterschiedlichen Organisation nach Themenbereichen auf. Für die Organisation nach Themenbereichen bieten sich unterschiedliche fachbezogene hierarchische Klassifikationssysteme an. Zum Beispiel gibt es für die Einteilung nach Branchen das North American Industry Classification System (NAICS) oder im Fachbereich Informatik das ACM Computing Classification System, eine weitere sehr bewährte Klassifikationsmöglichkeit ist die Dewey Decimal Classification (DDC) [Jenkins et. al. 2000] oder Dublin Core (DC) [DC 1998]. Viele Webkataloge verwenden jedoch eigens entwickelte Themenhierarchien. Bei Webkatalogen fehlen ausgeprägte, erweiterte Suchmöglichkeiten Probleme von Spider-basierten Suchdiensten Bei Spider-basierten Suchdiensten stellt sich das Problem der Stichwortsuche. Bei der automatischen Indexierung können semantische Informationen verloren gehen, da ein Dokument auf eine Menge von „unabhängigen“ Wörtern reduziert wird. Spider-basierte Suchdienste verwenden eine sehr unterschiedliche Suchsyntax Der Umfang der Suchergebnismenge ist bei allgemeinen Suchanfragen nicht mehr „handhabbar“ Seite 32 Große Bereiche des Webs können von Spider-basierten Suchdiensten nicht erreicht werden. Dazu zählen unter Anderem: Nicht-verlinkte Dokumente: Dokumente, auf die kein Link verweist und die auch nicht bei den Spider-basierten Suchdiensten eingetragen werden. Geschützte Dokumente: Dokumente, die durch Passwort, Registrierung oder Firewall geschützt sind. Dynamische Dokumente: Dokumente, die über Formulare usw. dynamisch generiert werden (CGI / Datenbanken). »robots.txt« Die meisten Spider-basierten Suchdienste halten sich an den RoboterExclusion-Standard E-Mail: E-Mail-Adressen können nicht automatisch akquiriert werden Dateien (Außerhalb des WWW-Server-Bereiches): Dateien, die über WWW-Browser mit »file:« erreichbar sind, können von den Spider-basierten Suchdiensten nicht erreicht werden. Probleme von Metasuchmaschinen Bei Metasuchmaschinen sind keine ausgeprägten, erweiterten Suchmöglichkeiten der beteiligten Spider-basierten Suchdienste einsetzbar, da diese sich in der Syntax oft sehr unterscheiden (komplexe Anfragen mit booleschen Operatoren oder einer Feldsuche sind meist nur direkt bei den Spider-basierten Suchdiensten möglich) Die unterschiedlichen Rankingkriterien der verwendeten Spider-basierten Suchdienste erlauben kein „korrektes“ Sortieren der Gesamttreffermenge. Meist erfolgt eine Begrenzung der Suchergebnismenge (es werden oft nur die ersten 10, 20 oder 30 Treffer je Spider-basierten Suchdienst angezeigt) Metasuchmaschinen weisen meist Performanceprobleme auf, da das vollständige Suchergebnis erst vorliegt, wenn auch die langsamste der befragten Spider-basierten Suchdienste ein Suchergebnis liefert 3.5 Problembereiche bei der Wissensauffindung im Web Die Suche nach Information stellt an den Benutzer besondere Anforderungen. Durch mehrere Untersuchungen ist belegt, dass die Suche ein hochkomplexer Prozess ist, bei dem sich der Benutzer einer Vielzahl von Problemen stellen muss. Die Komplexität einer Suche wird z.B. stark durch das unterschiedlich ausgeprägte Domain Wissen bzw. der unterschiedlichen Erfahrung der Benutzer beeinflusst. [Guetl 2004] Abhängig von diesem Wissen fällt es einem Benutzer mehr oder weniger schwer folgende Anforderungen, die sich innerhalb des Suchprozesses (siehe Abbildung 3.1) ergeben, zu erfüllen: [Branjik 1999] Seite 33 Kapitel 3 Informationsagenten im Web Der Benutzer muss geeignete Informationsquellen identifizieren, die den Informationsbedarf abdecken können Der Benutzer muss geeignete Suchanfragen Formulieren, die den Informationsbedarf beschreiben Der Benutzer muss brauchbare Dokumente aus einer Resultatliste von unbrauchbaren unterscheiden Der Benutzer muss Information aus gefundenen Dokumenten extrahieren, um zum Beispiel weitere Verbesserungen an seiner Suche vorzunehmen Der Benutzer muss gegebenenfalls Suchanfragen verändern und verbessern, wenn die vorangegangene Anfrage nicht zum Gewünschten Erfolg führte Wenn es die Informationsquelle unterstützt sollte der Benutzer in der Lage sein, gutes Relevance-Feedback zu geben und das von anderen für sich selbst zu nutzen Abbildung 3.1: Einfaches Information Access Modell; aus [Guetl 2004] nach [Baeza et al. 1999] Zudem treten drei weitere fundamentale Probleme bei der Informationssuche auf: [Branjik 1999] Das Problem des „Anomalous State of Knowledge“ d.h. ein Benutzer kann sein Informationsproblem nicht genau artikulieren, da ihm die genauen Kenntnisse zum Problem fehlen. Die fehlende Terminologie verursacht dann auch das Unvermögen, sein Bedürfnis einem Informationsvermittlungssystem mitteilen zu können. Das Vocabulary Problem besagt, dass eine Divergenz zwischen dem verwendeten Vokabular des Benutzers und dem derer Personen existiert, welche die gesuchten Dokumente katalogisiert haben. Letztgenannte Personen können dabei zum Beispiel die Autoren selbst sein oder Bibliothekare, die die Dokumente klassifizieren und Schlagworte auswählen. Die Bestimmung der Relevanz von gefundenen Dokumenten zum jeweiligen Zeitpunkt der Suche. Guetl weist in [Guetl 2004] darauf hin dass in der Praxis das Verhalten der Benutzer im Umgang mit Search-based Information Retrieval (IR) Systemen vom einfachen Seite 34 Modell nach Abbildung 3.1 in mehreren Punkten abweicht: Die Benutzer nehmen im Rahmen des Suchprozesses Domain Wissen auf Die Suchstrategien und das Informationsbedürfnis ändern sich im Suchprozess Vorübergehend werden andere Informationsbedürfnisse verfolgt Ein Informationsbedürfnis kann nicht durch einen einzigen Suchprozess befriedigt werden; erst die Kombination aus mehreren verschiedenen Suchprozessen liefert das gewünschte Ergebnis. Insbesondere bei fehlendem oder geringem Domainwissen ist eine (erste) Erschließung von Informationen und Inhalten durch Browsing-based IR Funktionskomponenten (z.B. Webkataloge) zielführender. [Guetl 2004] Bates hat 1990 eine Studie [Bates 1994] vorgelegt, in der Suchaktivitäten professioneller Rechercheure und Bibliothekare untersucht werden. Suchaktivitäten lassen sich danach in vier Abstraktionsebenen kategorisieren: [Bates 1994] Elementare Aktionen: Als Elementare Aktionen werden identifizierbare Gedanken oder Aktionen bezeichnet, die Teil einer Informationssuche sind. Sie entsprechen typischerweise den Kommandos, die von einem Retrieval-System zur Verfügung gestellt werden, also z. B. das Hinzufügen eines Terms oder einer Bedingung zu einer Anfrage oder das Verfolgen eines Verweises. Taktiken: Taktiken umfassen mehrere elementare Aktionen, die eine Suche beschleunigen und das Suchergebnis verbessern. Dazu gehört z. B. das Verfeinern von Anfragen wie die Generalisierung von Suchbegriffen, um den Recall zu erhöhen, oder etwa das Spezialisieren von Suchbegriffen, um die Precision zu erhöhen. Strategeme: Strategeme setzen sich meist aus mehreren Taktiken zusammen, um Informationsstrukturen in einer Suchdomäne auszunutzen. Dazu gehören z. B. der Journal-Run (Navigation in den Ausgaben einer Zeitschrift, die als zentral für ein gegebenes Informationsbedürfnis identifiziert wurde), die Footnote-Chase, bei der die Referenzen in einem relevanten Dokument verfolgt werden, oder die Autorensuche mit dem Ziel, weitere Dokumente eines Autors zu finden, der bereits in einem oder mehreren relevanten Dokumenten aufgetaucht ist. Strategien: Strategien sind Pläne, die Aktionen, Taktiken und Strategeme beinhalten, um eine Informationssuche vollständig durchzuführen und somit ein gegebenes Informationsbedürfnis komplett abzudecken. Eine einfache Strategie zur Literaturrecherche über ein neues Gebiet wäre etwa eine Themenorientierte Suche im ersten Schritt, wonach man mit den in den relevanten Dokumenten gefundenen Autorennamen eine Autorensuche anschließt. Bates stellte fest, dass sich Retrievalsysteme meist nur auf der Ebene der elementaren Aktionen bewegen. Zu einem Ähnlichen Ergebnis kommt eine Studie in [Choo et al. 2000], die das Verhaltensmuster bei der Informationssuche in Unternehmen untersucht. Nach [Guetl 2004] werden dort je nach Informationsbedürfnis und Problemstellung vier unterschiedliche Zielsetzungen bei der Informationssuche identifiziert: Seite 35 Kapitel 3 Informationsagenten im Web Undirected Viewing: Die Benutzer sind ohne bestimmtes Informationsbedürfnis Informationsreizen ausgesetzt. Das Ziel ist es, Informationen breit gefächert zu sichten, um möglichst früh Entwicklungen zu erkennen. Hierbei werden möglichst viele und unterschiedliche Quellen benutzt, die Granularität der Information ist dabei jedoch sehr grob. Conditioned Viewing: Hierbei ist das Interesse ganz gezielt auf Informationen zu ganz bestimmten Themen gerichtet. Die Benutzer können vorerst durch Undirected Viewing auf die Themen sensibilisiert worden sein. Ziel dieser Stufe ist es, Bedeutung und Auswirkungen auf das Unternehmen zu evaluieren und zu verfolgen. Informal Search: Bei diesem Suchprozess handelt es sich um eine thematisch begrenzte, jedoch unstrukturierte Aktivität, die die aktive Suche eines Benutzer, nach Informationen, beschreibt. Ziel ist es dabei, notwendigen Handlungsbedarf zu identifizieren. Formal Search: Dieser Prozess ist durch überlegte und geplante Aktivitäten gekennzeichnet und soll ganz spezifische Informationen zum Ergebnis haben. Dieser Suchprozess kann als formal bezeichnet werden, da hierbei voreingerichtete Prozeduren und bekannte Methoden verwendet werden. Die Granularität der Information ist sehr fein, die Suche ist stark auf Detailinformationen fokussiert. Das Ziel dieser Prozessstufe ist es, systematisch Informationen aufzufinden, die als Grundlage zur Entscheidungsfindung dienen oder Basis für Handlungen sind. Nach Guetl [Guetl 2004] lassen sich die Zielsetzungen durch Kombination von mehreren IR Tasks umsetzen:] Starting: Diese Kategorie umfasst alle Aktivitäten, die den Startpunkt der Suche nach Informationen darstellen. Startpunkte oder Initialquellen verweisen meist auf andere Quellen oder schlagen andere Referenzen vor. Chaining: Chaining beschreibt das Verfolgen von Hinweisen von Initialquellen (Startpunkte der Recherche), genauer wird dies als Backward Chaining bezeichnet. Umgekehrt führt Forward Chaining von anderen Quellen zu Initialquellen. Browsing: Sind Quellen bzw. Dokumente identifiziert, so werden diese durch eine semi-gerichtete Suche - dem Browsing - näher untersucht. In vielen Fällen bedeutet dies, dass Benutzer unter anderem die Inhaltsverzeichnisse, Autoren oder Institutionen aber auch Kurzfassungen prüfen. Differentiating: Diese Stufe beschreibt den Auswahlprozess der Quellen unter Berücksichtigung von Art und Qualität der Informationsquellen bzw. Informationen. Monitoring: Monitoring beschreibt jene Aktivitäten, mit denen man bei Entwicklungen auf einem bestimmten Gebiet auf dem Laufenden bleiben kann. Extracting: Extracting ist der systematische Prozess, mit welchem man gezielt Informationen von einer oder mehreren Quellen aufzufinden vermag. Die Zuordnung der hauptsächlich genutzten Tasks zu den verschiedenen Zielsetzungen zeigt Abbildung 3.2. Seite 36 Abbildung 3.2: Visualisierung der Verhaltensmuster bei der Informationssuche in Unternehmen nach [Choo et al. 2000], aus [Guetl 2004] Nach einer Studie der Bertelsmann Stiftung die in [Machill et al. 2004] veröffentlicht wurde setzen Benutzer im Umgang mit Search-based Information Retrieval (IR) Systemen. nur relativ wenige kognitive Ressourcen ein und probieren oft aus. Von den mächtigen Möglichkeiten der meisten Suchmaschinen verwenden sie nur einen Bruchteil; stattdessen beschränken sie sich auf einfache Suchanfragen in der Hoffnung, in der Trefferliste etwas Passendes zu finden. Die Suchmaschinen sind auf dieses Nutzerverhalten insgesamt gesehen nicht gut vorbereitet. Sie antizipieren zu wenig, wie Nutzer ihre Informationswünsche realisieren und orientieren sich zu stark an starren Suchalgorithmen. Weitere Problembereiche sind: [Machill et al. 2004] Die Suchergebnisse erfüllen oftmals nicht die Sucherwartungen ihrer Nutzer. Solchen ‚invaliden Treffern’ liegen – neben einer unausgereiften Technik – oft externe oder interne Manipulationen zugrunde, hinter denen ökonomische Interessen stehen. Dienstleistungen für Website-Anbieter und bezahlte Suchresultate haben als Erlösquelle einen hohen Stellenwert für Suchmaschinen. Die Trennung zwischen neutral ausgewählten Seiten und bezahlten Links ist nicht befriedigend gelöst. Den Nutzern ist diese Praxis kaum vertraut. Das Zustandekommen der Suchergebnisse ist für Nutzer meist nicht nachvollziehbar: Wie die Einträge in der Suchmaschinendatenbank entstehen, welche Algorithmen verwendet werden, ob es die Möglichkeit bezahlter Einträge gibt usw., ist weithin unbekannt. Aus welchen unterschiedlichen Quellen gegenwärtige Suchdienste ihre Suchergebnisse beziehen ist in Abbildung 3.3 ersichtlich. Dies unterstreicht den zuvor erwähnten Sachverhalt. Seite 37 Kapitel 3 Informationsagenten im Web Abbildung 3.3: Beziehungsgeflecht der Suchdienste in Deutschland und International (Stand 10.06.2004) [Suchfibel 2004]27 Die Bertelsmannstudie kommt zum Ergebnis, dass Trotz erheblicher technischer und gestalterischer Verbesserungen Suchmaschinen immer noch alles andere als einfach zu benutzen sind (Nutzerfreundlichkeit). Auch wenn die Nutzung von Suchmaschinen relativ einfach erscheint, so gibt es doch einiges zu beachten, um erfolgreich zu suchen. [Machill et al. 2004] 3.6 Informationsagenten Nachdem in den vorangegangenen Abschnitten einige Problembereiche der Suchdienste und der nach Informationen suchenden Benutzer identifiziert wurden, wird in diesem Unterkapitel auf den Einsatz von Informationsagenten in diesem Bereich eingegangen. Dazu wird zunächst in Anlehnung an [Klusch 2001] eine Definition für den Begriff Informationsagent gegeben, die die allgemeine Definition aus Kapitel 2 um einige, für diese Agententypen spezifischen, Eigenschafen und Anforderungen ergänzen soll: 27 http://www.suchfibel.de/ Seite 38 „Ein Informationsagent ist ein Softwareagent, der zu einer oder mehreren, heterogenen und geographisch verteilten Informationsquellen Zugriff hat, und der proaktiv im Auftrag seiner Benutzer, oder anderer Agenten relevante Informationen erwirbt, vermittelt und pflegt. Es wird allgemein verlangt, dass solche Agenten eine oder mehrere der folgenden Anforderungen erfüllen: Erwerb und Management von Informationen: Der Agent ermöglicht transparenten Zugriff auf eine oder mehrere Informationsquellen. Weiters findet, extrahiert, analysiert und filtert er Informationen, beobachtet Quellen, und aktualisiert relevante Informationen für seine Benutzer, oder andere Agenten. Synthese und Präsentation von Informationen: Der Agent ist in der Lage heterogene Daten zu verschmelzen und vereinheitlichte, multidimensionale Ansichten, der für seine Benutzer relevanten Informationen, zu erzeugen. Intelligente, individuelle Benutzerassistenz: Der Agent kann sich dynamisch an Änderungen im Bereich der Benutzerpräferenzen, Informationen oder der Netzwerkumgebung anpassen. Er stellt intelligente, interaktive Assistenz für seine Benutzer bei seien Informationsbasierten Tätigkeiten im Internet bereit.“28 [Klusch 2001] Diese Eigenschaften unterscheiden Informationsagenten insbesondere von den herkömmlichen Suchdiensten im Web (siehe Abschnitt 3.3) und so genannten intelligenten Front-Ends von Datenbanken aus, die seit Mitte der 80er Jahre im kommerziellen Einsatz sind. [Klusch 2001] 3.7 Klassifikation von Informationsagenten In Kapitel 2 wurde bereits eine allgemeine Klassifikation von Agenten eingeführt, und darauf hingewiesen dass es in dieser zu Überschneidungen im Speziellen bei Informationsagenten kommt. Es wurde auch erwähnt, dass unterschiedliche Kriterien zur Kategorisierung herangezogen werden können. Für den folgenden Überblick wird eine Klassifikation nach [Klusch 2001] herangezogen, in der Informationsagenten nach folgenden Eigenschaften kategorisiert werden: kooperativ, adaptiv, mobil 28 We define an information agent as an autonomous, computational software entity (an intelligent agent) that has access to one or multiple, heterogeneous and geographically distributed information sources, and which pro-actively acquires, mediates, and maintains relevant information on behalf of users or other agents preferably just-in-time. Thus, an information agent is supposed to satisfy one or multiple of the following requirements. Information acquisition and management. It is capable of providing transparent access to one or many different information sources. Furthermore, it retrieves, extracts, analyzes, and filters data, monitors sources, and updates relevant information on behalf of its users or other agents. Information synthesis and presentation. The agent is able to fuse heterogeneous data and to provide unified, multi-dimensional views on relevant information to the user. Intelligent user assistance. The agent can dynamically adapt to changes in user preferences, the information, and network environment as well. It provides intelligent, interactive assistance for common users supporting their information-based business on the Internet. [Klusch 2001] Seite 39 Kapitel 3 Informationsagenten im Web Die folgenden Abschnitte behandeln jede dieser Kategorien von Informationsagenten. Es werden dabei kurz die relevanten, zugrunde liegenden Technologien und entsprechende Beispiele von Informationsagenten und Informationsagenten innerhalb von Multiagentensystemen gegeben. Die folgenden Ausführungen sind großteils aus [Klusch 2001] entnommen. 3.7.1 Kooperative Informationsagenten und Systeme Der Begriff eines kooperativen Informationsagenten wurde 1992 im Zusammenhang mit dem Paradigma kooperativer Informationssysteme eingeführt. Ausgangspunkt ist eine Menge von verschiedenen, autonomen Datenbanken, die untereinander vernetzt sind (siehe Abbildung 3.4). Jeder dieser Datenbanken ist ein Informationsagent zugeordnet, der sie nach außen gegen unberechtigte Zugriffe abschirmt und für seine Benutzer aktiv nach relevanten Informationen sucht. Dabei muss ein Agent eine Vielzahl von Problemen lösen, die durch die Verteilung und Autonomie der Datenbanksysteme sowie die Heterogenität der Daten in den Datenbanken entstehen. Es wird vorausgesetzt, dass er hierfür genügend Wissen sowie ausreichende Inferenz- und Kooperationsfähigkeiten besitzt. Prominente Beispiele für Architekturen und Systeme von kooperativen Informationsagenten sind RETSINA [Sycara et al. 1996] und InfoSleuth [Nodine et al. 1999]. Abbildung 3.4: Makrostruktur eines Systems von kooperativen Informationsagenten [Klusch 2001] 3.7.2 Adaptive Informationsagenten Ein adaptiver Informationsagent besitzt die Fähigkeit, sich selbständig auf stetige Veränderungen in offenen Umgebungen und Anforderungen in seinem Aufgabenbereich anzupassen. Das betrifft zum Beispiel wechselnde Präferenzen und Bewertungen der Relevanz von Informationen durch seine Benutzer, die dynamische Klassifikation von Seite 40 nicht statischen, vagen oder unsicheren Inhalten aus eventuell ortsveränderlichen Informationsquellen und flexible Anpassung an wechselhafte Verfügbarkeit von Resourcen im Netz, wie Bandbreite und Auslastungen von aktuell besuchten Servern. Durch den Einsatz von (semi-) automatischen Lernverfahren für Informationsagenten wird vor allem eine flexiblere und benutzerfreundlichere, wenn auch nicht immer schnellere Informationssuche erwartet. Es ist dabei generell zwischen dem Lernen eines einzelnen Agenten in einem Multiagentensystem und der Adaption eines Multiagentensystems als Ganzes zu unterscheiden. Anwendungen von adaptiven Informationsagenten umfassen insbesondere intelligente Benutzerschnittstellen für das Web wie z.B. Letizia [Liebermann 1997] (siehe. Abschnitt 3.8.1). 3.7.3 Mobile Informationsagenten Die Fähigkeit zur Mobilität wird von Informationsagenten nicht dringend gefordert, ist aber in Bezug auf ein orts- und zeitunabhängiges, intelligentes Informationsmanagement von hoher Attraktivität für den Benutzer. Ein weiterer, erwarteter Vorteil von mobilen Agenten ist eine unter bestimmten Bedingungen signifikant reduzierte Netzlast durch lokale Datenverarbeitung. Mobile Agenten folgen dem Paradigma des Remote Programming im Gegensatz zu dem des Remote Procedure/Function Call (RPC/RFC) der traditionellen Client-Server Systeme. Sie sind in der Lage unter gegebenen Umständen für die Ausführung ihrer Aufgaben auf mehrere, geographisch verteilte Server zu migrieren. Unterstützt wird die Verwendung solcher Agenten in geeigneten Softwareapplikationen auch durch die steigende Verbreitung von mobilen Telekommunikationsgeräten, die eine Verbindung zum Internet bieten (WAP-fähige Webhandies, Kommunikatoren und Palms), intelligentem Breitband und drahtlosen, Satellitengestützten Datennetzwerken. Des Weiteren werden die fortschreitende Verteilung von relevanten Daten und Informationen und die Anforderung, (eventuell a priori unbekannte) Server oder deren Proxies bei Bedarf dynamisch zu selektieren sowie auf mögliche Störungen von (Funk-) Netzwerverbindungen flexibel reagieren zu können, zum Einsatz von mobilen Agenten in der Zukunft führen. 3.7.4 Informationsagenten für den elektronischen Handel Elektronischer Handel (E-Commerce) kann definiert werden als die Menge aller Aktivitäten, die direkt den online Handel von Waren und Dienstleistungen im Internet betreffen; damit ist E-Commerce Teil des allgemeineren elektronischen Geschäftsverkehrs, des sog. E-Business. Je nach Ausrichtung des Handelsflusses zwischen Geschäftsbereichen bzw. Warenanbietern und Konsumenten kann nach verschiedenen Marktsegmenten des ECommerce unterschieden werden. Diese Segmente sind: Business-to-Business (B2B) Business-to-Consumer (B2C) Consumer-to-Consumer (C2C) Consumer-to-Business (C2B) Bei E-Commerce können Agenten sowohl von Anbietern als auch von Nachfragern Seite 41 Kapitel 3 Informationsagenten im Web eingesetzt werden. So werden heute schon Agenten von den Anbietern für Personalisierung und Werbung von Produkten eingesetzt. Nachfrager benützen Agenten für Such- beziehungsweise Filterfunktionen, um so die Sucherfolge des gewünschten Produkts zu erhöhen. Nachfrage-Agenten sind auch in der Lage, selbständig komplexe Preis- und Vertragsverhandlungen durchzuführen. Jedoch unterstützen Agenten noch nicht den Kauf und die Lieferung sowie den Service. Besonders in dieser Sparte werden Agenten vermehrt eingesetzt werden, da sie eine wesentliche Erleichterung für den Käufer darstellen. Den Verkäufern können sie helfen, ihre Kunden zielgenauer anzusprechen. [Klusch 2001] 3.8 Beispiele von Informationsagenten In diesem Unterkapitel werden einige interessante Beispiele von Informationsagenten vorgestellt. 3.8.1 Letizia Wie bereits in Abschnitt 3.7.2 erwähnt wurde handelt es sich bei Letizia um einen Adaptiven Informationsagenten. Man kann sich diesen als einen Agenten vorstellen, der mit einem konventionellen Webbrowser zusammenarbeitet, um sein Ziel zu erreichen, nämlich dem Anwender aus der großen Menge von Links auf Webpages die relevanten herauszufiltern. Abbildung 3.5: Letizia integration in Netscape-Interface [Liebermann 1997] Abbildung 3.5 zeigt die Oberfläche von Netscape mit integriertem Letizia-Agenten. Im linken Bereich befindet sich das normale Browserfenster des Benutzers, rechts oben befinden sich die Suchkandidaten von Letizia, und im rechten unteren Bereich werden schließlich die Vorschläge von Letizia angezeigt. Um dem Benutzer sinnvolle Vorschläge bereitstellen zu können, muss der Agent Seite 42 wissen, welche Interessen dieser verfolgt. Letizia bezieht dazu sämtliche Informationen ausschließlich aus der Observation des Benutzers. Jede Auswahl wird mitprotokolliert und jede Seite die vom Benutzer betrachtet wird, wird auch vom Agenten „gelesen“. Diese Seiten werden anhand des TF-IDF (term frequency - inverse document frequency) Verfahren analysiert. Dieses Verfahren basiert auf der These, dass Wörter die im Allgemeinen selten vorkommen im untersuchten Dokument aber sehr oft, am aussagekräftigsten für den Inhalt des Dokumentes sind. Laut Liebermann ist das Verfahren nicht sehr zuverlässig, aber schnell, und kann als Platzhalter für kommende bessere Algorithmen dienen. Während der Benutzer die Webpage betrachtet, führt der Agent eine Breitensuche durch und kann so einen stetigen Fluss an empfehlenswerten Webpages bereitstellen. Im Gegensatz zu Suchdiensten die eine Ansammlung von Links liefern, berücksichtigt Letizia den Zusammenhang von Webpages über Links. Links werden ja vom Autor der Seite gesetzt, um die Relevanz zwischen zwei Seiten hervorzuheben. Daher wird bei Letizia dieser Faktor berücksichtigt. Die Menge von Seiten die nur wenige Links entfernt von der momentan betrachteten Seite sind, werden zu einer so genannten „semantic neighborhood“ zusammengefasst, in der Letizia dann die Breitensuche durchführt. Grundsätzlich kann man sagen der Benutzer führt die Tiefensuche, und Letizia die Breitensuche durch [Liebermann 1997]. 3.8.2 Infosleuth Abbildung 3.6: Struktur des Multiagentensystems InfoSleuth [Nodine et al. 1999], aus [Klusch 2001] Seite 43 Kapitel 3 Informationsagenten im Web InfoSleuth ist ein System, welches ganz speziell zur Suche und Verarbeitung von Information in föderierten Systemen (z.B. im Internet) entwickelt wurde. Das System arbeitet auf der Basis einer ontologischen Darstellung von so genannten Ressourcen, die im Wesentlichen Datenbanken sind und setzt dabei verschiedene Typen von Agenten ein. Diese Agenten kommunizieren über eine gemeinsame Sprache KQML und die einzelnen Aufträge werden im Wissensaustauschformat ANSI KIF formuliert. InfoSleuth enthält Agenten mit unterschiedlichen Aufgaben: User-, Broker-, Ontologie-, Task Execution-, Resource- und Multi-Resource-Agenten. Die Struktur des Multiagentensystems ist in Abbildung 3.6 dargestellt. Die Aufgaben der einzelnen Agententypen können folgendermaßen beschrieben werden: [Nodine et al. 1999] User Agent: Der User Agent unterstützt den Benutzer bei der Formulierung von Suchen und stellt die erreichten Ergebnisse dar. Für die Zukunft ist z.B. auch ein Spracheingabesystem geplant. Broker Agent: Der Broker Agent ist für die Aufgabenverteilung zwischen den Agenten zuständig. Er verfügt über die Kenntnis, welche Agenten welche Fähigkeiten haben und leitet entsprechende Aufgaben an die „kompetenten” Agenten weiter. Kommt ein neuer Agent in das System gibt dieser dem Broker Agenten eine Übersicht über die eigenen Fähigkeiten bekannt. Ontology Agent: Der Ontology Agent ist eine Art semantischer Dolmetscher, dessen Kompetenz im Wissen über verschiedene „Domain Models” liegt. Ontologien bzw. Domain Models sind semantische Grundlagen für verschiedene Themenbereiche. Ein üblicher Anwendungsfall für den Ontology Agent wäre die Unterstützung des User Agenten, um den Benutzer bei der Frageformulierung zu helfen, damit die entsprechende Domäne den semantischen Inhalt der Frage-Syntax korrekt erfasst. Task Execution Agent: Der Task Execution Agent plant und koordiniert die Durchführung der Anfragen von anderen Agenten. Die Planausführung unterstützt Reaktionen auf unvorhergesehene Ereignisse und das Arbeiten mit unvollständigen Informationen. Ressource Agent: Resource Agenten fungieren als Schnittstellen zwischen anderen Agenten des Systems und lokalen Datenquellen, übersetzen deren Inhalte in den Wortschatz der entsprechenden Ontologien und unterrichten den Broker Agenten über den Inhalt der Datenquelle. Des Weiteren kann ein Resource Agent in regelmäßigen Abständen einen Report über seine Datenquelle abgeben oder über Veränderungen informieren. Resource Agenten für Textquellen analysieren die beinhalteten Texte und extrahieren deren Essenz. Multiressource Query Agent: Der Multi Ressource Query Agent teilt komplexe Fragen in einzelne Teilfragen auf, die an die hierfür kompetenten Agenten weitergegeben werden. Die entsprechenden Teilantworten werden vom Multi Ressource Query Agent dann wieder zu einer Antwort zusammengefasst. Zum Beispiel könnte bei einer Anfrage bezüglich des gesamten Inventars eines Kaufhauses ein Agent Mengen und Artikelbezeichnungen kennen, ein anderer die Preise. 3.8.3 RETSINA In einem RETSINA-Multiagentensystem [Sycara et al 1996] kooperieren drei verschiedene Arten von Agenten miteinander, um relevante Informationen im Internet zu Seite 44 finden (siehe Abbildung 3.7): Interface-, Aufgaben- und Informations Agenten. Abbildung 3.7: RETSINA-Architektur eines kooperativen Agentensystems [Sycara et al 1996], aus [Klusch 2001] Die Interfaceagenten stellen für den Benutzer eines RETSINA-Agentensystems den einzigen Zugang zum System dar. Sie helfen ihm interaktiv bei der Spezifizierung von Aufgaben und geben die Ergebnisse ihrer Bearbeitung aus. Alle Aufgabenagenten besitzen jeweils ein umfangreiches bereichsspezifisches Wissen; jeder Agent plant und kontrolliert die Ausführung der Aufgaben, die er von einem oder mehreren Interfaceagenten erhält. Eventuell zerlegt er eine Aufgabe in mehrere Teilaufgaben und delegiert ihre Ausführung entweder an andere geeignete Aufgabenagenten oder direkt an die entsprechenden Informationsagenten. Ein Informationsagent hat einen direkten Zugriff auf eine oder mehrere Informationsquellen. Er kann die Anfragen eines Aufgabenagenten je nach Anforderung einmal oder wiederholt (periodisch) bearbeiten sowie eine bedingte Überwachung von Datenbeständen in den Informationsquellen durchführen. Eine besondere Art der Informationsagenten in einem RETSINAAgentensystem sind die so genannten „Matchmaker-Agenten“. Im Gegensatz zu den Broker-Agenten bei InfoSLeuth beschränken sich diese Agenten nur auf das Vermitteln von relevanten Agenten für die Ausführung einer Aufgabe, überlassen aber alles weitere den davon betroffenen Agenten. Eine Kooperation findet je nach Bedarf zwischen allen Arten von Agenten statt. Die Kommunikation zwischen den Agenten erfolgt in der Sprache KQML. [Klusch 2001] Die Grundidee bei der Entwicklung von Agenten eines RETSINAMultiagentensystems ist die Widerverwendbarkeit von (Java-)Programmcode: Die bereichsabhängigen und bereichsunabhängigen Kontrollstrukturen für Kommunikation, Kooperation, Scheduling und Monitoring sowie Planfragmente und Wissensbasis eines generischen Agenten werden je nach Anwendung für die jeweiligen Agenten geeignet instantiiert. [Klusch 2001] Seite 45 3.8.4 Kapitel 3 Informationsagenten im Web Daffodil Bei Daffodil handelt es sich um ein Agentensystem für digitale Bibliotheken im World Wide Web (Distributed Agents for User- Friendly Access of Digital Libraries). In der ersten Projektphase wurde ein nutzerorientiertes Zugangssystem für digitale Bibliotheken entwickelt. Da es dem Anwender herkömmlicher Digitaler Bibliotheken oft nicht möglich ist wegen fehlender Adaptivität, inadäquater Funktionalität und mangelhafter Visualisierung das Angebot verschiedenster Digitaler Datenbanken effektiv zu nutzen. Basierend auf Erfahrungen aus dem Bibliotheksbereich wurden höhere Funktionen zur Unterstützung bewährter Suchstrategien realisiert. Dabei wurden verschiedene Digitale Bibliotheken eng integriert, so dass Suche und Navigation systemweit möglich ist. Das System ist an unterschiedliche Benutzerwünsche bezüglich des Systemverhaltens und bevorzugter Inhalte adaptierbar bzw. verhält sich adaptiv. Die Gestaltung der Benutzungsoberfläche orientiert sich an neuen Erkenntnissen aus der Mensch-Maschine-Interaktion und unterstützt unterschiedliche Interaktionsmodi. In einer zweiten Projektphase wurde das Konzept der strategischen Unterstützung bei der Nutzung digitaler Bibliotheken beibehalten und wurde nun auf alle Verarbeitungsstufen beim Umgang mit digitalen Bibliotheken, sowie die verschiedenen Arten der Informationsbeschaffung erweitert. Für die Organisation gefundener Materialien, deren Annotation und Interpretation wurde eine persönlichen Handbibliothek eingerichtet. Diese bietet gleichzeitig einen Nutzer- und aufgabenbezogenen Kontext, der das Suchen und Browsen besser als bisher unterstützt. Als zusätzliche Methoden der Informationsbeschaffung wurde das Pfad-Modell, kollaboratives Filtern sowie das Workflow-Modell integriert. Die beiden letztgenannten Methoden erlauben die Kooperation bei der Anwendung von digitalen Bibliotheken; hierbei wird der Sonderrolle von Bibliothekaren Rechnung getragen. Die Gestaltung der Benutzungsoberfläche unterstützt unterschiedliche Interaktionsmodi - insbesondere sollen umständliche Arbeitsprozesse durch Informationsagenten unterstützt und automatisiert werden; dabei muss die Anwenderautonomie berücksichtigt werden. Ebenso soll der iterative Arbeitsprozess beim Information Retrieval, unter Berücksichtigung von Agentennetzen und asynchronen oder langwierigen Retrievalschritten, optimiert werden. Das System bietet dem Benutzer höherwertigere, zielgerichtete Funktionalität an, als sie von einer einzelnen digitalen Bibliothek erbracht werden kann. Benutzerinteraktion mit digitalen Bibliotheken über das Agentensystem lässt sich in vier Schichten modellieren (siehe. Abbildung 3.10). Auf unterster Ebene befinden sich die im WWW angebotenen digitalen Bibliotheken. Transparenter Zugriff auf deren Funktionen und Daten ist durch die Schicht der Wrapper-Agenten gewährleistet. Aufgabe der Wrapper-Agenten ist es, die von den digitalen Bibliotheken erbrachten Funktionen und Daten so zu kapseln, dass sie für das Gesamtsystem nutzbar sind. Auf der anderen Seite kommuniziert der Benutzer mit dem Gesamtsystem über einen UserinterfaceAgenten. Die Aufgabe des Userinterface-Agenten ist zweifältig. Zum einen muss er die vom Gesamtsystem erbrachte Funktionalität dem Benutzer anbieten. Ausgehend von den Seite 46 Aktionen der Benutzer macht er dazu entsprechende Angebote bzw. nimmt die Funktionalität des Gesamtsystems in Anspruch. Zum anderen muss der UserinterfaceAgent die von den Service-Agenten erbrachten Ergebnisse visualisieren. Zwischen Userinterface- und Wrapper-Agenten befindet sich nun das Herzstück des Agentensystems, eine kritische Masse von Service-Agenten, die die zusätzliche Funktionalität implementieren. Jeder angebotene Dienst, der sich auf den Ebenen der Suchfunktionalität nach Bates (siehe Abschnitt 3.5) einordnen lässt, wird von einem Service-Agenten implementiert. Zur Realisierung eines Dienstes greift ein Service-Agent auf Dienste von anderen Service-Agenten, sowie der Wrapper-Agenten zurück. Agenten erfüllen ihre Aufgaben in Zusammenarbeit mit anderen Agenten. Services können nur durch Kommunikation erbracht werden. Sollen Services auf mehreren digitalen Bibliotheken basieren, muss eine Kommunikation mit diesen Bibliotheken gewährleistet sein. Service-Agenten, die einen Dienst basierend auf Diensten anderer Service-Agenten erbringen, müssen mit diesen kommunizieren. Für die Kommunikation der Service-Agenten wurde ein Bussystem konzipiert, das Broadcasting, Groupcasting sowie Peer-to-Peer-Kommunikation zwischen einzelnen Agenten ermöglicht. Abbildung 3.8: Schichtenmodell in Daffodil [Fuhr 2000] Die Objekte, über die kommuniziert wird, orientieren sich an den Objekten, die von den digitalen Bibliotheken in das System eingebracht werden. Diese lassen sich über die von Fuhr genannten Ebenen von Informationsstrukturen [Fuhr 2000] in Datenbanken identifizieren: Schema: Auf Schemaebene werden die möglichen Attribute von Dokumenten und von deren Metadaten modelliert. Beispiele für standardisierte Schemata sind der Dublin Core oder bibliographische Datenformate wie MAB und MARC. Attributwert: Der Wertebereich zu einem Attribut aus dem Datenbankschema kann zum Navigieren und zur Anfrageerstellung verwendet werden. Häufig sind Attributwerte selbst strukturiert, z. B. in Thesauri oder Klassifikationen. Seite 47 Kapitel 3 Informationsagenten im Web Metadatensatz: Ein Metadatensatz fasst die Attributwerte bezüglich eines Schemas zu einem gegebenen Dokument zusammen, z. B. bibliographische Attribute, wie Titel, Autor, Erscheinungsjahr und Quelle. Volltext: Das Dokument selbst, mit Inhalt und Struktur. Abbildung 3.9: Klassenhierarchie für Anfrageobjekte in Daffodil [Fuhr 2000] Anfrageobjekte innerhalb des Agentensystems beziehen sich nun entweder auf Objekte innerhalb einer Ebene der Informationsstrukturen, oder sie schaffen Übergänge zwischen zwei Ebenen. Es ergibt sich die in Abbildung 3.9 gezeigte Klassenhierarchie für Anfrageobjekte. 3.9 Zusammenfassung Gegenwärtig ist die wissensbasierte Suche nach relevanten Informationen im Internet durch intelligente Informationsagenten sehr attraktiv. Die Suchmaschinen der Gegenwart werden längst nicht mehr den Wünschen der Anwender gerecht. In der Zukunft wird der Bedarf an Informations-Management nicht mehr mit herkömmlichen Strategien bewältigt werden können [Liebermann, 1997]. Traditionell ist Informations-Management eine Aufgabe des Information Retrieval (IR). Doch IR setzt sich mit relativ statischen Informationsquellen auseinander. Der Informationsraum Web ist aber hochdynamisch, unstrukturiert und nicht unbedingt textbezogen, daher versagen hier die klassischen IRTechniken. Andererseits basieren viele Suchmaschinen auf IR. Sie benutzen meist die Häufigkeit von Stichwörtern um das Thema eines Dokuments zu bestimmen. Hier wird auf die Fähigkeit des Anwenders gesetzt, eine gezielte Anfrage zu stellen, und gegebenenfalls diese Anfrage nach und nach zu verfeinern. Dieser iterative Prozess ist aber hoch komplex, und bereitet vielen Benutzern Probleme. Informationsagenten können hier dem Benutzer behilflich sein. Die Aufgabe des Suchens, Organisierens, Verwaltens und des Präsentierens sollte im Auftrag des Anwenders von Informationsagenten übernommen werden. Unter einem Informationsagenten versteht man einen Agenten, der in einem Informationsraum tätig ist und dessen Aufgabe es ist, dem Anwender beim Zugriff und der Verwaltung von Informationsquellen und der von ihr bereitgestellten Information zu unterstützen. Diese Informationsräume sind z. B. durch das Web verbundene Datenbanken, Suchdienste oder auch einzelne Webseiten. Das Spektrum für den Einsatz von Informationsagenten ist so breit wie die verschiedenen Arten von Informationen und so verschieden wie der Informationsbedarf der Anwender. Gegenwärtig liefern Informationssysteme objektiv relevante Information, die nach einem für den Benutzer schwer nachvollziehbaren Bewertungsschema beurteilt werden. Der Einsatz von Informationsagenten soll den Benutzer beim Auffinden subjektiv relevanter Information unterstützen, in der auch die Bedürfnisse des Benutzers in die Bewertung mit Seite 48 einbezogen werden. Seite 49 Kapitel 4 Multiagentensysteme Kapitel 4 4 Multiagentensysteme Im vorigen Kapitel wurden interessante Beispiele von Informationsagenten, beschrieben, die innerhalb einer Multiagentenumgebung agieren (siehe Abschnitte 3.8.2 bis 3.8.4). In diesem Kapitel werden nun wesentliche Aspekte, die im Zusammenhang mit solchen Mehragentensystemen auftreten, näher betrachtet. 4.1 Allgemeines Betrachtet man Systeme, die aus mehreren kollaborativ arbeitenden Agenten bestehen, so ergeben sich zwei grundsätzlich unterschiedliche Sicht- und Herangehensweisen. Erfolgt die Modellierung problemzentriert top-down29, beginnend mit einer Zerlegung des Problems in Subprobleme und nachfolgender Identifikation und Implementierung von Spezialagenten für die Teilaufgaben, wird von einem DPS-System30 gesprochen. Es existiert ein zentrales Systemdesign, und das System ist insoweit relativ geschlossen, als dass die teilnehmenden Agenten a priori bekannt sind. Sie verhalten sich im Sinne der zu erzielenden Problemlösung kooperativ und benötigen, da sie Teil eines Gesamtkonzepts sind, nur eingeschränkte Autonomie. In DPS Systemen ist der Untersuchungsgegenstand der Rationalität oder des Verfolgens von Zielen von eher nebensächlichem Rang, zumeist sind diese Aspekte implizit in das Systemdesign eingebaut und nicht Gegenstand der Agentenmodellierung. DPS Systeme werden üblicherweise zur Realisierung verteilter Problemstellungen verwendet, wobei die Verteilung räumlicher, funktionaler oder zeitlicher Natur sein kann. [Fricke 2000] Im Gegensatz zum reduktionistischen Ansatz des DPS ist die Vorgehensweise im Forschungsbereich Multi-Agent Systems (MAS) konstruktivistisch: Hier steht die Modellierung einzelner Agenten im Vordergrund. Weder ist ein globales Ziel vorgegeben noch ein Problem zu lösen, anstelle dessen verfolgen die Agenten eigene, persönliche Ziele. [Fricke 2000] Während DPS-Systeme von ihrer Konzeption her grundsätzlich kooperativ sind, zeichnen sich MAS eher durch Eigeninteresse der Agenten oder sogar Konkurrenzsituationen aus. Aufgrund der Fokussierung auf die Modellierung einzelner Agenten eignet sich dieser Ansatz sehr gut für offene Domänen. MAS-Agenten benötigen ein höheres Maß an Autonomie, Flexibilität und Intelligenz, da sie in unbekannten Umgebungen wirken. Das „Funktionieren“ eines Mehragentensystems, das aus „selbst 29 Wooldridge und Jennings nennen dies reduktionistisch [Wooldridge et al. 1995]. Distributed Problem Solving. Nach [Davis et al. 1983] besteht das verteilte Problemlösen aus den 4 Phasen Problemzerlegung, Problemverteilung, Abarbeitung der Teilprobleme und Lösungssynthese. 30 Seite 50 interessierten“ Agenten besteht, beruht oft auf Synergieeffekten, die durch dynamische Koordination und Kooperation entstehen können. [Fricke 2000] Stand der Technik sind DPS-Lösungen, die entweder auf etablierten Techniken wie der Blackboard-Kommunikation (siehe Abschnitt 4.4) beruhen oder mit Hilfe so genannter agentenorientierter Designmethoden im Sinne objektorientierter Softwareentwicklung erstellt werden. Im Bereich MAS hingegen sind viele Aspekte noch Forschungsgegenstand und werden erst in zukünftigen Anwendungen zum Einsatz kommen. [Fricke 2000] 4.2 Eigenschaften von Multiagentensystemen In Systemen mehrerer autonomer Agenten treten verschiedene Merkmale verteilter Systeme in Erscheinung, die sich im Verhalten eines isoliert arbeitenden Agenten nicht zeigen. [Fricke 2000] Komplexe und dynamische Umgebung: Bei Multiagentensysteme handelt es sich um komplexe Systeme die sich durch ihr nichtdeterministisches Verhalten auszeichnen. Eine gewisse Dynamik entsteht dabei über längere Sicht nur, durch das System verlassende oder neu das System betretende Agenten. Dabei sind die Informationen in einem Multiagentensystem im Unterschied zu monolithischen Systemen nicht transparent über die einzelnen Agenten verteilt. Ein einzelner Agent kennt nur den für ihn interessanten Ausschnitt der Welt, der aber nicht unbedingt exakt und korrekt sein muss. Durch das gleichzeitige Wirken mehrerer autonomer Einheiten ist Wissen über den Zustand der Umgebung generell temporärer Natur. Synergieeffekte durch Kooperation und Koordination: Um die Gefahr von Deadlocks oder Ressourcenengpässen zu vermindern ist ein Abstimmen der Aktionen einzelner Agenten mit anderen Agenten von Vorteil. Wird das Handeln einzelner Agenten insofern koordiniert, dass redundante Handlungen nicht mehrfach durchgeführt werden oder aber auch mehrere Agenten zeitkritische Aufgaben zerlegt bearbeiten, so kann das durchaus zu Verbesserungen führen. Durch Wissensaustausch und Rollenverhalten, aber auch durch längerfristige Kooperationen erschließen sich Synergieeffekte. Diese wird durch die so genannten „value-added services“ ermöglicht, eine Kombination einfacher Basisfunktionalitäten zu neuartigen. Häufig wird nicht einmal domänenspezifisches Wissen benötigt, so ist es möglich Koordinierungs- und Kooperationsmechanismen als generische Bestandteile in Agenten einzupflanzen. Flexibilität durch Offenheit: Werden Agentensysteme bewusst redundant ausgelegt so wird damit die Ausfallsicherheit erhöht. Funktioniert ein System derart auch noch bei Ausfall einzelner Komponenten, so spricht man von „graceful degradation“. Üblicherweise wird Redundanz benutzt, um Performanceprobleme zu lösen. Ein weiterer Aspekt der Flexibilität liegt in der Offenheit von Agentensystemen: Da es sich bei Agenten um eigenständige Prozesse handelt, die über eine einheitliche Schnittstelle, die Agentenkommunikationssprache, verfügen können Agenten zur Laufzeit dynamisch ersetzt und hinzugefügt werden, ohne das Gesamtsystem zum Stillstand zu bringen. Keine zentrale Steuerung des Gesamtsystems: Da das Gesamtsystem keiner zentralen Steuerung unterliegt ist es Agenten möglich selbst über ihre nächsten Aktionen zu Seite 51 Kapitel 4 Multiagentensysteme entscheiden. 4.3 Mögliche Vorteile von Multiagentensystemen Durch den Einsatz von Multiagentensystemen ergeben sich folgende Vorteile: [Schneeberger 2001b] Dadurch dass die Rechenleistung nicht von einem einzelnen Programm bzw. Computer erbracht werden muss, kann die Berechnung schneller abgeschlossen werden. Für kritische Funktionen können mehrere Agenten vorgesehen werden, so dass beim Ausfall des einen Agenten ein anderer einspringen kann. Wenn ein Computer ausfällt, oder ein Softwarefehler auftritt, dann bleibt also nicht gleich das ganze System stehen, sondern es fällt nur eine einzelne Funktion aus, und die verbleibenden Teile können immer noch sinnvolle Arbeit leisten. Skalierbarkeit: Es können einfach weitere Agenten hinzugefügt werden, wenn die Aufgabenstellung von den bislang benutzten Systemen nicht mehr geleistet werden kann. Günstigere Kosten: Statt einem teueren Spezialrechner mit Spezialsoftware kann man viele kleine Computer mit Software-Agenten einsetzen. 4.4 Agentenkommunikation Für unterschiedlichste Einsatzzwecke gibt es viele verschiedene etablierte Kommunikationstechniken. Durch Protokolle kommt es zu einer verlustfreien Übermittlung, der Datenaustausch erfolgt entweder verbindungsorientiert oder verbindungslos, synchron oder asynchron, als Datenstrom oder in Pakete geschnürt und eventuell noch komprimiert und verschlüsselt. [Fricke 2000] Um in verteilten Systemen eine einheitliche Sicht auf die verschiedenen Programmelemente eines Netzwerkes und deren einfache Nutzung zu ermöglichen kommt Kommunikations-Middleware wie CORBA31 oder DCOM32 mit BrokeringDiensten zum Einsatz. [Fricke 2000] Im Bereich der Multiagentensysteme könnte es sich bei einem solchen Broker-Dienst selbst um einen Agenten handeln. Dieser kann einerseits der Lokalisierung der Kommunikationspartner dienen, aber auch den Transport der Nachrichten zum jeweiligen Partner übernehmen. Damit ist es möglich dass ein Agent den Empfänger nicht mehr direkt kennt, sondern ein geeigneter Empfänger für die jeweilige Nachricht durch den Broker gesucht wird. Um eine sinnvolle Kommunikation unter Agenten zu ermöglichen müssen die nachfolgend aufgezählten Voraussetzungen gegeben sein: 31 32 Common Object Request Broker Architecture [Yang et al. 1996] Distributed Computing Environment [Brando 1995] Seite 52 Die Agenten müssen über eine gemeinsame Kommunikationssprache verfügen. Die Agenten müssen ein gemeinsames Verständnis über die Inhalte der Kommunikation haben. Die Agenten müssen die Fähigkeit besitzen untereinander Nachrichten austauschen zu können. Beim Design einer Agentenkommunikationssprache (ACL) sind folgende Aspekte von besonderer Relevanz: [Fricke 2000] Inhalt und Bedeutung Agentenkommunikationssprachen müssen ausdruckskräftig sein, weiters muss ein Informationsaustausch auf der Wissensebene. möglich sein Agenten übermitteln nicht einfach nur Daten, deren Interpretation dem Empfänger überlassen ist; vielmehr spielt auch die Bedeutungsebene eine große Rolle: Agenten erbitten die Erbringung von Diensten, wünschen die Erreichung eines Zieles, erfragen die Pläne anderer Agenten oder schlagen Wege zur Behebung von Konflikten vor. Um die Sprache effizient und möglichst einfach benutzbar zu machen sollte es eine Unterscheidung geben, zwischen einem Teil, der die Bedeutung ausdrückt, und einem Teil, der den eigentlichen Inhalt der Kommunikation ausdrückt. Ist dies der Fall spricht man von einer so genannten Schichtstruktur Universalität Da offene Systeme, in denen Agenten ausgetauscht, hinzugefügt oder entfernt werden können. wünschenswert sind, ist eine einheitliche Kommunikationssprache von großem Vorteil. Anwendungen bestehen aus Agenten, die von unterschiedlichen Entwicklern stammen. Diese Heterogenität macht eine einheitliche Kommunikationssprache erstrebenswert, die unabhängig von der konkreten Implementierung der Agenten ist. Weiters ist auch die Netzwerkfähigkeit von Agenten außerordentlich wichtig, d.h. die Sprache sollte gut zu den modernen Netzwerktechnologien passen und unabhängig von Transportmechanismen (z.B. TCP/IP, E-Mail, http, etc.) sein. Dialoge Um gemeinsam komplexe Aufgaben zu erfüllen oder auch Konfliktsituationen zu meistern muss es Agenten möglich sein zielgerichtete Dialoge zu führen. Dabei funktioniert Kommunikation nicht wie bei herkömmlichen Kommunikationsanwendungen nach dem Client-Server-Prinzip, sondern findet zwischen gleichberechtigten Partnern statt. Eine weitere wünschenswerte Eigenschaft einer Agentenkommunikationssprache ist, dass sie auch für menschliche „Agenten“ einfach lesbar und interpretierbar ist. In frühen Anwendungen der DAI33 kamen vorwiegend Blackboards (siehe Abbildung 4.1) als Kommunikationsform zum Einsatz. Sie stellen eine abstrakte Form des shared memory dar. Agenten schreiben Daten auf das Blackboard oder lesen Daten von diesem und kommunizieren auf diese Weise miteinander. Ein Merkmal dieser frühern 33 Distributed Artificial Intelligence (Verteilte Künstliche Intelligenz) Seite 53 Kapitel 4 Multiagentensysteme Anwendungen liegt in der indirekten Kommunikation, das direkte Adressieren einer Nachricht an einen bestimmten Agenten ist mit solch einem Blackboard nicht möglich. Abbildung 4.1: Prizip der Blackboard Kommunikation [Schneeberger 2001b] Mit der zunehmenden Realisierung echt verteilter Systeme gerieten Blackboards zugunsten direkter, sprechaktbasierter Kommunikationsformen (siehe Abschnitt 4.4.2) zunehmend in den Hintergrund. 4.4.1 Sprechakte Im Bereich der DAI kommen überwiegend, an die menschliche Kommunikation angelehnte, sprechaktbasierte Sprachen zum Einsatz. Wesentliches Element eines Sprechakts ist neben der übermittelten Information der Aspekt des Handelns. Austin identifizierte drei unterschiedliche Aspekte der Kommunikation (siehe Abbildung 4.2): [Fricke 2000] Lokutionäre Akte Die lokutionären Akte beschreiben den Sprechakt im Hinblick auf Artikulation, Konstruktion und Logik. Illokutionäre Akte Die illokutionäre Ebene drückt eine beabsichtigte Wirkung und damit eine kommunikative Funktion aus. Perlokutionäre Akte Der perlokutionäre Aspekt fokussiert auf Konsequenzen beim Empfänger. Für Agenten spielt ausschließlich die illokutionäre Ebene eine Rolle. Lokutionäre Aspekte werden entweder durch die Übertragung mittels des Kommunikationsmediums abgedeckt und sind daher uninteressant, oder können - wie beispielsweise Betonung oder Gestik - prinzipiell nicht übermittelt werden. Seite 54 Abbildung 4.2: Einordnung der Sprechakte nach Austin [Austin 1985] Auf der anderen Seite liegt es außerhalb der Kontrolle eines Agenten, die beabsichtigte Wirkung bei einem anderen Agenten sicherzustellen. 4.4.2 Sprechaktbasierte Agentenkommunikationssprachen Gegenwärtig dominieren zwei Vertreter der sprechaktbasierten Sprachen den Bereich der Agentenkommunikation: KQML (Knowledge Query and Manipulation Language) FIPA-ACL Beide Sprachen beruhen auf einer Reihe illokutionärer Sprechakte (so genannte Performatives) Dabei werden Syntax, Nachrichteninhalt und Bedeutung getrennt. Um die eigentliche Botschaft darzustellen kommen meist logikbasierte Wissensrepräsentationssprachen zum Einsatz. Diese benutzen ihrerseits ein in einer so genannten Ontologie (siehe Abschnitt 4.4.) beschriebenes Vokabular Prinzipiell kann der Nachrichteninhalt aber auch in weniger mächtigen Sprachen wie zum Beispiel XML beschrieben werden. Eine Nachricht in KQML könnte zum Beispiel folgendermaßen aussehen: Seite 55 Kapitel 4 Multiagentensysteme Abbildung 4.3: Beispiel einer KQML-Nachricht [Schneeberger 2001b] Die in Abbildung 4.3 dargestellte KQML-Nachricht beschreibt in etwa wie der Agent ‚buyer’ dem Agenten ‚auctioneer’ ein Angebot über 150 Währungseinheiten für eine verhandelte Ware unterbreitet. Die Währung in der das Angebot gemacht wird ist dabei in der Ontologie ‚markets’ definiert. Der Inhalt dieser Nachricht ist in Prolog kodiert, was aus dem Parameter language ersichtlich ist. Aufgrund der asynchronen Kommunikation wird der Parameter in-reply-to verwendet, der dem Empfänger eine Zuordnung zu vorangegangenen Nachrichten ermöglicht. Im Parameter protocol ist der Name des verwendeten Interaktionsprotokolls (siehe. Abschnitt 4.4.3) angegeben, welches den Ablauf der Konversation definiert. Im oben gezeigten Beispiel ist die Schichtstruktur einer KQML-Nachricht zu erkennen, die in Abbildung 4.4 skizziert ist. Die Kommunikationsschicht enthält Absender (:sender) und Adressat (:receiver). Die Sprechaktschicht enthält neben dem Sprechakt selbst nähere Angaben zum Inhalt. In der Inhaltsschicht befindet sich schließlich der eigentliche Nachrichteninhalt (:content). Analoges gilt auch für FIPAACL Nachrichten. Abbildung 4.4: Schichtstruktur einer KQML-Nachricht [Schneeberger 2001b] Die Sprachbeschreibung von KQML enthält 43 Performatives. Nachfolgend werden einige dieser Performative genannt: tell bezeichnet eine Mitteilung ask-if kennzeichnet eine Frage nach einer bestimmten Tatsache ask-about wird für allgemeine Anfragen verwendet, d.h. wenn der Ansprechpartner irgendetwas über ein bestimmtes Thema weiß, soll er das melden. reply und sorry werden für Antworten auf Fragen verwendet. Seite 56 Zum Verständnis der nächsten Performatives ist zu sagen, dass es in einem KQML Szenario meist Broker bzw. Vermittler gibt. Wenn ein Agent an der KQML Kommunikation teilnehmen will, dann meldet er sich zunächst beim Vermittler an. Dies geschieht mit dem Performative register. Mit subscribe kann ein bestimmtes Thema beim Vermittler abonniert werden - d.h. der Agent erfährt immer, wenn es neue Information zu diesem Thema gibt. Mit advertise kann ein Agent seine Fähigkeiten und Dienste beim Vermittler anmelden. Mit Hilfe solcher Performatives können Informationen ausgetauscht und einfache Dialoge gebildet werden. Dies soll anhand folgender Beispiele gezeigt werden. Dazu sei zunächst angenommen, dass es drei Agenten gibt: einen Vermittler oder Broker V und zwei Agenten A und B. Alle drei Agenten sind in einem lokalen Netz miteinander verbunden. Weiters sei vorausgesetzt, dass beide Agenten A und B sich bereits beim Vermittler V registriert haben. Im ersten Beispiel (siehe Abbildung 4.5) wendet sich Agent A direkt an Agent B mit der Frage „ask“ und dem Inhalt „X“. Agent B antwortet auf diese Frage mit der Mitteilung „tell“ und einem Inhalt „X“. Abbildung 4.5: Ein Einfacher Frage-Antwort-Dialog mittels KQML [Schneeberger 2001b] Im nächsten Beispiel (siehe Abbildung 4.6) abonniert Agent A beim Broker V alle Informationen über X. Etwas später erhält der Broker V von Agent B eine Mitteilung „tell“ über X, die V anschließend an Agent A weiterreicht. Abbildung 4.6: Agent A abonniert bei Broker V alle Informationen über X [Schneeberger 2001b] Im abschließenden Beispiel (siehe Abbildung 4.7) wirbt Agent B gegenüber dem Vermittler V mit seinem Wissen über X. Später bittet Agent A, V um eine Quelle für X, und V antwortet mit dem Hinweis auf Agent B. Jetzt kann Agent A die Anfrage über X Seite 57 Kapitel 4 Multiagentensysteme direkt an Agent B leiten, und bekommt auch entsprechend eine Antwort. Abbildung 4.7: Ein etwas komplexerer Dialog mittels KQML [Schneeberger 2001b] Im Gegensatz zu KQML kommt ACL mit nur 20 Nachrichtentypen aus, die aus 5 grundlegenden Kommunikationsakten inform, request, query, confirm, disconfirm, aufgebaut werden. Der wichtigste Unterschied zwischen beiden Sprachen liegt in der semantischen Fundierung. Während für KQML-Sprechakte nur prosaische Annotierungen existieren, werden Bedeutung und Anwendbarkeit von FIPA-Nachrichten genauestens spezifiziert. 4.4.3 Interaktionsprotokolle Wie aus den Beispielen in vorigem Abschnitt zu sehen ist, können mit den oben behandelten Sprechakten Informationen ausgetauscht und einfache Frage-AntwortDialoge durchgeführt werden. Damit Agenten auch zu längerfristigen Interaktionen wie etwa Verhandlungen und Kooperationen in der Lage sind benötigt man so genannte Interaktionsprotokolle. Ein solches Protokoll regelt den Ablauf einer Konversation. Es legt für alle Beteiligten fest, wann sie welche Sprechakte austauschen und welche Inhalte übermittelt werden. In diesem Sinne stellen Interaktionsprotokolle eine Verbindung von Kommunikation und Handeln dar, wozu die Sprechakttheorie allein nicht ausdrucksmächtig genug ist. Verhandlungen sind notwendig, wenn zur Erreichung des Ziels kooperatives Handeln notwendig ist, oder wenn die Aktionen und Ziele der Agenten sich gegenseitig widersprechen. Eine Verhandlung ist dann ein iteratives Verfahren, um einen kooperativen Plan in einem Multiagentensystem zu finden, so dass alle Aufgaben von Auftragnehmern übernommen werden. 4.4.3.1 Contract-Net-Protokoll Ein sehr bekannter Vertreter dieser Interaktionsprotokolle ist das so genannte Contract-Net-Protokoll. Sein Zweck ist das Delegieren von Aufgaben an andere Agenten, aber auch die Vergabe von Ressourcen kann mit diesem Mechanismus gesteuert werden. Dieses Protokoll wird nun nachfolgend näher beschrieben. Seite 58 Ein Kontraktnetz stellt folgendes Szenario dar: Es existiert eine Menge von Agenten, und es gibt zwei verschiedene Rollen für Agenten, Manager und Auftragnehmer. Ein Manager vergibt eine Aufgabe und überwacht deren Ausführung, während ein Auftragnehmer für die Ausführung der übernommenen Aufgabe verantwortlich ist. Dabei werden die beiden Rollen dynamisch vergeben und jeder Agent kann gleichzeitig Manager und Auftragnehmer sein. Es wird davon ausgegangen, dass jeder Agent kooperationsbereit ist und versucht Aufgaben zu übernehmen. Der Ablauf der Interaktionen zwischen einem Manager und einem Auftragnehmer (Kontraktor) ist in Abbildung 4.8 skizziert. Abbildung 4.8: Ablauf der Kommunikation zwischen Manager und Kontraktor innerhalb des Contract-Net-Protokolls [Schneeberger 2001b] Der Manager initiiert eine Ausschreibung für seine Teilprobleme, die er nicht selbst lösen kann, so dass alle Agenten davon Kenntnis bekommen, die für die Ausführung der Teilaufgaben in Frage kommen. Eine solche Ausschreibung könnte per KQML etwa mit dem „broadcast“ performative oder durch informieren des Brokers erfolgen. Alle Agenten, die sich in der Lage sehen eine der Teilaufgaben zu bewältigen, bewerben sich beim Manager um die Ausführung der entsprechenden Aufgabe. Der Manager seinerseits bewertet alle eingegangenen Angebote, und erteilt dem Anbieter mit dem günstigsten Angebot den Zuschlag. Zwischen beiden Parteien erfolgt ein Vertragsabschluss und alle weiteren Vereinbarungen werden in direkter zweiseitiger Kooperation abgewickelt. Nach Abschluss der Arbeiten wird das Ergebnis an den Auftraggeber übermittelt, der aus allen vergebenen Unteraufträgen wiederum ein Gesamtergebnis zusammenstellen muss. Der Manager braucht in der Wartezeit nicht untätig zu sein, sondern er kann sich seinerseits auf Angebote anderer Manager bewerben. Auch der Auftragnehmer muss die Aufgabe nicht unbedingt alleine erledigen, sondern er kann eine weitere Zerlegung und Ausschreibung der Arbeiten vornehmen. 4.4.3.2 Iterated Contract-Net-Protokoll nach FIPA Ein Problem mit dem zuvor beschriebenen Contract-Net-Protokoll ist, dass manchmal Seite 59 Kapitel 4 Multiagentensysteme eine gute Arbeitsverteilung verhindert wird, weil es nach dem Prinzip „wer zuerst kommt, mahlt zuerst“ Verträge abschließt. Dadurch kann ein Auftragnehmer schon durch einen Vertrag gebunden sein, obwohl er eigentlich für die nächste offene Aufgabe besser geeignet wäre. Dieser Effekt lässt sich durch eine Änderung des Modus beim Bieten vermeiden. Ein Manager erteilt nicht mehr einfach dem ersten besten Bieter einen Auftrag, sondern er versucht alle seine Aufgabenstellungen gleichzeitig zu vergeben. Das kann dadurch erreicht werden, dass der Manager die Aufgaben mit einer Bezahlung ausschreibt. Wenn jetzt eine oder mehrere Aufgaben unbearbeitet bleiben, so kann er in der nächsten Ausschreibungsrunde die Bezahlung für diese unbearbeiteten Teilaufgaben erhöhen. Dieses Verfahren wird so lange wiederholt, bis wirklich alle Teilaufgaben vergeben sind, erst dann werden die entsprechenden Verträge mit den Auftragnehmern abgeschlossen. Abbildung 4.9: FIPA Iterated Contract Net-Protokoll [Fipa 2002a] Abbildung 4.9 zeigt das UML-Diagram der Fipa Spezifikation einer Variante dieses Protokolls, das so genannte Iterative Contract-Net-Protokoll. Ein Manager (Initiator) initiiert m Ausschreibungen (cfp-Performativ). Von den n Antworten die der Manager Seite 60 erhält, sind k Antworten positiv (propose-Performativ), d.h. diese Agenten bewerben sich um den Auftrag, die restlichen j Antworten sind negativ (refuse-Performativ). Anhand der k positiven Antworten entscheidet der Initiator ob dies der letzte Iterationsschritt ist und akzeptiert in diesem Fall p (0 < p < k) der Angebote (accept-proposal), den restlichen sagt er ab (reject-proposal). Als Alternative kann der Manager in einer weiteren Iteration eine modifizierte Ausschreibung initiieren. Für eine detaillierte Beschreibung sei auf [Fipa 2002a] verwiesen. 4.4.3.3 Auktions-Protokolle Eine weitere Problemstellung, die häufig in Multi-Agenten-Szenarien auftritt ist, eine effizient und fair gestaltete Preisbildung zwischen Anbietern und Nachfragern zu finden. Dies kann zum Beispiel mittels so genannter Auktions-Protokolle gelöst werden. In [FIPA 2002b] und [FIPA 2002c] werden zwei dieser Auktions-Protokolle beschrieben, die zum Finden des Marktpreises einer Ware verwendet werden können. Bei der so genannten „englischen Auktion“ (siehe Abbildung 4.10) beginnt der Auktionator (Anbieter) mit einem niedrigen Preisniveau und erhöht solange, bis keine neuen Gebote von den Bietern (Nachfragern) mehr eingehen. Mit dem Startsprechakt (inform start auction), der zum Beispiel per Broadcast an alle Agenten geht, wird die Auktion eröffnet. Das Bieten erfolgt anonym, d.h. kein Bieter kann sich ein Bild von den Konkurrenten machen. Am Ende erhält der Meistbietende den Zuschlag, falls dessen Gebot über einem festgelegten Minimalpreis liegt. Die Auktion wird durch Bekanntgabe eines entsprechenden Endsprechakts (inform end-auction) beendet und der Bestbietende wird mit dem request perform (action)-Sprechakt um Bezahlung gebeten. Der umgekehrte Weg wird durch die so genannte „holländische Auktion“ beschritten. Hier startet der Auktionator mit einem offensichtlich über dem Marktwert liegenden Preis und reduziert solange, bis der erste Bieter akzeptiert. In beiden Modellen hat ein ausgezeichneter Auktionator das Heft des Handelns in seiner Hand. Abbildung 4.10: FIPA Protokoll einer englischen Auktion [Fipa 2002b] Seite 61 Kapitel 4 Multiagentensysteme Natürlich gibt es neben den hier erwähnten Interaktionsprotokollen eine große Anzahl weiterer, die je nach Aufgabenbereich mitunter sehr komplex sein können. 4.4.4 Ontologien Der Begriff „Ontologie“ hat in Agentensystemen eine etwas andere Bedeutung als in der Philosophie34. Eine Ontologie legt eine Reihe an Wörtern oder Objekten, ihre Beziehungen untereinander und ihre Bedeutung in einem bestimmten Kontext fest. [Griss 1999]. Eine Ontologie ist also eine Spezifikation der Bedeutung von Schlüsselwörtern. Es genügt nicht nur die Syntax und die Existenz der Schlüsselwörter zu definieren. Alle an der Konversation beteiligten Agenten müssen diese Schlüsselwörter im selben Kontext gleich interpretieren. Eine Ontologie definiert den Wortschatz einer bestimmten Anwendungs-Domäne. Es ist entscheidend, in welcher Anwendungs-Domäne (Kontext) diese Definition geschieht, da das gleiche Wort an anderer Stelle eine abweichende Bedeutung haben kann. Neben der Definition der Wörter können auch die Beziehungen zwischen diesen festgelegt werden. Beziehungen können Generalisierungen oder Spezialisierung sein, Synonyme oder Antonyme, Aggregationen, etc. Alle Agenten in einem Multiagentensystem müssen auf dieselben Ontologien zurückgreifen, damit eine Kommunikation erwartungsgemäß funktioniert. Ein Agent kann die für seine Aufgaben benötigten Ontologien in Form von Programm-Code erhalten oder ein oder mehrere Dienste in einem MAS stellen diese für die Agenten bereit. Je nach Aufgabengebiet und Kommunikationspartnern sind die notwendigen Ontologien implizit gegeben und brauchen nicht formal (vom Computer auswertbar) definiert zu werden. 4.4.5 Vermittlung und Organisation durch Faciltiators Damit es zum Wissensaustausch zwischen zwei Agenten kommen kann, müssen sich die Kommunikationspartner adressieren können. Ein Agent, der der Allgemeinheit einen Dienst oder eine Information zur Verfügung stellen möchte oder bei der Suche nach einer Problemlösung auf fremde Hilfe angewiesen ist, verwendet dafür typischerweise eine Broadcast-Nachricht. Dieses „Rufen in den Wald“ kann jedoch zu einer erheblichen Belastung der Kommunikationsmedien und der Agenten führen. Zur Minderung des „information overload“ können so genannte Facilitator-Agenten eingesetzt werden. Diese Spezialagenten können dabei für jeweils eine Gruppe von Agenten, als Informations- und Service-Broker fungieren, oder bieten einen so genannten Matchmaker-Serviece an. Die Unterschiede dieser beiden Service-Typen sind aus Abbildung 4.11 zu entnehmen. 34 Lehre vom Wesen und von den Eigenschaften des Seienden, von den Seinsweisen und Seinsschichten, die zu zeigen hat, was allem Seienden als solchem gemeinsam ist.“ [Brockhaus 2005] Seite 62 Abbildung 4.11: Service Broker und Matchmaker [Klusch 2001] Jede Anfrage an einen Service-Broker oder Matchmaker wird mit den aktuell registrierten und verfügbaren Services verglichen. Sind Agenten verfügbar, die die Anfrage erfüllen können so liefert der Matchmaker eine Liste mit Namen und Dienstbeschreibungen dieser Agenten zurück. Die Auswahl und Kommunikation mit einem der in Frage kommenden Agenten obliegt nun dem anfragenden Agenten (Requester). Im Gegensatz dazu wird diese Auswahl und Kommunikation vom Broker gleich selbst erledigt, und der anfragende Agent erhält sofort ein entsprechendes Ergebnis. Beide Varianten bieten Vorteile, aber auch Nachteile. So können Broker zum Beispiel mit der Fähigkeit ausgestattet werden Übersetzungen zwischen verschiedenen Sprachdialekten vorzunehmen und Nachrichten zu bündeln oder zu splitten. Andererseits kann ein Broker aber durch den erhöhten Kommunikationsaufwand leicht zum „Flaschenhals“ werden. Der Matchmaker selbst kommt hingegen mit weniger Kommunikation aus, dies aber auf Kosten der zusätzlich notwendigen Kommunikation die der anfragende Agent durchführen muss, und damit auch auf Kosten des erhöhten Programmieraufwands für diesen Agenten. [Klusch 2001] Abbildung 4.12: Agenten in einem föderierten System [Fricke 2000] Durch die mittelbare, assistierte Kommunikation und die Zuordnung von Agenten zu Facilitators entsteht ein so genanntes föderiertes System, das in Abbildung 4.12 illustriert ist. Die Agenten geben ihre Autonomie zugunsten des sie vertretenden Vermittlers preis, Seite 63 Kapitel 4 Multiagentensysteme indem sie jenem ihre Fähigkeiten und Wünsche mitteilen. 4.4.6 Regeln der Kommunikation Damit eine vernünftige Kommunikation zwischen Agenten zustande kommt, ist es erforderlich, dass bei den Agenten überhaupt ein allgemeines Interesse am gegenseitigen Helfen besteht. Außerdem sollten sich die Agenten zumindest an die folgenden Regeln halten: [Schneeberger 2001b] Agenten müssen immer die Wahrheit sagen. ein Agent darf einen anderen Agenten nicht zwingen einen Dienst zu erfüllen, wenn dieser nicht vorher seine Bereitschaft dazu erklärt hat ein Agent ist an seine Zusage, einen bestimmten Dienst auf Anfrage zu erfüllen, gebunden. 4.5 Agentenarchitekturen In Kapitel 2 wurden Fähigkeiten und Eigenschaften von Agenten beschrieben. Soweit es sich hierbei um generische Fähigkeiten handelt, ist es wenig sinnvoll, sie zum Gegenstand der Agentenprogrammierung zu machen. Vielmehr sollte eine „Agentenprogrammiersprache“ oder „Agentenentwicklungsumgebung“ derartige „agentische“ Eigenschaften automatisch bereitstellen, um so den Programmieraufwand zu verringern. Diesem Zweck dienen die so genannten Agentenarchitekturen, die in diesem Abschnitt behandelt werden. Eine Agentenarchitektur ist laut Maes eine Methodologie für die Programmierung von Agenten: „[…] beschreibt die Zerlegung eines Agenten in eine Menge von Komponenten und deren Interaktion miteinander. Diese Beschreibung muss die Antwort darauf geben, wie Sensordaten und der momentane interne Status eines Agenten die zukünftigen Aktionen bestimmen und den zukünftigen internen Status des Agenten beeinflussen. Eine Agentenarchitektur verwendet Techniken und Algorithmen die diese Methodologie unterstützen.“35 [Maes 1995] Jörg Müller gibt auf die Frage was eine Agentenarchitektur ist in Müller 1998 folgende Antwort: „Das Herz eines Agenten ist seine Kontrollarchitektur, d.h. die Beschreibung seiner funktionalen Komponenten und ihres Zusammenspiels.“ Müller 1998 Eine Agentenarchitektur beschreibt demnach den strukturellen Aufbau eines Agenten durch eine Menge von Komponenten und definiert den Informationsfluss zwischen diesen. In den Komponenten sind die in Kapitel 2 behandelten Fähigkeiten zu finden. „It specifies how ... the agent can be decomposed into the construction of a set of component modules and how these modules should be made to interact. The total set of modules and their interactions has to provide an answer to the question of how the sensor data and the current internal state of an agent determine the actions ... and future internal state of the agent. An architecture encompases techniques and algoithms that support this methodology”. [Maes 1995] 35 Seite 64 Durch die vorgegebene Informationsspeicherung und -verarbeitung ist gleichzeitig die Programmierschnittstelle festgelegt. In der Praxis treten drei unterschiedliche Strukturvarianten auf: komponentenbasierte, geschichtete sowie strukturarme (reaktive) Architekturen. Diese drei Architekturen werden in den folgenden Unterkapiteln kurz behandelt. Im Wesentlichen stützen sich folgende Ausführungen auf [Fricke 2000]. 4.5.1 Komponentenarchitekturen Wenn unterschiedliche funktionale Komponenten vorliegen, spricht man von einer modularen Struktur. Modulare Zerlegung ist eine im Software Engineering weit verbreitete Methode des Systemdesigns. Bei einer Komponentenarchitektur realisiert jedes Modul eine Funktionalität und arbeitet typischerweise mit einem eigenen Datenmodell. Charakteristisch für derart strukturierte Agenten ist die Anwesenheit einer Kommunikationskomponente, über die der gesamte Nachrichtenverkehr abgewickelt wird. Häufig anzutreffen sind auch ein Reasoning-Modul, eine Komponente zur Steuerung und Ausführung der lokalen Fähigkeiten und eine Wissensbasis, die ein einheitliches Datenmodell für alle Komponenten bietet (siehe Abbildung 4-13). Abbildung 4.13: Prinzipieller Aufbau einer Komponentenarchitektur [Fricke 2000] Neben der Herausstellung unterschiedlicher Funktionalitäten wird bei diesem horizontalen Design auch der Daten- oder Kontrollfluss mit modelliert. Alle inputliefernden, d.h. vorgeschalteten Komponenten stellen Daten im vorgeschriebenen Format bereit. Die Daten werden entweder in eine komponenteneigene Wissensbasis eingetragen oder als Events in eine vorgesehene Input-Queue geschrieben. Derart als nebenläufiges Objekt gestaltet, kann jede Komponente in einem eigenen Prozess laufen und durch die Pufferung einkommender Daten auch simultan von mehreren vorgeschalteten Komponenten bedient werden. Komponenten, die diese Prozesseigenständigkeit nicht besitzen, müssen dagegen von außen direkt und synchron über ihre Funktionsschnittstelle aktiviert werden. 4.5.2 Geschichtete Architekturen Altenativ zur modulorientierten Sicht kann ein Agent auch in unterschiedliche Ebenen Seite 65 Kapitel 4 Multiagentensysteme der Wissensverarbeitung hierarchisch zerlegt werden (siehe. Abbildung 4.14). Ein Agent besteht dann aus einer Menge übereinander liegender Schichten (Layers), die, mit zunehmender Höhe, immer komplexere Aufgaben übernehmen. Gemäß dem Modell der verschiedenen Wissensarten bietet sich eine Unterteilung in die vier Abstraktionsschichten physical level, symbol level, knowledge level und social level an. Auf jeder Ebene befinden sich Methoden zur Verarbeitung des dort verwalteten Wissens. Mit zunehmender Abstraktion werden die Verarbeitungsmethoden mächtiger, aber auch komplexer. Findet auf der physikalischen Schicht ausschließlich sensorischer Austausch statt, so wird auf der darüberliegenden Ebene bereits Wissen repräsentiert und verarbeitet. Auf dem knowledge level ist die Rationalität angesiedelt; hier werden Ziele verfolgt. Schließlich finden sich auf der sozialen Ebene Mechanismen für Kooperationen, soziale Normen usw. Der Informationsfluss geht von unten nach oben. Wahrnehmungen gelangen über die physikalische Ebene in den Agenten. Jede Ebene funktioniert dabei als Filter, indem sie alle diejenigen Informationen verarbeitet, für die sie konzipiert ist und die nicht verarbeitbaren an die nächst höhere Schicht weiterleitet. Zum Beispiel wird übermitteltes Wissen von der symbolischen Ebene abgespeichert, während Sprechakte, die Bestandteil eines Kooperationsprotokolls sind, bis in die oberste Ebene durchgereicht werden. Entsprechend besitzt jede Schicht ihre eigene Wissensbasis mit assoziierten wissensverarbeitenden Methoden. Abbildung 4.14: Prinzipieller Aufbau einer Schichtstruktur [Fricke 2000] In entgegengesetzter Richtung zum Informationsfluss findet die Kontrolle statt, weil jede Schicht zur Realisierung der Konsequenzen ihrer Wissensverarbeitungsmechanismen Fähigkeiten der darunterliegenden Ebenen benötigt. So arbeitet der knowledge-level direkt auf den Repräsentationen der Symbolebene, während für das Aussenden eines Sprechakts aus einem Kooperationsprotokoll heraus sowohl die symbolische Ebene zur Repräsentation des Nachrichteninhalts wie auch die physikalische Schicht für das Sendeprotokoll benötigt wird. Seite 66 4.5.3 Reaktive Architekturen Geschichtete und komponentenartige Architekturen haben gemeinsam, dass sie Agenten als Informationsverarbeiter modellieren. Für beide Ansätze ist die interne Repräsentation eines Welt- oder Wissensmodells charakteristisch. Als Antwort auf die oft problembehaftete Wissensrepräsentation wurden rein reaktive Agentenarchitekturen entwickelt, die ohne ein Modell der Umwelt funktionieren, da die Agenten direkt in der Welt verankert sind. Reaktive Agenten können immer nur auf ihre derzeitigen Sensordaten reagieren und sind somit nicht in der Lage etwas zu lernen. (Wenn man Lernen als Anpassen der inneren Struktur sieht, die ihrerseits den Ablauf weiterer Aktionen entscheidet). Eine planende Struktur ist ebenfalls nicht zu verwirklichen, da ein Plan wesentlich von einem Weltmodell abhängt. Die Wahrnehmung der Umwelt erfolgt über Reiz- oder Signal-empfangende Sensoren. Die Verarbeitung findet üblicherweise durch einen einheitlichen, einfachen Mechanismus statt, der sämtliche Wahrnehmungen direkt, d.h. ohne eine Klassifikation oder symbolische Repräsentation vorzunehmen, verarbeitet (siehe. Abbildung 4.15). Möglichkeiten für derart uniforme Mechanismen auf Signalebene bieten Zustandsautomaten, stimulus-response-artige Produktionssysteme oder konkurrierende Kompetenzmodule. Abbildung 4.15: Strukturarmer Aufbau einer Agentenarchitektur [Fricke 2000] Prominentester Vertreter dieser Art von Architekturen ist die SubsumptionArchitektur, die aus einem fest verschalteten Netzwerk endlicher Automaten besteht. Die Automaten verarbeiten einfache Signale, die entweder direkt von Sensoren stammen oder Ausgangssignale anderer Automaten sind. Überschreitet das anliegende Signal einen Schwellenwert, wird das Verhaltensmuster des Automaten aktiviert. Resultat ist wiederum ein Signal, das an anliegende Zustandsautomaten oder Handlungen auslösende Actuators geschickt wird. Diese Art der Informationsverarbeitung ähnelt stark den neuronalen Netzen. Ähnlich wie dort ist außerdem eine Schichtenstrukturierung gegeben, wobei höhere Schichten tiefer liegende Ebenen durch Unterdrückungsregeln steuern können. 4.6 Standardisierungsbemühungen Agenten, die in abgeschlossenen Welten unabhängig voneinander für sich existieren, Seite 67 Kapitel 4 Multiagentensysteme können keinen besonderen Vorteil aus Normierungen ziehen. Im Gegensatz dazu sind mobile Agenten sowie Agenten in offenen Multiagentenumgebungen auf Standards angewiesen, um einen sinnvollen Wissensaustausch untereinander zu vollziehen. Im Folgenden werden die wichtigsten Bemühungen in diesem Bereich kurz vorgestellt. 4.6.1 Knowledge Sharing Effort Der Anfang der 90er Jahre gegründete Knowledge Sharing Effort (KSE) ist eine Initiative von Firmen und Universitäten die Entwicklung von Konventionen und Techniken zum Aufbau großer Wissensbasen, deren Inhalte untereinander austauschbar und wieder verwendbar sind als Ziel gesetzt hat. 4.6.2 FIPA Im Gegensatz zum KSE, der sich nur indirekt mit agentenspezifischen Fragen beschäftigt, wurde die „Foundation for Intelligent Physical Agents“ (FIPA) ausschließlich mit dem Ziel des Erarbeitens von Richtlinien und Standards für die Entwicklung von Agenten gegründet. Auslöser für die Gründung war die Erkenntnis, dass bestimmte Agententechnologien ein fortgeschrittenes Stadium erreicht haben, jedoch nur durch Standards nutzbringend eingesetzt werden können. Deshalb sieht die FIPA ihre Aufgabe in der Definition von Schnittstellen der verschiedenen Komponenten in der Umwelt eines Agenten, mit denen er interagiert. Dazu gehören Menschen, andere Agenten, Software allgemein, sowie die physische Welt. Die FIPA ist bemüht, mit ihrem teilweise hierarchischen Gerüst von Spezifikationen alle relevanten Einsatzgebiete für Agenten und das daran beteiligte Umfeld zu standardisieren. 4.6.3 Agent Society Neben der FIPA existiert ein weiterer Zusammenschluss von Firmen und Universitäten zur Unterstützung von Agententechnologien – die Agent Society. Ihr Ziel ist die Förderung und Koordination neuer Entwicklungen auf dem Gebiet der Agentensysteme sowie damit verbundener Technologien. Das sich daraus ergebende Tätigkeitsfeld beinhaltet z.B. Sammeln und Publizieren von Informationen zu Agententechnologien, -anwendungen und –märkten, Vermarkten der Produkte, Fördern von Standards sowie von Technologietransfer zwischen Entwicklung und Industrie. 4.6.4 Object Management Group Die OMG liefert mit ihren Spezifikationen für verteilte Objekte wie CORBA und IIOP eine wichtige Grundlage, um agentenspezifische Protokolle und Anwendungen zu entwickeln, die eine netzwerkweite Kommunikation und Mobilität ermöglichen. Seite 68 4.7 Zusammenfassung Kommunikation ist bei Softwareagenten weitgehend gleichbedeutend mit der Fähigkeit zum Senden und Empfangen von Sprechakten. Zwar benötigt ein Agent häufig auch „klassische“ Kommunikationsformen, um beispielsweise mit konventioneller Software zu interagieren, diese Sprachen und Protokolle sind jedoch nicht Gegenstand der Agentenkommunikation. Die Haupttriebkraft bei der Gestaltung von Agentenkommunikationssprachen liegt dabei in der Anforderung, Agentensysteme offen zu gestalten. Eine wichtige Anforderung an verteilte Systeme ist das koordinierte Handeln der einzelnen Glieder. In Agentensystemen sind diese Glieder weitgehend autonom, so dass Koordination per Systemdesign schwierig zu erreichen ist. Daher kommen unterschiedliche Techniken zur dynamischen Koordinierung zur Anwendung: Abgestimmtes Handeln zwischen mehreren Agenten findet zumeist in Form von Interaktionsprotokollen statt. Die Agentenarchitektur beschreibt Aufbau und Funktionsweise eines einzelnen Agenten. Von ihr bereitgestellte generische Funktionalitäten im Bereich der Informationsfilterung, -speicherung und -verarbeitung bilden die „architectural commitments“, welche die Verwendungsmöglichkeiten der Architektur einschränken. Entsprechend den vielen möglichen Anforderungen in Bezug auf die Aufgabenstellungen und Ausprägungen der Einsatzumgebung existieren zahlreiche Architekturen mit unterschiedlichen Schwerpunkten. Agenten, die in abgeschlossenen Welten unabhängig voneinander für sich existieren, können keinen besonderen Vorteil aus Normierungen ziehen. Anders ist dies bei mobilen Agenten und Agenten in offenen Multiagentenumgebungen. Sie sind auf Standards angewiesen, um einen sinnvollen Wissensaustausch untereinander zu vollziehen. Nach Meinung des Autors dieser Arbeit ist die FIPA (Foundation for Intelligent Physical Agents) die derzeit aktivste Initiative in dieser Richtung. Seite 69 Gestaltungsbereich Kapitel 4 Multiagentensysteme Seite 70 Mit den aus dem Untersuchungsbereich gewonnen Erkenntnissen wird nun versucht eine Agenten Plattform zu spezifizieren und in weiterer Folge ein Prototyp implementiert. Es sei an dieser Stelle angemerkt, dass dies in Zusammenarbeit mit Stefan Kernbauer, ebenfalls Diplomand am IICM bewerkstelligt wurde. Aus diesem Grund weist das folgende Kapitel 5 größere Gemeinsamkeiten zu der Diplomarbeit von Stefan Kernbauer [Kernbauer 1999] auf. Die darauf folgenden Kapitel sind jedoch von dieser Arbeit weitgehend unabhängig. Kapitel 5 5 SMART - Sophisticated Mobile Agent Repository 5.1 Motivation Vor allem die in Kapitel 3 des Untersuchungsbereichs identifizierten Probleme bei der Informationserschließung im Web, und der Lösungsansatz mittels kooperativen Agenten, der ebenfalls in Kapitel 3 vorgestellt wurde bilden nun die Motivation dafür eine Agenten Plattform zu spezifizieren und prototypisch zu implementieren. Informationsagenten die in dieser Plattform agieren könnten Aufgaben wie das Identifizieren von relevanten Informationsangeboten, das Filtern und Klassifizieren von Informationsangeboten sowie die benutzerfreundliche Aufbereitung der Ergebnisse übernehmen, und so den Benutzer stark entlasten. Für die Verwaltung und Koordination dieser Agenten wird aber eine gewisse Infrastruktur benötigt. Es muss eine Umgebung geschaffen werden, die sich streng nach außen abgrenzt und die Agenten innerhalb der Plattform unterstützt. Eine restriktive Abgrenzung der Umgebung ist aus mehreren Gründen notwendig. Zum einen können durch definierte Interfaces zum User und zu externen Systemen Sicherheitslücken eliminiert werden und zum anderen dürfen sich z.B. mobile Agenten nur in einem bestimmten Bereich frei bewegen. Niemals darf mobilen Software Agenten das gesamte Netz uneingeschränkt zur Verfügung gestellt werden, denn da sich Agenten mehrfach klonen können, würde sich sofort eine Überlastung des Netzes einstellen. Aus der Sicht des Users wird also ein Agentensystem benötigt, dass in seiner Gesamtheit Aufgaben übernehmen und Dienste verknüpfen kann. Für den User ist es vollkommen irrelevant wie viele Agenten für die Erfüllung der Aufgabe benötigt werden, und welche Prozesse und Strukturen nötig sind. Wichtig ist ein standardisiertes Userinterface, über das alle Funktionen zu erreichen sind und das intuitiv zu bedienen ist. In den Folgenden Unterkapiteln wird nun die Entwicklung und Konzeption eines solchen Agentensystems beschrieben. Seite 71 Kapitel 5 SMART 5.2 Anforderungen an ein Agentensystem Um die geforderte Funktionalität erfüllen zu können, werden an ein Agentensystem eine Reihe von grundsätzlichen Anforderungen gestellt. Diese sollen nachfolgend genauer erläutert werden. Verteiltes System: Ein Agentensystem sollte verteilt über mehrere Plattformen agieren. Der Aktionsbereich sollte eingeschränkt werden, doch sollten die Vorteile von Computernetzen genutzt werden. Über das Netz können Dienste und Ressourcen, die auf verschiedenen Rechnern angeboten werden, nutzbar gemacht werden. Agenten sollten auf verschiedenen Plattformen installierbar sein, somit ist ein gewisses Maß an Plattformunabhängigkeit gefordert. Erweiterbarkeit: Die Funktionalität des Agentensystems sollte jederzeit erweiterbar sein. Die Erweiterung und Anpassung stellt ein gewisses Sicherheitsrisiko dar (Installation von Computerviren) und sollte deshalb ein streng geregelter Vorgang sein. Komponententechnologie bietet sich an. Signierte Softwarekomponenten die nur von einem definierten Personenkreis installiert werden dürfen, würden etwaigem „Wildwuchs” des Systems vorbeugen. Administration und Kommunikation mit dem Benutzer: Benutzer wie auch Administratoren sollte ein graphisches Interface zur Verfügung gestellt werden, über welches sie mit dem System kommunizieren und Einstellungen vornehmen können. User und Administrator wird eine unterschiedliche Sicht des Systems ermöglicht. Der Zugriff des Users beschränkt sich auf dessen angeforderte Agenten, deren Nachrichten und Einstellungen. Ein Administrator kann auf das Gesamtsystem zugreifen. Ihm obliegt die Verwaltung der Userrechte, der Agenten und der Komponenten. Zugriff auf externe Systeme: Agenten sollten über das Agentensystem auf externe Systeme jeglicher Art zugreifen können. Webserver, Datenbanken und Dienste aller Art sollten für Agenten zugänglich sein, jedoch muss der Zugriff kontrolliert und auch protokolliert werden damit die Aktivitäten des Systems nachvollziehbar bleiben. Erreichbarkeit durch externe Systeme: Externe Agenten oder Programme sollten auf das Agentensystem zugreifen und mit den Agenten des Systems kommunizieren können. Benötigt wird ein Application Programming Interface (API) oder ein Gateway zur Agentenkommunikation. Skalierbarkeit: Das Agentensystem sollte auf das Ausmaß der Nutzung angepasst werden können. Es sollte möglich sein, immer wieder neue Rechner in das System einzubinden, wodurch Rechenleistung und Speicher stets an den Nutzungsgrad angepasst werden können. Security: Der Zugriff auf das System sollte durch Userrechte geregelt werden. So haben Benutzer nur eine beschränkte Sicht auf das System und kaum Manipulationsmöglichkeiten. Nur Administratoren haben einen vollständigen Zugriff auf das System und nur ihnen ist es erlaubt Software in das System zu installieren. Durch diesen Ansatz kann ein hohes Maß an Sicherheit erreicht werden. Logging: Alle Aktivitäten des Systems und der Agenten sollten mitprotokolliert werden. Durch Log-Files erreicht das System eine größtmögliche Transparenz. Verwaltung von Agenten: Damit Agenten ihre Aufgabe erledigen können, benötigen sie eine „Infrastruktur”. Software Agenten sollten sich im System frei bewegen, auf Daten zugreifen und mit anderen Agenten kommunizieren können. Auch werden Seite 72 Agenten durch das System überwacht, gestartet, gestoppt oder gelöscht. Benutzer müssen Agenten bewerten können, denn nur durch Feedback kann sich das System verändern und verbessern. Daher müssen Möglichkeiten geschaffen werden, Agenten zu speichern und zu bewerten. User Management: Benutzer haben im Agentensystem nur sehr beschränkte Rechte. Diese Rechte und auch die Daten der User müssen verwaltet werden. Das System ermöglicht das Anlegen eines Benutzers, das Editieren von Benutzerdaten und das Löschen des Users. Sinnvollerweise müsste für jeden User ein Homeverzeichnis angelegt werden, in dem seine Benutzerdaten gespeichert werden. Verstehen von User-Anfragen: Benutzer sollten mittels Anfragen Aufgaben formulieren können, die durch die Agenten des Systems erledigt werden. Hiezu ist es nötig, dass das System die Anfragen versteht. Adaptives Verhalten bzw. Lernfähigkeit ist gefordert. Komponenten: Agenten sollten aus Komponenten bestehen, die nach Bedarf kombiniert werden können. Kombinationen, die sich im System bewähren, werden öfter verwendet als erfolglose Kombinationen. Um dieses Ranking zu ermöglichen, müssen Kombinationen mit ihren Bewertungen gespeichert werden. Agentenkommunikation: Software Agenten müssen untereinander und auch mit systemfremden Agenten kommunizieren können, um Informationen auszutauschen und Aktivitäten zu koordinieren. Für die Kommunikation bieten sich Agentensprachen wie KQML oder FIPA-ACL an. Pro-Aktives Verhalten: Software Agenten sollten pro-aktiv und autonom agieren d.h. Sie setzen von sich aus Aktivitäten und treffen Entscheidungen. Pro-Aktives Verhalten kann nur erreicht werden, wenn für jeden Agenten mindestens ein Prozess (Thread) gestartet wird. Persistenz und Serialisierbarkeit: Um Software Agenten frei im System bewegen zu können, müssen sie serialisierbar sein, d.h. sie müssen ihren Zustand persistent in einen Stream speichern können. Auch muss der Status des Gesamtsystems gespeichert werden können, um vor Netz- bzw. Rechnerausfällen sicher zu sein. 5.3 SMART Philosophie Das SMART (Sophisticated Mobile Agent Repository Technology) System, ist ein Agentensystem, das aus mobilen und statischen Agenten besteht. Die Agenten besitzen eine in sich abgeschlossene Funktionalität (starke Kapselung). Sowohl die Agenten, als auch das Gesamtsystem soll sich an den Benutzer und an die Umgebung anpassen. Das SMART System ist ein verteiltes System, das plattformübergreifend agiert. Im Gesamtsystem wird konsequent auf Komponententechnologie gesetzt, wodurch das System offen und erweiterbar bleibt. SMART-Agenten können eigenständig im Auftrag des Benutzers agieren und untereinander kommunizieren. Die Kommunikation mit externen Agenten wird über eine genormte Schnittstelle ermöglicht (FIPA-Foundation for Intelligent Phyisical Agents). Das zentrale Element des SMART-Systems ist eine verteilte Agentenplattform. Diese Plattform schafft eine Runtime-Umgebung für SMART-Agenten. In dieser Plattform werden Agenten verwaltet, sie bildet die Schnittstelle zu externen Systemen und verwaltet Useranfragen. Im Wesentlichen besteht die Plattform aus einer Struktur (Dino-Struktur) über die Agenten und externe Systeme (WWW, Hyperwave Server, Datenbanken, xFIND, etc.) adressiert werden können. Neben Seite 73 Kapitel 5 SMART den Agenten befinden sich auf der Plattform Servicekomponenten, die die Kommunikation mit dem User (Thesaurus) und die Zusammenarbeit von Agenten erleichtern sollen. Die Agentenplattform läuft als Serverprozess auf einem Host. Plattformen auf verschiedenen Hosts können zu einer gemeinsamen Plattform vereinigt werden und es entsteht dadurch ein verteiltes System. Jeder Agent im System besitzt einen eigenen Thread, dadurch laufen sie selbständig und können jederzeit gestoppt werden. Strukturell bestehen Agenten aus Komponenten, aus denen sie zur Laufzeit zusammengefügt werden. Das Zusammenfügen der Agenten wird durch User-Anfragen initiiert. Wird ein Agent für eine bestimmte Aufgabe benötigt so versucht das System passende Komponenten zu finden. Diese Komponenten werden dann automatisch zu einem Agenten kombiniert. Wird ein Agent nicht mehr benötigt so löst er sich wieder auf. Agenten werden zusätzlich durch den User bewertet, wodurch die betroffenen Komponenten ein Ranking erfahren. Das Ranking beeinflusst die Auswahl der Komponenten. So werden erfolgreiche Komponenten öfter ausgewählt als erfolglose. Der User kommuniziert mit dem System über einen eigenen User-Agenten. Der UserAgent ist auf dem Rechner des Anwenders installiert und stellt dem Anwender ein graphisches Interface zur Verfügung, über das er Anfragen in natürlicher Sprache (einfache Sätze, getrennte Eingabe von Verb, Subjekt und Objekt) stellen kann. Nach Eingabe der Anfrage wird eine Verbindung mit der Agentenplattform hergestellt. Das System versucht unter Verwendung eines Thesaurus die Anfrage zu verstehen und passende Komponenten zu finden, die die Anfrage erfüllen können. Wurden Komponenten gefunden, so werden diese zu einem Agent kombiniert und der Agent tritt mit dem Benutzer in Kontakt. Über ein graphisches Interface wird der Agent konfiguriert und dieser nimmt seine Tätigkeit auf. Nach Erledigung der Aufgabe kann der Agent vom Benutzer bewertet werden. Die Bewertung beeinflusst wiederum die zukünftige Auswahl der Komponenten. Verwaltet und konfiguriert wird das Gesamtsystem über ein eigenes Administratorinterface. Ein Administrator kann Benutzerrechte verwalten, Agenten überwachen und Komponenten einspielen. Durch den Komponentenansatz bleibt das System erweiterbar und flexibel. Werden neue Komponenten eingebracht können Agenten mit neuen Fähigkeiten ausgestattet werden. Komponenten, die nicht mehr benötigt werden, können aus dem System entfernt werden. Auch die Anzahl der Agenten richtet sich nach der Art der Anfragen. Wird an das System mehrmals eine bestimmte Anfrage gestellt, so werden einfach mehr Agenten für dieses Thema erzeugt. Daher unterliegen die Fähigkeiten des Gesamtsystems und auch die Aufgaben mit dem sich das System beschäftigt einem ständigen Wandel. Die Aufteilung der Funktionalität auf unabhängige Einzelkomponenten steigert auch die Fehlertoleranz des Systems. Durch eine instabile Komponente wird die Stabilität des Gesamtsystems nicht gefährdet. Schlimmstenfalls wird nur der betroffene Agent in Mitleidenschaft gezogen und kann durch den Administrator gestoppt werden. Die Erweiterbarkeit und Zugriffsmöglichkeiten im System sind streng geregelt. Interfaces auf externe Systeme werden über die Agentenplattform ermöglicht (Dino). So können selbst Agenten nur über diese Schnittstellen mit der „Außenwelt” kommunizieren. Eigene Security Manager regeln streng das Ausmaß des Zugriffs. Die grundsätzliche Struktur ist in Abbildung 5.1 dargestellt. Seite 74 Abbildung 5.1: Das SMART Agentensystem [Kernbauer 1999] 5.4 Bausteine zur Entwicklung eines Agentensystems Entscheidend für die erfolgreiche Entwicklung eines Agentensystems ist die Wahl der richtigen Hilfsmittel und Frameworks. Für die Entwicklung von SMART fiel die Wahl auf die Programmiersprache Java und auf das am IICM Graz entwickelte Framework Dino. Sowohl Java als auch Dino erleichtern die plattformübergreifende Kooperation von Software. Von verschiedensten Organisationen wurden bereits Software Agenten und Agentensysteme entwickelt. Für den praktischen Einsatz ist die Kooperation dieser Systeme sinnvoll, es fehlt jedoch an Standards und definierten Schnittstellen. FIPA (Foundation for Intelligent Physical Agents) versucht seit einigen Jahren einen Standard für Agentensysteme und Agentenkommunikation zu spezifizieren. Um zu anderen Systemen offen zu bleiben, wurde auch für das SMART System ein FIPA Gateway konzipiert. 5.4.1 Java Die Programmiersprache Java bietet einige Besonderheiten, die die Entwicklung von mobilen Software-Agenten begünstigen. Auf diese Besonderheiten soll im Folgenden näher eingegangen werden. Plattformunabhängigkeit: Durch die Programmiersprache Java wurde ein “Write Once, Run Anywhere” Konzept verwirklicht. Java Sourcecode wird durch den Compiler nicht in lauffähigen Maschinencode übersetzt, sondern es entsteht ein Seite 75 Kapitel 5 SMART Bytecode der von einem virtuellen Computer (Java Virtual Machine) interpretiert wird. Die Virtual Machine ist für verschiedenste Plattformen erhältlich und selbst in Web Browsern eingebaut. Die Virtual Machine bietet stets dieselben Schnittstellen, wodurch Java Programme auf verschiedenen Plattformen ausgeführt werden können. Persistenz: Für mobile Software Agenten ist es notwendig, dass sie mit ihrem Status in eine Form umgewandelt werden, die problemlos über das Netz transportiert werden kann. Java Objekte können durch einen speziellen Mechanismus (Serialize) mit ihrem Status in Bytecode umgewandelt werden, der auf einem Stream über das Netz transportiert wird. Am Ziel können aus dem Stream die Objekte wieder rekonstruiert werden. Durch den Serialisier-Mechanismus kann Objekten Persistenz verliehen werden, wodurch sie auch nach Systemabstürzen und anderen undefinierten Zuständen wieder rekonstruiert werden können. Netzwerkfähigkeit: Java unterstützt die Programmierung von Sockets und URL (Uniform Resource Location) Kommunikation. Über RMI (Remote Method Invocation) kann auf verteilte Objekte zugegriffen werden. Classloading: Der Java Classloading Mechanismus kann erweitert werden, wodurch Java Klassen nicht nur aus dem Java Classpath sondern auch über das Netzwerk nachgeladen werden können. Ein spezialiserter Classloader kann Klassen vom Java Classpath, von einer URL oder vom Objektstream nachladen (Nicht nur die Java Objekte, auch die dazugehörigen Klassen können auf einen Stream serialisiert werden). 5.4.2 Dino Abbildung 5.2: Die Dino Struktur [Dino 1998] Dino (Distributed Interactive Network Objects) ermöglicht eine virtuelle Sicht auf einen heterogenen Informationsraum. Die Elemente des Informationsraums können aus Daten oder auch aus Programmen bestehen und werden durch Knoten in einem virtuellen Verzeichnisbaum repräsentiert. Die Struktur des Baumes ähnelt einem Unix Verzeichnisbaum, wodurch auch eine Adressierung und Navigation im Unix Stil möglich ist. Durch den Aufbau wurde der Zugriff auf Elemente des Informationsraums Seite 76 standardisiert. Der Benutzer wendet stets das gleiche Schema an, egal ob auf Daten lokal oder remote zugegriffen wird. Abbildung 5.2 zeigt einen Dino Adressraum, in den über einen Mounter ein externes System eingebunden wird. Dino zeichnet sich durch eine Reihe von Eigenschaften aus: Plattformunabhängigkeit: Dino wurde vollständig in Java implementiert, wodurch ein hohes Maß an Plattformunabhängigkeit erreicht wurde. Verteilte Objekte: Sowohl aktive Inhalte (Programme, Objekte), als auch passive Inhalte (Daten, Meta-Daten) können über den Dino Adressraum erreicht werden. Java Objekte können über einen Object-Wrapper im Dino Adressraum angesprochen werden. Erweiterbarkeit: Die Dino Middleware kann an die jeweilige Situation und Anwendung angepasst werden. Skalierbarkeit: Die Anzahl von eingebetteten Servern und Knoten kann beliebig groß werden. Sicherheit: Benutzerzugriffe werden auf Knotenebene geregelt. Durch die enge Integration von Java-Sicherheitsmechanismen wird ein größtmögliches Maß an Sicherheit erreicht. Implementieren Java Objekte ein spezielles Interface (LogicalContext), so können sie in den Dino Adressraum eingebunden werden. Auf die Objekte kann sowohl lokal als auch remote über Wrapper (LogicalContextWrapper) zugegriffen werden. Das graphische Interface der Objekte wird gesondert abgelegt und kann als „Service” vom Dino Knoten angefordert werden. Sind diese Objekt zusätzlich noch serialisierbar (Serializeable), so können sie im Dino Adressraum durch einen einfachen Copy oder Move Befehl verschoben werden. Bei diesen Operationen ist es irrelevant wie viele Plattformgrenzen übersprungen werden. Somit reduziert sich das Bewegen eines Software Agenten zwischen 2 Plattformen auf einen einfachen Move Befehl. 5.4.3 FIPA Abbildung 5.3 zeigt das FIPA Referenzmodell in dem FIPA Agenten existieren und agieren können. Es entsteht eine Agenten Plattform (AP), die aus einigen zentralen Komponenten besteht, und die als „Lebensraum” von Software Agenten dient. Ein Agent Management System (AMS) kümmert sich um die Verwaltung von Agenten, ein Directory Facilitator (DF) stellt einen „Yellow Pages“ Dienst zur Verfügung und ein Agent Communication Channel (ACC) kümmert sich um die externe Kommunikation der Plattform. Grundsätzlich sind alle Grundkomponenten einer FIPA Agenten Plattform als Agenten spezifiziert. Seite 77 Kapitel 5 SMART Abbildung 5.3: Das FIPA Referenzmodell [Fipa 1997] 5.5 Das SMART System Das SMART System bildet ein verteiltes Agentensystem. Das System schafft eine Umgebung, die die, von Software Agenten benötigte, Infrastruktur aufbaut. In dieser Umgebung können Software Agenten agieren und untereinander kooperieren. Natürlich beinhaltet das SMART System auch alle Mechanismen um Agenten und die, von ihnen benötigten, Ressourcen zu verwalten. Technisch stützt sich das SMART System auf das Dino Framework, bzw. stellt eine Anwendung von Dino dar. Durch Dino wird die Adressierung und die Interaktion der verschiedenen Module, Agenten und Komponenten möglich. Durch die Dino-Technologie können Ressourcen jeglicher Art in das System eingebunden werden, wodurch diese Ressourcen für Agenten zugänglich werden. Dino relativiert Plattform- und Systemgrenzen und ermöglicht die Interaktion der Komponenten über eben diese Grenzen. Letztlich kümmert sich Dino auch um Sicherheitsfragen und verwaltet User-Rechte. Das SMART System besteht aus mindestens einer SMART Plattform. Diese Agentenplattform läuft als Serverprozess auf einem bestimmten Host. Durch Dino können Plattformen auf verschiedenen Hosts zu einer gemeinsamen Plattform vereinigt werden, wodurch eine große, verteilte SMART Plattform entsteht. Die verteilte SMART Plattform bildet nach außen hin ein abgeschlossenes System, auf das nur über definierte Schnittstellen zugegriffen werden kann. Benutzer verwenden zur Interaktion mit dem System einen User Interface Agenten, der auf dem Rechner des Benutzers installiert ist. Der User Interface Agent verbindet sich bei Bedarf mit dem System und ermöglicht die Kommunikation mit internen Agenten. Neben den „normalen” Benutzern haben noch zwei weitere Usergruppen Zugriff auf das System, nämlich Administratoren und externe Agenten. Administratoren können über ein eigenes Administrations Tool das System Seite 78 verwalten. Externe Agenten kommunizieren über ein Gateway mit der Plattform. Der grundsätzliche Aufbau des SMART Systems ist in Abbildung 5.4 dargestellt. Abbildung 5.4: Das SMART Agentensystem [Kernbauer 1999] Jede Teilplattform des Gesamtsystems wird dezentral verwaltet. Benutzer sind nur auf einer Teilplattform registriert, die dann als Heimatplattform des Benutzers und der vom Benutzer angeforderten Agenten fungiert. Für jede Plattform ist mindestens ein Administrator verantwortlich. Da die Agenten der Plattformen des SMART Systems eng zusammenarbeiten und sich die Agenten zwischen den Plattformen bewegen können, ist eine transparente Struktur notwendig. Sinnvoll ist eine Verknüpfung der Plattformen mittels einer gemeinsamen Root-Plattform. Durch diese logische Anordnung befinden sich die einzelnen Plattformen im Adressraum auf einer gemeinsamen Ebene und sind dadurch einfach zu erreichen. Eine Gruppierung der Plattformen kann durch einen hierarchischen Aufbau der Root-Plattform erreicht werden. Durch diesen Ansatz ist es möglich „Domains” einzuführen. Grundsätzlich kann jede Plattform eine andere Plattform über die gemeinsame Root erreichen und es entsteht dadurch eine gemeinsame verteilte Plattform, das SMART System. 5.6 Die SMART Plattform In der Konzeption wurde versucht, bewährte Ansätze des objektorientierten Designs Seite 79 Kapitel 5 SMART konsequent umzusetzen. So ist die Plattform nach einem Schichtenmodell aufgebaut. User Interface Agent, Admin Tool und FIPA-Gateway sind in der obersten Schicht angeordnet, die Agenten in einer mittleren Schicht, die Dino Struktur darunter und in einer letzten Schicht sind sämtliche Ressourcen vereinigt. Ein weiteres zentrales Konzept ist die strenge Kapselung der einzelnen Module. Jedes Modul hat ein streng definiertes Aufgabenfeld, grenzt sich von anderen Modulen deutlich ab und wird dadurch austauschbar. Wichtige Aufgaben im System werden von so genannten „Managern” übernommen. Sie kontrollieren, steuern und verwalten das System. Teilweise übernehmen Manager ein komplexes Aufgabenfeld und können auch als „Agenten” bezeichnet werden. Jedoch müssen sie nicht immer aktiv im System agieren und benötigen dadurch nicht immer einen eigenen Prozess. Zusätzlich werden sie permanent im System installiert und dürfen während der Laufzeit der SMART Plattform nicht mehr deinstalliert werden. Da Manager zentrale Aufgaben im System übernehmen, würde eine Veränderung der Konstellation die Stabilität des Systems gefährden. In diesen Eigenschaften unterscheiden sie sich deutlich von so genannten „SAgenten”. SAgenten (User Agenten, System Agenten, Staff Agenten) ermöglichen die dynamische Funktionalität des Systems. Sie können zur Laufzeit je nach Bedarf installiert und deinstalliert werden. SAgenten bestehen aus Komponenten, die unter bestimmten Einschränkungen frei kombinierbar sind (Nur bestimmte Typen von Komponenten sind kombinierbar). So ist es möglich, dass neue Agenten im System erstellt und zur Probe eingesetzt werden. Bewähren sich die Agenten, dann werden sie öfters angefordert, andernfalls werden sie aus dem System wieder entfernt. Sowohl die Kombination, als auch die Installation und Deinstallation erfolgt im System automatisch. Alle SAgenten im System erhalten einen eigenen Prozess und können dadurch aktiv („Pro-Aktiv”) ihre Aufgaben durchführen. „Handler” und „Assistants” bilden die dritte große Gruppe der SMART Plattform. Sie sind meist für die Verwaltung und den Zugriff auf Ressourcen verantwortlich. Die Ressourcen werden ebenfalls in zwei Gruppen unterteilt. Man unterscheidet Systemdaten und allgemeine Ressourcen. Zu den Systemdaten zählen sämtliche Konfigurationsdateien (User Data, etc.) und Datenbanken (Agentbase, Componentbase, etc.) die vom SMART System benötigt werden um stabile Funktionalität zu gewährleisten. Zu den allgemeinen Ressourcen zählen externe Daten, wie z.B. HTTP Server, Hyperwave Server, FTP Server usw. Diese externen Daten können von Agenten angefordert werden, worauf sie, sofern Rechte und Ressourcen vorhanden, mit dem SMART System verbunden werden. Sobald die Daten verbunden wurden, kann über einen allgemeinen Dino Handle auf sie zugegriffen werden. 5.6.1 Kurzbeschreibung der Module Die wichtigsten Module einer SMART Plattform sind in Abbildung 5.5 dargestellt. Jedes Modul ist für definierte Teilaufgaben verantwortlich. Diese Teilaufgaben werden hier nun kurz zusammengefasst: User Interface Agent (1) Über den User Interface Agent kommuniziert der Benutzer mit dem System. Es wird ein graphisches Interface bereitgestellt. Zusätzlich dient das graphische Interface als Basis Frame auf dem die graphischen Interfaces der Agenten dargestellt werden. Somit kann der Benutzer „seine” angeforderten Agenten direkt konfigurieren und verwalten. Seite 80 Admin Tool (2) Über das Admin Tool kann ein Benutzer mit Administratorrechten die SMART Plattform verwalten. Sowohl Agenten, Komponenten, Thesaurus und Userdaten können verwaltet und verändert werden. FIPA Gateway (3) Das FIPA Gateway ist für das Routing von FIPA-ACL Nachrichten in das SMART System bzw. aus dem SMART System verantwortlich. User Assistant (4) Loggt sich ein Benutzer in die SMART Plattform ein, so wird für ihn ein User Assistent instanziert. Dieser hat die Aufgabe die Verwaltung von User Daten und User Profilen zu erleichtern. Zusätzlich speichert der User Assistent die Handles aller, vom jeweiligen Benutzer angeforderten, Agenten. Agent Finder (5) Formuliert ein Benutzer eine Aufgabe so wird eine Anfrage an den Agent Finder gesendet. Der Agent Finder stellt dafür ein graphisches Interface zur Verfügung, das im User Interface Agent dargestellt wird. Der User hat die Möglichkeit die Aufgabe auf drei verschiedene Arten zu formulieren. Die Anfrage kann in Form eines natürlichen Satzes (Verb, Objekt, Subjekt), in Kategorien (Funktion, Resource, Mode..) oder durch einen boolschen Ausdruck ausgedrückt werden. Über einen Thesaurus wird versucht die Begriffe zu verstehen und über die Komponentendatenbank (Componentbase) oder Agentendatenbank (Agentbase) werden entsprechende Agenten gefunden. Service Factory (6) Im Dino System werden die graphischen Interfaces der Knoten separat gespeichert und verwaltet. Sie werden als „Services” bezeichnet. Die Service Factory ist eine zentrale Anlaufstelle im System, über die sämtliche Services, der im Dino System erreichbaren Knoten, angefordert werden können. Jedes Service besitzt einen Namen und steht mit einem bestimmten Knoten in Verbindung. Nach Angabe des Namens und des entsprechenden Handles wird das Service instantiiert und die Instanz wird an den „Kunden” weitergereicht. Als Kunden treten Sinnvollerweise Komponenten auf, die direkt mit dem User interagieren (User Interface Agent, Admin Tool). System Manager (7) Der System Manager kümmert sich um die Verwaltung der Ressourcen. Dadurch wird die Anzahl der laufenden Agenten kontrolliert. Der zur Verfügung stehende Speicher und die Rechenzeit wird verwaltet (Scheduling der Agenten, Starten und Stoppen der Agenten). External Agent Manager (8) Der External Agent Manager kümmert sich um die Verwaltung der Stellvertreter (External Agent Deputy) externer Agenten im SMART System. Jeder externe (nicht im SMART System) Agent erhält in der SMART Plattform einen Stellvertreter. Über diesen Stellvertreter können externe Agenten von internen angesprochen werden. Nachrichten werden über den Stellvertreter und über das FIPA Gateway zum externen Agenten geroutet. Seite 81 Kapitel 5 SMART Abbildung 5.5: Die SMART Plattform [Kernbauer 1999] Seite 82 User Manager (9) Der User Manager verwaltet die Benutzer und Administratoren des Systems (Anlegen und Löschen von Benutzern). Internal Agent Manager (10) Die Hauptaufgabe des Internal Agent Managers ist die Verwaltung der internen Agenten d.h. Agenten installieren (initialisieren) und Agenten löschen. Die „Lebenszeit” von Agenten wird überwacht und Konfigurationen von angeforderten Agenten werden in der Agentbase gespeichert. Assessment Manager (11) Der Assessment Manager ist für die Verwaltung von internen Agenten verantwortlich. Wird ein Agent vom Benutzer oder System bewertet so speichert der SAgent den aktuellen Wert. Die Bewertungen der einzelnen Agenten werden durch den Assessment Manager abgeholt und in die Agentbase gespeichert. Die Bewertungslogik im Assessment Manager und im SAgent kann als Plug-In global nachgeladen werden. Plug-In Handler (12) Bewertungsstrategien oder auch Kommunikationsprotokolle können in das System als Plug-In implementiert werden. Die installierbaren Plug-In’s werden durch den Plug-In Handler verwaltet. SAgent (13,14,15) SAgenten bilden die eigentliche Funktionalität des SMART Systems. Jegliche Funktion des Systems, abgesehen von Kontroll- und Verwaltungsaufgaben, werden durch SAgenten ermöglicht. SAgenten werden dynamisch auf Anfrage aus Komponenten zusammengefügt und automatisch aus dem System entfernt, wenn sie nicht mehr benötigt werden. Ein SAgent muss mindestens eine Komponente besitzen (funktionelle Komponente), die die zentrale Funktion des Agenten ermöglicht. Alle weiteren Komponenten erweitern diese Funktionalität (Zugriff auf Resourcen, Timer, etc.). Jedem SAgent wird ein eigener Thread zugewiesen. User Agenten, Staff Agenten und System Agenten besitzen einen identischen Grundaufbau jedoch unterscheiden sie sich in ihren Rechten und Funktionen. User Agenten agieren im Auftrag des Users, System Agenten übernehmen Systemaufgaben und Staff Agenten erledigen Dienste für andere Agenten. External Agent Deputy (16) Soll auf einen Agenten außerhalb des SMART Systems (kein SAgent) zugegriffen werden, so wird auf der Plattform ein Stellvertreter installiert. Über diesen Stellvertreter können externe Agenten so wie SAgenten angesprochen werden. Der External Agent Deputy bildet einen Wrapper und routet die Nachrichten zum externen Agenten weiter. Agentbase Handler (17) Wurden SAgenten erfolgreich im System installiert, so wird deren Beschreibung in der Agentbase gespeichert. Die Beschreibung enthält die Klassennamen der benötigten Komponenten (SDNA - SMART DNA), Meta Daten und den Wert der aktuellen Bewertung. Auf Grund dieser Bewertung entscheidet der Agentfinder über die Installation des beschriebenen Agenten. Componentbase Handler (18) SAgenten werden aus einzelnen Komponenten (SComponents) zusammengefügt. Die Beschreibungen der erreichbaren Komponenten werden in der Componentbase gespeichert. Diese Beschreibung definiert einen Typ und legt auch den Typ jener Komponenten fest, zu denen die Komponente kombinierbar ist. Logging Assistant (19) Der Logging Assistant ist eine zentrale Protokolleinheit. Wünscht eine Komponente das Protokollieren ihrer Tätigkeiten so übergibt sie die Seite 83 Kapitel 5 SMART Logfile Einträge dem Assistant. Der Assistant speichert die Einträge zentral in mehreren Logfiles. Directory Facilitator (20) Der Directory Facilitator ermöglicht einen „Yellow Pages” Dienst für installierte Agenten. Wird ein SAgent im System installiert, so wird ihm ein bestimmter Typ zugeordnet. Sucht nun ein SAgent einen Kommunikationspartner eines bestimmten Typs, so stellt er an den Directory Facilitator eine Anfrage. Dieser antwortet mit einer Liste der in Frage kommenden Agenten (die Handles der Agenten). Thesaurus (21) Der Thesaurus verwaltet sämtliche Begriffe, die vom System verstanden werden. Verknüpfungen zwischen den Begriffen werden geschaffen und wieder gelöst. Wird ein Begriff nicht verstanden, so wird der Benutzer aufgefordert Synonyme für diesen Begriff einzugeben. 5.7 SMART Konzepte Das SMART System zeichnet sich durch eine Reihe von Konzepten aus, die dem System Dynamik und Offenheit ermöglicht. Ein besonderes Merkmal von SMART ist dessen Anpassungsfähigkeit. Das System kann, je nach Anforderungen, seine Funktionalität verändern und stellt sich selbst auf neue Umweltbedingungen und Situationen ein. 5.7.1 SMART Agent (SAgent) Die wichtigsten Elemente des SMART Systems sind die SMART Agenten (SAgenten). Die SAgenten geben dem SMART System Funktionalität und Dynamik. Die vom User gestellten Aufgaben werden von SAgenten erfüllt und von ihnen ist die Qualität des Gesamtsystems abhängig. SAgenten agieren im SMART System, sie können ohne das System nicht existieren. SMART kümmert sich um die Verwaltung und Organisation der SAgenten. SMART Agenten sind sehr dynamische Elemente. Sie bestehen aus Komponenten die nach Bedarf kombiniert werden. Erst wenn SAgenten benötigt werden, werden sie erzeugt und installiert. Wird ihre Funktion nicht mehr benötigt, so werden sie automatisch aus dem System entfernt. Ihre Struktur und ihre spezielle Kombination geht jedoch niemals verloren, denn sie wird mit der Anfrage, die zu seiner Installation führte, in einer Datenbank gespeichert. Die Speicherung erfolgt in Form einer Beschreibung, die die Namen der Komponenten (SDNA - SMART DNA, in Anlehnung an das biologische Vorbild), die Anfrage, eine Bewertung und diverse Meta-Daten enthält. Über die SDNA sind sämtliche, jemals installierte, Agenten wieder reproduzierbar. SAgenten werden im SMART System als Dino Knoten (DAnt - Dino Ant) installiert und sind über dessen Handle erreichbar. Der gesamte SAgent, mit seinen Komponenten wird als Logical Context in den Dino Knoten eingebunden. Sie müssen daher das nötige Interface implementieren (implements DAntLogicalContext). Im Aufbau (siehe Abbildung 5.6) bestehen SAgenten aus einer SAgent-Hülle und aus Komponenten (SComponents), die in diese „Hülle” installiert werden. Die SAgent-Hülle stellt einen grundsätzlichen SAgent dar, der für die Kombination und Verwaltung seiner Seite 84 Komponenten verantwortlich ist. Die SAgent-Hülle besitzt keine Agentenfunktionalität, ist für alle SAgenten gleich und wird vom SMART System zur Verfügung gestellt. Die Hülle agiert als Postfach für Agentenmessages und stellt Methoden bereit, über die Komponenten mit dem System kommunizieren können (User/FIPA Messages versenden, Anfrage an Internal Agent Manager, Query an Directory Facilitator, etc.) und über die das SMART System den Agenten steuert (Starten/Stoppen des Agenten, Zugriff auf Komponenten). Abbildung 5.6: Der SAgent Wrapper [Kernbauer 1999] In der Hülle läuft ein allgemeiner Thread, der mit jedem Durchlauf einen HeartbeatEvent versendet. Komponenten können sich über die Methode addHeartbeat() als HeartbeatListener eintragen. Sie müssen dazu lediglich die Methode doHeartbeat(HeartbeatEvent e) implementieren, die mit jedem Durchlauf des Threads aufgerufen wird. Über diesen Ansatz wird Thread-Funktionalität an die Komponenten weitergereicht und müssen daher keinen eigenen Thread (bzw. dürfen nicht, da Java Threads sehr viele Ressourcen benötigen.) installieren. Auf die Methoden des SAgenten und seiner Komponenten wird über einen Wrapper (SAgentWrapper) zugegriffen. Der Wrapper muss das Interface DLogicalContextWrapper implementieren und kann über den Dino Knoten angefordert werden. Der Wrapper kann auch über das Netz angefordert werden (implements Serializable) und ermöglicht daher einen „Remote-Zugriff” auf die Methoden des SAgenten. (Um „remote” Seite 85 Kapitel 5 SMART auf Methoden zuzugreifen müssen eigene DMethod Objekte erzeugt werden, die die Funktionalität der Methoden kapseln und über die die Methoden aufgerufen werden.) Auch das graphische Interface des SAgenten und seiner Komponenten kann über den Dino Knoten angefordert werden und ermöglicht dem Benutzer die Kommunikation mit dem Agenten. Der Zugriff des graphischen Interface auf die Methoden des Agenten erfolgt über den Wrapper des Agenten. Durch diesen Ansatz ist eine örtliche Trennung zwischen graphischem Interface und Funktionalität möglich d.h. das Interface kann im User Interface Agent lokal dargestellt werden, obwohl der Agent auf einem anderen Host im Netz läuft. In einem Dino Knoten können auch Properties (DProperties) gespeichert werden. Diese Möglichkeit wird auch im SMART System genutzt, indem verschiedene Metadaten (Bewertung, Name) als DProperty in den Dino Knoten gespeichert werden. Der Assessment Manager, der Internal Agent Manager und andere Systemteile greifen auf diese Properties zu, um Berechnungen durchzuführen und um Einstellungen vorzunehmen. 5.7.2 Kommunikation zwischen Agenten SMART Agenten (bzw. deren Komponenten) können auf zwei Arten kommunizieren. Zum einen können sie über den Dino Knoten den Wrapper (SAgentWrapper) des Kommunikationspartners anfordern. Über den SAgentWrapper kann auf die Methoden des Agenten und seiner Komponenten zugegriffen werden (siehe Abbildung 5.6). Der Zugriff auf die Methoden des Kommunikationspartners ist ein sehr einfacher Mechanismus, der jedoch einen großen Nachteil in sich birgt. Es kann nämlich nur sinnvoll auf die Methoden eines Agenten zugegriffen werden, wenn sie erstens bekannt sind und zweitens deren Aufgabe klar ist. Java ermöglicht zwar einen Mechanismus über den die Namen der Methoden und die Properties einer Klasse erfahrbar sind und wodurch der technische Zugriff auf unbekannte Klassen möglich ist, jedoch muss trotzdem der Zweck der einzelnen Methoden bekannt sein, um sie sinnvoll verwenden zu können. Neben dem simplen Methodenaufruf können SMART Agenten auch durch Austausch von FIPA-ACL Messages kommunizieren. Da durch Dino in einem verteilten System Java Objekte ausgetauscht werden können, wird die Messagekommunikation stark vereinfacht. Es werden FIPA-ACL Objekte versandt, wodurch das Parsing der Messages größtenteils entfällt. Soll eine Message versandt werden, so wird am SAgentWrapper des Zielagenten eine receiveMessage(fipaacl) Methode aufgerufen und das FIPA-ACL Objekt übergeben. Das Messageobjekt kann im SAgenten von der zuständigen Komponente ausgelesen werden. Will eine Komponenete eine Message versenden, so ruft sie im SAgent die Methode sendMessage(fipaacl) auf, worauf die Message zum Kommunikationspartner gesendet wird. Durch Messagekommunikation ist Wissensaustausch auf höchster Ebene möglich. Es können hoch entwickelte Kommunikationsprotokolle verwendet werden. Im Prinzip ist über FIPA-ACL eine Kommunikation möglich, die der menschlichen Kommunikation entspricht. Im Gegensatz zum reinen Methodenaufruf müssen sich in der Messaging Kommunikation die beiden Kommunikationspartner nicht so genau kennen (Wissen über die einzelnen Methoden, etc.), sondern sie müssen sich nur über das Protokoll, die Seite 86 Contentsprache (Im Content-Feld einer FIPA-ACL Message kann jede Sprache verwendet werden) und die Ontologie einigen. 5.7.3 Mobilität von Agenten SMART Agenten werden als Knoten in den Dino Adressraum eingefügt. Nachdem sich der Dino Adressraum sehr stark an das Vorbild des UNIX Verzeichnisbaumes hält, sind auch dieselben Strukturoperationen möglich. Knoten können kopiert, verschoben und gelöscht werden. Verzeichnisse können angelegt und symbolische Links gesetzt werden. Der Adressraum kann sich über verschiedene Plattformen erstrecken. Somit bleiben die Strukturoperationen über Plattformgrenzen hinweg konstant. Das Bewegen eines Agenten auf eine andere Plattform reduziert sich somit auf eine einfache Move Strukturoperation. Um die Operation durchführen zu können, muss die Zielplattform mit dem SMART System verbunden werden und der Agent muss vollständig serialisierbar sein. Die Java Objekte im Dino System werden über den Java Serialisier-Mechanismus verschoben (Ein Objekt wird serialisiert, der entstandene Byte Stream wird über das Netz kopiert und in der virtuellen Maschine der Zielplattform wird das Objekt rekonstruiert). 5.7.4 SMART Komponenten Die gesamte Agentenfunktionalität von SAgenten wird aus Komponenten (SComponents) zusammengesetzt. Die Komponenten können nach dem Bausteinprinzip kombiniert werden (siehe Abbildung 5.6), wobei Kombination bestimmten Regeln unterworfen ist. So werden in SMART zwei verschiedene Typen von Komponenten unterschieden, die unter bestimmten Bedingungen kombinierbar sind: Zentrale Komponenten: Zentrale Komponenten („Functional Components”) beinhalten die wesentliche Funktion des Agenten und deshalb benötigt jeder SAgent mindestens eine zentrale Komponente. Diese Komponente ist für die gesamte Logik und Koordination der übrigen Komponenten (falls vorhanden) innerhalb eines Agenten verantwortlich. Optionale Komponenten: Optionale Komponenten erweitern die Funktion der zentralen Komponenten. In SMART werden verschiedene Typen von optionalen Komponenten unterschieden: „Object Components” definieren das Objekt, auf das die Funktion angewendet werden soll. So könnte die vom User gestellte Aufgabe „search Car” von zwei Komponenten erfüllt werden. Der Ausdruck „search” würde durch eine „Functional Component” erfüllt werden und „Car” würde durch eine „Object Component” definiert werden. Im Zusammenspiel der beiden Komponenten entsteht ein Suchagent, der ein Auto sucht. _ Über eine „Resource Component” erhalten SAgenten das jeweilige Wissen, um auf Resourcen zugreifen zu können. Eine „Mode Component” definiert den Modus der Aktion. Eine Suchfunktion kann schnell oder gründlich durchgeführt werden. Die nötige Logik kann durch diesen Komponententyp ermöglicht werden. Seite 87 Kapitel 5 SMART Die „Time Component” ist für die zeitgemäße Steuerung des Agenten verantwortlich. Sie legt fest, wann ein Agent welche Funktion durchführen soll. Die vier Typen von optionalen Komponenten bilden eine Grundmenge die durch neue Typen erweitert und ergänzt werden kann. Neben der logischen Typisierung werden SMART Komponenten zusätzlich nach Themen gruppiert. Die Gruppierung erfolgt hierarchisch, wodurch eine Verschmelzung von Subtypen möglich ist. Als Vorbild für die SMART Gruppierung diente die „MIMEType” Typisierung aus dem Internet. So werden zum Beispiel durch den Typ function/commerce/buy Functional Components bezeichnet, die sich mit dem Kaufen von Waren beschäftigen. Nachdem im SMART System verschiedene Typen von Agenten existieren (User Agent, System Agent, Staff Agent), die jeweils ein unterschiedliches Aufgabenfeld besitzen kann auch dieses Aufgabenfeld in den Typ der Komponenten kodiert werden. Eine Komponente mit dem Typ function/user/commerce/buy ist eine Functional Component, die in einem Useragenten verwendet wird. Im Gegensatz dazu wird eine Komponente mit dem Typ function/system/commerce/marketplace von Systemagenten eingesetzt um einen virtuellen Marktplatz aufzubauen. Programmtechnisch erben alle Komponenten von einer SComponent - Grundklasse und müssen einige Grundmethoden implementieren um in einen SAgenten eingebunden zu werden: Die Methode getType() definiert den Typ der Komponente. Die Methode getNeeds() definiert jenen Typ der Komponenten, zu denen die Komponente kombinierbar ist. Die Methode getKeywords() beschreibt mit einigen Schlüsselwörtern die Funktion der Komponente. Diese Schlüsselwörter werden im SMART System vom Agent Finder verwendet, um die zu einer Benutzeranfrage passenden Komponenten zu finden. 5.7.5 SMART Componentbase In der „SMART Componentbase” wird die Menge der verfügbaren Komponenten verwaltet. Die Speicherung erfolgt in Form einer Komponentenbeschreibung („SComponentDescription”). Die Beschreibung enthält neben Typ, Schlüsselwörtern und einer allgemeinen Beschreibung auch eine Komponentenbewertung. Nachdem für den Erfolg der SMART Agenten im SMART System hauptsächlich die Komponenten verantwortlich sind, wird die Bewertung des Agenten auf die enthaltenen Komponenten zurückgerechnet. Die Bewertung wird durch den Assessment Manager in der Componentbase gespeichert. Wird ein neuer SMART Agent erstellt, so dient die Bewertung als Entscheidungsgrundlage für die Auswahl der passenden Komponenten. Komponenten mit einer höheren Bewertung werden gegenüber anderen Komponenten bevorzugt. Seite 88 5.7.6 SMART Agentbase Nach der Installation eines SMART Agenten wird die neu erstellte Kombination von Komponenten in der „SMART Agentbase” gespeichert. Wie die Komponenten in der Componentbase werden auch die Agenten in der Agentbase durch ein Beschreibungsobjekt („SAgent-Description“) repräsentiert. In der Beschreibung ist die Bewertung des Agenten und die Benutzeranfrage, die zu seiner Erstellung führte, gespeichert. Wichtigster Bestandteil der Beschreibung ist die „DNA” des Agenten d.h. die Beschreibung der Kombination von Komponenten, aus denen der Agent besteht. Die Beschreibung wird in Anlehnung an das biologische Vorbild als SMART-DNA (SDNA) bezeichnet. Die SDNA enthält Package- und Klassennamen jener Komponenten aus denen der Agent kombiniert wurde. Über die SDNA ist der Agent jederzeit reproduzierbar. 5.7.7 SMART Bewertung SMART ist ein adaptives Agentensystem, das sich an die Bedürfnisse des Benutzers anpasst. Die Anpassung wird im SMART System durch einen doppelten Auswahl- und Bewertungsmechanismus erreicht. Ziel der Bewertungsmechanismen ist die Optimierung der dynamischen Elemente (SAgenten) des Systems. Nur jene Agenten, die den Anforderungen am besten entsprechen, sollen im System erhalten bleiben. Agenten die sich nicht bewähren, sollen aus dem System entfernt werden. Der Optimierungsprozess soll ständig aufrechterhalten werden, wodurch das Gesamtsystem ein dynamisches Verhalten erfährt. Werden an das Gesamtsystem neue Anfragen gestellt, so werden die nötigen Agenten installiert, andere, die den Anforderungen nicht mehr entsprechen, werden deinstalliert. Die Gesamtbewertung stützt sich auf zwei parallele Bewertungsmechanismen: Bewertung durch den Benutzer Die Grundidee der Bewertung durch den User ist die Bildung einer Feedback Schleife, über die die Meinung des Benutzers in das System einfließt. Der Benutzer ist aufgefordert „seine” Agenten zu bewerten. Der Agent kann während der Erfüllung seiner Aufgabe bewertet werden. Spätestens nach der Erfüllung der Aufgabe und vor der Deinstallation wird der Benutzer aufgefordert den Agenten zu bewerten. Interne Bewertung SMART Agenten können die Dienste anderer SMART Agenten in Anspruch nehmen. Somit tritt ein Agent als „Benutzer” eines anderen Agenten auf. Grundsätzlich können die Dienste jedes SMART Agenten von einem anderen Agenten in Anspruch genommen werden. Der „Typus” des Agenten definiert auch seinen Kundenkreis. User Agenten und System Agenten stellen ihre Dienste sowohl Benutzern, wie auch Agenten zur Verfügung, Staff Agenten handeln nur im Auftrag anderer Agenten und können nicht von einem Benutzer angefordert werden. Die Bewertung zwischen den Agenten wird auf Basis der Anfragen möglich. Agenten, die viele Anfragen von anderen Agenten erhalten sind offensichtlich „beliebter” als Agenten, an die weniger Anfragen gestellt werden. Zusätzlich muss noch unterschieden werden, welcher Art die Anfragen sind und ob die Anfragen zu positiven oder negativen Ergebnissen führten. Die interne Bewertung wird durch die möglichen Sonderfälle ein sehr schwieriger und fehlerbehafteter Vorgang. Jedoch ist eine interne Bewertung Seite 89 Kapitel 5 SMART notwendig um eine konsistente Bewertung des Gesamtsystems zu erreichen. Die Bewertungen werden als Property im Dino Knoten des Agenten gespeichert und nach Bedarf bzw. vor der Deinstallation durch den Assessment Manager ausgelesen und in der Agentbase gespeichert. Da für den Erfolg eines Agenten nicht nur die richtige Kombination von Komponenten ausschlaggebend ist, sondern auch die Komponenten selbst einen wesentlichen Teil beitragen, wird die Bewertung auch auf die Komponenten umgerechnet und in den Beschreibungen der Komponenten in der Componentbase gespeichert. Die Bewertungslogik im Assessment Manager und im SAgent wird durch Bewertungsklassen ermöglicht, die nach einem „Plug-In” Mechanismus austauschbar sind. Der Administrator kann über die „Plug-In Base” jederzeit eine andere Bewertungslogik auswählen und installieren. 5.7.8 User Interaktion Der Benutzer kommuniziert über den User Interface Agent oder über das Admin Tool mit dem SMART System. Im graphischen Interface dieser Client-Programme werden auch die graphischen Interfaces (GUI - Graphical User Interface) der einzelnen Agenten dargestellt. Über das GUI des Agenten kann der Benutzer den Agenten konfigurieren und mit dem Agenten kommunizieren. Rückmeldungen und die Ergebnisse der Agenten erhält der User in Form einer Nachricht (SUsermessage). Die Nachrichten können über den User Interface Agenten gelesen und auch im lokalen System gespeichert werden. Dies ist die Grundkonfiguration des SMART Systems. Die Grundkonfiguration kann durch Systemagenten erweitert werden, vor allem aber komfortabler gestaltet werden. Ein „Mail” System Agent könnte die Nachricht als Email versenden oder ein „Web-Server” System Agent könnte die Nachricht auf einem Webserver in Form eines HTML Files speichern, wodurch die Rückmeldung mit einem normale WebBrowser gelesen werden kann. 5.8 Zusammenfassung Ziel von SMART ist es, eine allgemeine Infrastruktur zur Realisierung von Multiagentensystemen zu schaffen, die nicht an bestimmte Anwendungsdomänen gebunden sind. Als Bausteine zur Entwicklung dienten die Programmiersprache Java und das am IICM Graz entwickelte Framework „Dino”. Die SMART Plattform, stellt ein verteiltes System dar in dem sowohl mobile, als auch statische Agenten agieren können. Die Plattform schafft eine Runtime-Umgebung für SMART-Agenten, und Agenten können verwaltet werden. Im Wesentlichen besteht die Plattform aus einer Dino-Struktur über die Agenten und externe Systeme (WWW, Hyperwave Server, Datenbanken, xFIND, etc.) adressiert werden können. Jeder Agent im System besitzt einen eigenen Thread, dadurch laufen sie selbständig und können jederzeit gestoppt werden. Strukturell bestehen Agenten aus Komponenten, aus denen sie zur Laufzeit zusammengefügt werden. Der User kommuniziert mit dem System über einen eigenen User-Agenten. Der User-Agent ist auf dem Rechner des Anwenders installiert und stellt ihm ein graphisches Interface zur Verfügung, dass es ihm Seite 90 ermöglicht seine Agenten zu verwalten. Auch Agenten stellen dem User ein graphisches Interface zur Verfügung über das sie konfiguriert werden können. Nach Erledigung seiner Aufgabe kann der Agent vom Benutzer bewertet werden. Die Bewertung wird auf die Komponenten des Agenten weitergegeben und beeinflusst damit die zukünftige Auswahl der Komponenten. Verwaltet und konfiguriert wird das Gesamtsystem über ein eigenes Administratorinterface. Ein Administrator kann Benutzerrechte verwalten, Agenten überwachen und Komponenten einspielen. Durch den Komponentenansatz bleibt das System erweiterbar und flexibel. Werden neue Komponenten eingebracht können Agenten mit neuen Fähigkeiten ausgestattet werden. Komponenten, die nicht mehr benötigt werden, können aus dem System entfernt werden. Die Erweiterbarkeit und Zugriffsmöglichkeiten im System sind streng geregelt. Interfaces auf externe Systeme werden über die Agentenplattform ermöglicht (Dino). So können selbst Agenten nur über diese Schnittstellen mit der „Außenwelt” kommunizieren. Die hier erläuterten Konzepte wurden, wie schon einleitend erwähnt gemeinsam mit Stefan Kernbauer in einer ersten Version prototypisch implementiert. Eine umfassendere Beschreibung dieses Prototyps ist aus dessen Diplomarbeit [Kernbauer 1999] zu entnehmen. Dort sind unter anderem auch die Software Requirement Specification und die Software Engineering Specification zu finden, die zur Implementierung des SMART Prototypen verwendet wurden. Der SMART-Prototyp stellt nur eine Basiskonfiguration dar, die erst durch das hinzufügen von Komponenten und Agenten zum „Leben“ erwacht. Um die Funktionsweise des SMART Prototypen zu zeigen, und die Vorgehensweise bei der Implementierung von SMART-Komponenten und –Agenten zu verdeutlichen wird im folgenden Kapitel ein einfaches Agenten-Szenario entworfen, und dessen Umsetzung beschrieben. Seite 91 Kapitel 6 Ein einfacher Informationsagent für SMART Kapitel 6 6 Ein einfacher Informationsagent für die SMART Agenten Plattform Das folgende Kapitel beschreibt nun wie Agenten für die SMART-Plattform programmiert, und in die SMART Umgebung integriert werden können. Dazu wird ein einfaches Beispielszenario entworfen, in dem ein Agent mit dem am IICM entwickelten xFIND Suchsystem kommuniziert. Das vordergründigste Ziel dieses Kapitels ist es den Ablauf und die Vorgehensweise bei der Umsetzung eines „SMART-Projekts“ zu dokumentieren, des Weiteren sollten Erkenntnisse darüber gewonnen werden, ob sich die im SMART-Prototypen umgesetzten Konzepte auch in der Praxis bewähren. Der Funktionsumfang wurde dabei bewusst kurz gehalten, da bereits in die Entwicklung des SMART-Prototypen viel Zeit investiert wurde. Um einen technischen Einblick in das xFIND Suchsystem zu bekommen folgt zunächst eine kurze Beschreibung dieses Systems. 6.1 Das xFind Suchsystem xFIND steht für Extended Framework for Information Discovery und wird in erster Linie zur modernen Wissensauffindung in verteilten Umgebungen eingesetzt. xFIND ist aufgrund des Einsatzes von Java (das UI ist in Perl bzw. PHP umgesetzt) plattformunabhängig. Durch die Bewertung der Suchergebnisse mit Qualitätsaspekten oder Merkmalen wie z.B. die Zuverlässigkeit einer Informationsquelle wird die Ergebnismenge eingeschränkt und damit kann von xFIND eine sehr hohe Treffergenauigkeit erzielt werden. [Gütl 2002] Die xFIND Architektur setzt sich im Wesentlichen zusammen aus Gatherer, Indexer und Broker. Um die Übertragung der Daten zwischen den Modulen möglichst effizient betreiben zu können, wird ein eigens entwickeltes Übertragungs-Protokoll und Datenaustauschformat xQCF (xFIND Query Communication Format) eingesetzt. In Abbildung 6.1 ist die verteilte hierarchische Architektur des xFIND Suchsystems grafisch dargestellt. Gatherer können direkt (Local) oder Remote auf die Datenbestände zugreifen. Indexer können ihre Informationen von mehreren Gatherer beziehen. Broker nehmen Suchanfragen entgegen und greifen ihrerseits wiederum auf die Daten verschiedener Indexer zu. [Gütl 2002] Seite 92 Abbildung 6.1:Verteilte Architektur des xFIND Suchsystems [Gütl 2002] Aus Sicht von xFIND gilt der Indexer als Schnittstelle zwischen den Informationsbrokern und den Gatherern. Der Indexer verarbeitet die von einem Gatherer zur Verfügung gestellten SOIF-Objekte36, indiziert diese und legt die indizierten Daten in einer Datenbank ab (z.B. MySQL, PostGres, Oracle). Der Indexer wertet die Suchanfragen im xQCF Format der Broker aus. Die xFIND Suche unterstützt herkömmliche SuchFunktionen, wie Volltextsuche, Ähnlichkeits-erkennung oder Schlüsselwortsuche. Zusätzlich kann aber auch nach den beschreibenden Metainformationen gesucht bzw. die verschiedenen Suchen miteinander verknüpft werden. Dem entsprechend werden bei der Darstellung der Suchergebnisse auch diese zusätzlichen Metainformationen mit angezeigt. [Gütl 2002] Der Broker nimmt die Suchanfragen der Benutzer entgegen und leitet diese an einen oder mehrere Indexer weiter. Die erhaltenen Resultate werden gesammelt, gecached, entsprechend zur Ausgabe aufbereitet und zum Client zurückgeschickt. Die Suchanfragen der Clients werden vom Broker in das xQCF-Format umgesetzt und in dieser Form als Anfrage an die Indexer weitergeleitet. [Gütl 2002] [Lackner 2004] Die Kommunikation zwischen den verschiedenen xFIND-Modulen wird über Java TCP/IP Socket Verbindungen (XFSocket) durchgeführt. Auf diesem TCP/IP Socket wird ein eigens definiertes Transportprotokoll aufgesetzt. Jedes Modul in xFIND muss eigens einen Client und Server starten, um miteinander kommunizieren zu können. So startet z.B. der Gatherer über die Klasse XFGathererCommunication den Gatherer-Server, um Requests vom xFIND Indexer-Client entgegen nehmen zu können. Der xFIND Indexer startet hingegen mit der Klasse XFIndexGathererClient die Kommunikationsschnittstelle am Indexer. Der Indexer schickt eine Such-Anfrage im xQCF-Format an den Gatherer. 36 SOIF: Das Harvest Summary Object Interchange Format besteht aus Attribut-Wert Paaren, die aus dem Textinhalt der Daten extrahiert werden. Seite 93 Kapitel 6 Ein einfacher Informationsagent für SMART Der Gatherer extrahiert resultierend der Suchanfrage die entsprechenden Daten aus seiner internen Datenbank. Die Kommunikation zwischen xFIND Broker und xFIND Indexer erfolgt auf ähnliche Weise. Der Broker startet einen Client über die Klasse XFIndexerQuery. Auf der Indexer Seite wird der entsprechende Server über die Klasse XFIndexerSearchQueryComm erzeugt. Da bei dieser Kommunikation keine zusätzlichen Transformationen stattfinden besteht der Datenaustausch hauptsächlich aus verschiedenen xQCF Datenpaketen. [Lackner 2004] Im folgenden Beispielszenario wird die Broker-Indexer Kommunikation verwendet. Dabei übernimmt der xFIND Indexer Wrapper Agent (siehe Abschnitt 6.3.1) die Funktion des Brokers. Dieser Kommuniziert mit einem xFIND Indexer über eine XFSocket-Verbindung auf einem definierten Port. Ein Vorteil den diese Konstellation mit sich bringt ist, dass keine HTML-Transformationen bei dieser Kommunikation durchgeführt werden, und damit ein HTML-Parsen der Ergebnisliste nicht notwendig ist. 6.2 Das xFind Beispielszenario Das zuvor beschriebene xFIND Suchsystem soll um einen so genannten „Whats New“ Service erweitert werden, der den Benutzer in regelmäßigen Abständen darüber informiert, ob zum Ergebnis einer seiner früheren Anfragen an das xFIND-System, neue Treffer hinzugekommen sind. Dieser Service wird z. B. im Hyperwave Informations System [Hyperwave 2005] angeboten. Das beschriebene Service soll in der SMART Plattform umgesetzt werden. Anforderungen Die SMART-Plattform braucht eine Verbindung zum xFIND Suchsystem, über die Suchanfragen gestellt, und Ergebnisse entgegengenommen werden können. Sowohl die Suchanfragen, als auch die Ergebnisse müssen in geeigneter Weise im SMART-System gespeichert werden können, damit eine spätere Wiederholung der Suchanfrage und ein Vergleich der Ergebnisse möglich sind. Natürlich muss auch der Benutzer Zugriff auf die gespeicherten Daten haben. Die zeitlichen Abstände in denen die Suchanfragen wiederholt und deren Ergebnisse miteinander verglichen werden, sollen für den Benutzer konfigurierbar sein. Der Benutzer muss gegebenenfalls über Änderungen informiert werden. Die Schrittweise Umsetzung dieses Szenarios wird nun in den folgenden Unterkapiteln kurz beschrieben. 6.3 Beteiligte Agenten Die Umsetzung der oben genannten Anforderungen kann natürlich auf vielerlei Arten erfolgen. Beispielsweise könnte die gesamte Funktionalität in einem einzelnen SmartAgenten vereinigt sein, doch dies widerspricht dem Agentenansatz. Vielmehr sollten die Aufgaben und Fähigkeiten an mehrere spezialisierte Agenten verteilt werden, die dann gemeinsam den geforderten Service erbringen. Für die Zwecke dieser vorliegenden Arbeit soll der „Whats New“ Service mittels zwei verschiedenen Agententypen, nämlich Seite 94 einem „xFIND Indexer Wrapper“ Agenten und einem „What’s New“ Agenten umgesetzt werden. Der xFIND Indexer, dient als Kommunikationsschnittstelle zum xFIND Suchsystem. Die Kommunikationsbeziehungen der Beteiligen Module sind in Abbildung 6-2 dargestellt. Bei der Kommunikation zwischen den beteiligten Agenten und dem xFIND Indexer werden im Wesentlichen xQCF Datenpakete ausgetauscht. What’s New Agent xFIND Indexer Wrapper Agent xFIND Indexer Abbildung 6.2: Die Kommunikationsbeziehungen im xFIND Beispielszenario Die Beschreibung Aufgaben der Agenten werden in den folgenden Unterkapiteln kurz beschrieben. 6.3.1 Der xFIND Indexer Wrapper Agent Die Hauptaufgaben dieses Agenten sind, die Kommunikation mit dem xFIND Indexer aufzubauen, eine Suchanfrage vom What’s New Agenten an den xFIND Indexer weiterzuleiten, das Suchergebnis vom xFIND Indexer entgegenzunehmen und an den What’s New Agenten zurückzuliefern. Dieser Agent benötigt lediglich ein einfaches Userinterface mit dem der Hostnamen und die Portnummer für die Kommunikation mit dem xFIND Indexer konfiguriert werden. Die Kommunikation findet über eine XFSocketverbindung statt und erfolgt mittels Austausch von xQCF Datenpaketen (siehe Abschnitt 6.1). Um die, für diesen Agenten benötigten Komponenten definieren zu können, ist es zunächst von Vorteil, das Komponentenmodell von SMART genauer zu betrachten. Das Komponentenmodell von SMART Der SMART Agentenansatz sieht vor, dass Agenten aus mehreren Komponenten bestehen (siehe Abbildung 5.6). Manche Komponenten (Functional Components) können nur in einem Agententyp verwendet werden, andere Komponenten (Object-, Ressource-, Mode- und Time-Komponenten) können als Zusatzkomponenten in mehreren Agententypen verwendet werden. Im SMART Prototypen muss ein Agent zumindest über eine Funktionelle Komponente (Functional Component) verfügen, alle anderen Komponententypen sind optional. Programmtechnisch leiten sich alle Komponenten von der generellen SMART Component Klasse (SComponent) bzw. von den davon abgeleiteteten Spezialklassen (SFunctionComponent, SObjectComponent, SResourceComponent, SModeComponent, Seite 95 Kapitel 6 Ein einfacher Informationsagent für SMART STimeComponent) ab. Nachdem Smart Agenten als Knoten in den Dino Adressraum eingefügt werden, müssen sie das Dino Interface DAntLogicalContext implementieren. Um den Anforderungen des DAntLogicalContext Interfaces zu entsprechen, müssen die Komponenten sämtliche geforderten Methoden implementieren (getLogicalContext(), getServices(), getMethods(), etc.). Um als SMART Komponente eingesetzt werden zu können, müssen die Komponenten noch zusätzlich die Methoden getType(), getNeed() und getKeywords() implementieren. Neben diesen generellen Methoden besitzen SMART Komponenten noch Methoden, die deren spezielle Funktionen implementieren. Auf die Methoden der Komponenten und Agenten kann im Dino-Adressraum nur über einen so genannten Wrapper zugegriffen werden. Die allgemeinen Methoden eines Agenten werden bereits im SAgentWrapper zur Verfügung gestellt (siehe Abschnitt 5.7.1). Damit auch auf die Methoden der Komponenten zugegriffen werden kann, wird eine zusätzliche Wrapper Klasse zu jeder Komponente benötigt, die das DAntLogicalContextWrapper Interface implementiert. Komponenten können grafische Interfaces anbieten. Diese so genannten „Services“ werden in einem Dino-Knoten separat gespeichert und verwaltet. Für jedes dieser Services muss eine eigene Klasse implementiert werden, die das entsprechende grafische Interface repräsentiert (z.B. einen JFrame mit Eingabefeldern). Um dieses Service von einem Knoten anfordern zu können ist eine zusätzliche Java Klasse erforderlich, die das DAntServiceInfo Interface implementiert. Mit diesen Informationen können nun die benötigten Komponenten und Klassen des xFIND Indexer Wrapper Agenten definiert werden. Benötigte Komponenten für xFIND Indexer Wrapper Agent: Da der xFIND Indexer Wrapper Agent nur als Schnittstelle zu xFIND verwendet wird, und keine zusätzliche Funktionalität besitzt, wird für diesen Agenten eine Funktionelle Komponente ausreichen. Das Graphische Interface dieses Agenten ist sehr einfach, und kann von einem einzigen Dino Service erledigt werden. Für die Umsetzung dieses Agenten wurden vier Java-Klassen implementiert. Die Klasse XFIndexerFunction.java stellt die Methode askQCFIndexer(xQCFQuery) bereit, die die Kommunikation mit dem xFIND Indexer erledigt und das Ergebnis der Anfrage zurückliefert. Zwei weitere Methoden setIndexer() und getIndexer() werden zum Setzen und Auslesen des Hostname und der Portnummer des Kommunikationspartners benötigt. Die Klasse XFIndexerFunctionWrapper.java wird benötigt, um den Zugriff auf die Methoden der Komponente über Dino zu ermöglichen. Eine weitere Klasse XFIndexerFunctionFrame.java implementiert das grafische Interface der Komponente (Dinoservice), einen JInternalFrame mit drei Textfeldern für die Eingabe von Name, Hostname und der Portnummer. Damit dieses Service über Dino angefordert werden kann ist wird die Klasse XFIndexerFunctionFrameServiceInfo.java benötigt. Seite 96 Für genauere Details der Implementierung sei an dieser Stelle auf den Sourcecode, der dieser Arbeit beigelegten CD verwiesen. Nach dem Kompilieren der Java Klassen sind alle Voraussetzungen für die Installation eines Agenten in der SMART-Plattform gegeben. Die Vorgehensweise wird nun an Hand von Screenshots kurz beschrieben. Starten der Plattform Mit dem Shellscript DinoJava dinosaur.smart.platform.Splatform wird die Plattform gestarted (dieses Script fügt die von SMART benötigten Klassenpfade zum normalen Java-Aufruf hinzu). Es erscheint der UserManagerFrame der SMART-Plattform (siehe Abbildung 6.3). Der Usermanager ermöglicht die Userverwaltung (anlegen und löschen von Benutzern), sowie das An- und Abmelden von Benutzern. Abbildung 6.3: Der SMART User Manager Frame Anlegen eines neuen Benutzers In SMART sind zwei Usergruppen vorgesehen, die Gruppe Admin und die Gruppe User. Abbildung 6.4 zeigt den Add User Dialog, mit dem ein neuer User angelegt werden kann. An dieser Stelle soll ein neuer User mit Administratorrechten angelegt werden. Seite 97 Kapitel 6 Ein einfacher Informationsagent für SMART Abbildung 6.4: Der SMART Add User Dialog Einloggen eines Benutzers Abbildung 6.5 zeigt den Login-Dialog, der über das Connection-Menü des UserManagerFrame erreichbar ist. Abbildung 6.5: Der SMART Login Dialog Abhängig von der Gruppenzugehörigkeit des angemeldeten Benutzers ist der Zugang zum SMART-System unterschiedlich. Benutzern die der Admin-Gruppe angehören wird nach dem Einloggen der SMART-ADMIN TOOL-Frame angeboten (siehe Abbildung 6.6). Nur Über diesen Zugang können SMART-Komponenten in die SMARTComponentbase eingespielt werden (siehe das aufgeklappte Menü in Abbildung 6.6). Seite 98 Abbildung 6.6: Das SMART Admin Tool Benutzer der Gruppe User erhalten einen eingeschränkten Zugang zum SMARTSystem über den so genannten SMART USER INTERFACE AGENT (siehe Abbildung 6.7). Sie haben nur Zugriff auf Komponenten und Agenten die mit den Rechten der Gruppe User ausgestattet sind, und dürfen selbst keine Komponenten in die SMARTComponentbase einfügen. Abbildung 6.7: Der SMART USER INTERFACE AGENT Für den weiteren Verlauf dieser Beschreibung muss der Benutzer Administratorrechte besitzen, damit die Komponente des xFIND Indexer Wrapper Agenten in die SMARTComponentbase eingefügt werden kann. Einfügen einer SMART-Komponente in die SMART-Componentbase SMART Komponenten werden beim Einfügen in die Componentbase mit Rechten versehen. Dabei wird zwischen User-, System-, und Staff-Komponenten unterschieden. User-Komponenten müssen über ein entsprechendes Userinterface verfügen (Dino Service). Staff-Komponenten sind Komponenten, die über kein Userinterface verfügen. Bei System-Komponenten spielt dies keine Rolle, diese Komponenten dürfen nur von Seite 99 Kapitel 6 Ein einfacher Informationsagent für SMART Benutzern mit Administratorrechten beim Erstellen von Agenten verwendet werden. Einfügen der xFIND Indexer Wrapper Komponente in die SMART- Componentbase Da es sich bei dieser Komponente um eine Kommunikations-Komponente handelt, die zudem sehr viele Ressourcen benötigt, ist es sinnvoll, diese als System Komponente in die Componentbase einzufügen, damit nicht jeder Benutzer diese unkontrolliert verwenden kann. Dazu wird im SMART-ADMIN TOOL der Menüpunkt ‚Admin system Components’ (siehe Abbildung 6.6) gewählt. Es erscheint der Componentbase systemcomponents-Dialog (siehe Abbildung 6.8). Mit diesem Dialog können alle Systemkomponenten administriert werden (hinzufügen, löschen, editieren). Abbildung 6.8: Der SMART Systemcomponents Dialog Jetzt soll die xFIND-Indexer-Wrapper Komponente eingefügt werden. Dazu wird Add im vorigen Dialog (siehe Abbildung 6.8) gewählt. Es erscheint ein File-Auswahldialog, der die Navigation im Dateisystem auf das Java-Class-File der zu installierenden Komponente ermöglicht (siehe Abbildung 6.9). Seite 100 Abbildung 6.9: Der Choose Class Dialog Ist das entsprechende Class-File gefunden, so wird mit ‚Open’ der Add Component Dialog geöffnet, der in Abbildung 6.10 dargestellt ist. Hier werden sämtliche Metadaten der Komponente visualisiert. Abbildung 6.10: Der Add Component Dialog Durch Drücken des Add-Buttons wird die Komponente in die Componentbase eingefügt, und der Benutzer wird über den Erfolg bzw. Misserfolg mittels Alertfenster Seite 101 Kapitel 6 Ein einfacher Informationsagent für SMART benachrichtigt. Damit ist die Installation der Komponente abgeschlossen. Jetzt kann ein SMART-Systemagent aus dieser Komponente erzeugt werden und zunächst in die SMART-Agentbase eingefügt werden. Die Vorgehensweise wird nachfolgend beschrieben. Einfügen eines Agenten in die SMART-Agentbase Voraussetzung dafür, einen Agenten im SMART-System zu erstellen ist, dass sich bereits geeignete Komponenten in der Componentbase befinden. An dieser Stelle wird vorausgesetzt, dass die, in den vorigen Abschnitten beschriebenen Aktionen bereits durchgeführt wurden, und die Systemkomponente xFIND Indexer Wrapper bereits vorhanden ist. Um den xFIND Indexer Wrapper Agenten in die SMART-Agentbase einzufügen, wird im SMART-ADMIN TOOL-Frame (siehe Abbildung 6.6) der Menüpunkt ‚Agentbase >Admin system Agents’ gewählt. Es öffnet sich der Agentbase systemagents-Dialog (siehe Abbildung 6.11). Dieser Dialog ermöglicht, analog zum Componentbase systemcomponents-Dialog (siehe Abbildung 6.6) die Administration von SMARTSystemagenten. Abbildung 6.11: Der SMART Agentbase Systemagents Dialog Durch klicken des ‚Add’-Buttons öffnet sich der ‚Add Agent to Agentbase Dialog’ (siehe Abbildung 6.12). Mit Hilfe dieses Dialogs kann nun ein Agent aus Komponenten verschiedenen Typs (derzeit stehen 5 Komponententypen zur Auswahl) zusammengestellt werden. Einzige Einschränkung ist, dass eine Funktionelle-Komponente bei jedem Agenten vorhanden sein muss. Seite 102 Abbildung 6.12: Der SMART Add Agent to Agentbase Dialog Der xFIND-Indexer-Wrapper Agenten benötigt lediglich die Funktionelle Systemkomponente die zuvor in die Componentbase eingefügt wurde. Diese Komponente kann durch Betätigen des Buttons ‚Choose Function’, aus dem dabei sich öffnenden Dialog (siehe Abbildung 6.6) ausgewählt werden. Dem Agenten kann nun noch ein aussagekräftigen Name gegeben werden, und durch drücken des Add-Buttons wird er in die SMART-Agentbase eingefügt. Nun hat jeder User mit Administratorrechten die Möglichkeit, einen oder auch mehrere dieser Agenten auf der SMART-Plattform zu installieren. Die Vorgehensweise wird nachfolgend beschrieben. Installation eines xFIND Indexer-Wrapper Agenten in der SMART-Plattform Voraussetzung dafür, einen Agenten in der SMART-Plattform zu installieren ist, dass sich bereits Agenten in der SMART-Agentbase befinden. An dieser Stelle wird vorausgesetzt, dass die, in den vorigen Abschnitten beschriebenen Aktionen bereits durchgeführt wurden, und der Systemagent xFIND Indexer Wrapper Agent bereits vorhanden ist. In SMART existieren mehrere Möglichkeiten Agenten zu installieren. Es kann z. B. eine Suche nach Schlüsselwörtern abgesetzt werden, die dann in der SMART-Agentbase nach Agenten, die diese Schlüsselwörter in ihren Metadaten enthalten sucht, und gegebenenfalls zurückliefert. Diese Vorgehensweise ist aber erst interessant wenn sich dort sehr viele Agenten befinden. An dieser Stelle wird ein direkter Weg zur Installation eines Agenten beschrieben, der diese Suchmöglichkeiten außer Acht lässt. Abbildung 6.7 stellt den SMART-ADMIN TOOL-Frame mit aufgeklappten ‚Find’-Menü dar. Wählt man dort den Menüpunkt ‚Choose from Agentbase Systemagent’, so öffnet sich der Choose from Agentbase Dialog (siehe Abbildung 6.13). In diesem Dialog kann nun ein entsprechender Agent selektiert werden und durch Klicken des ‚Install’-Buttons wird eine Instanz dieses Agenten in die Dino-Hierarchie der SMART-Umgebung eingefügt und gestartet (ein Zwischendialog Seite 103 Kapitel 6 Ein einfacher Informationsagent für SMART ermöglicht dem Benutzer die Eingabe eines bedeutungsvollen Namen für den Agenten). Abbildung 6.13: Der Choose from Agentbase Dialog Die Verwaltung von aktiven Agenten in der SMART-Plattform ist über das MyAgents-Menü im SMART ADMIN TOOL-Frame, möglich. Es öffnet sich der My Agents Dialog (siehe Abbildung 6.14), über den sämtliche installierten Agenten der SMART-Plattfom, starten, stoppen, bewerten und entfernen lassen. Abbildung 6.14: Der My Agents Dialog Seite 104 Um zu den grafischen Interfaces eines Agenten und seiner Komponenten zu gelangen, muss zunächst der Button ‚Show’ im My Agents Dialog betätigt werden. Es erscheint ein generischer Dialog, der für jede Komponente des Agenten, die ein grafisches Interface besitzt eine Schaltfläche anbietet. In diesem Beispiel enthält der Agent nur eine Funktionale Komponente die ein Userinterface anbietet (siehe Abbildung 6.14). Mit einem Klick auf die Schaltfläche wird das grafische Interface der Komponente visualisiert (siehe Abbildung 6.15). Abbildung 6.15: Das xFIND Indexer Wrapper Interface Durch Eingabe der entsprechenden Daten ist der xFIND Indexer Wrapper Agent konfiguriert, und kann nun mit dem xFIND Indexer kommunizieren. 6.3.2 Der What’s New Agent Der What’s New Agent hat mehrere Aufgaben. Er stellt für den Benutzer ein Grafisches Interface zur Verfügung, das ihm Zugang zu verschiedenen Funktionen verschafft, und er muss mit den xFIND Indexer Wrapper Agenten kommunizieren können. Zu den Funktionen die dieses Agenten zählen unter anderem: Abfragen der im SMART System vorhanden xFIND Indexer Wrapper Agenten, durch eine Anfrage beim Directory Facilitator Bereitstellung eines Suchformulars Speichern von Suchanfragen und Ergebnissen Visualisierung von Suchanfragen und Ergebnissen Zeitgesteuertes, wiederholtes ausführen von Suchanfragen Vergleichen von Suchergebnissen Benachrichtigen des Benutzers Die Beschreibung dieses Agenten soll an dieser Stelle kurz gehalten werden. Die Seite 105 Kapitel 6 Ein einfacher Informationsagent für SMART Vorgangsweise bei der Installation entspricht der in den vorangegangenen Unterkapiteln beschriebenen. Der What’s New Agent setzt sich aus einer Funktionalen- und einer TimeKomponente zusammen. Die Timerkomponente erlaubt die eine komfortable Eingabe von verschieden Zeitpunkten und Intervallen. Es können damit tägliche, wöchentliche, monatliche und beliebige andere Intervalle festgelegt werden, an denen dann ein Java Event ausgelöst wird. Abbildung 6.16 zeigt das Userinterface dieser Komponente. Abbildung 6.16: Das Userinterface der Timer Komponente Das Interface der Funktionalen Komponente des What’s New Agenten ist in Abbildung 6.17 dargestellt. Abbildung 6.17: Das Userinterface der What's New Komponente Seite 106 Abbildung 6.18: Der SMART Assistent Bei dieser What’s New Komponente wurde nicht die gesamte Funktionalität umgesetzt. Es fehlt ein entsprechendes Suchformular zur Eingabe von Suchanfragen und auch die Visualisierung der gespeicherten Suchergebnisse. Suchanfragen können lediglich über die Commandline eingegeben werden, und Suchergebnisse werden in einem File abgelegt. Wenn ein neues Suchergebnis gespeichert wurde wird der Benutzer vom SMART Assistenten darüber informiert (siehe Abbildung 6.18), und er kann die enstprechende Nachricht über das Massage Menü des SMART ADMIN TOOL lesen. Die in der SMART-Plattform installierten xFIND Indexer Wrapper Agenten werden durch eine Anfrage an den SMART Facilitator ermittelt, und über den Choose Indexer Dialog ist es möglich einen der Vorhandenen Indexer zu wählen (siehe Abbildung 6.17). 6.4 Zusammmenfassung Das in diesem Kapitel dargestellte Szenario sieht auf den ersten Blick sehr einfach aus. Die beteiligten Agenten brauchen weder mit „Intelligenz“ ausgestattet werden, noch sind die Aufgaben die sie erfüllen müssen sehr komplex. Doch hat sich bei der praktischen Umsetzung gezeigt, dass es mit viel Aufwand verbunden ist, den Agenten selbst einfache Grundfunktionen wie z.B. das Speichern von Daten im Filesystem zu ermöglichen. Um dies dennoch zu erreichen mussten große Eingriffe an verschiedenen Stellen im Sourcecode des SMART-Prototyp gemacht werden. Jeder dieser Eingriffe konnte die Stabilität des gesamten Systems an anderer Stelle gefährden. Als weiteres Problem, dass bei der Umsetzung dieses Szenario identifiziert werden konnte ist, dass im SMART-Prototyp kein Eventhandling präsent ist, das die Koordination der Komponenten innerhalb eines Smart-Agenten doch erheblich vereinfachen würde. Auch dies wurde in einfacher Form nachgeholt. So können nun Komponenten innerhalb eines Agenten auf Java-Events von anderen Komponenten reagieren, was die Programmierung sehr vereinfacht. Diese Möglichkeit wird bereits in der Timerkomponente angewendet. Ein weiterer Problembereich der ersichtlich wurde ist, das der SMART-Prototyp keine Unterstützung für die persistente Speicherung von Agenten bietet. In der Praxis bedeutet dies, das bei jedem Neustart des Systems alle benötigten Agenten neu gestartet, und zusätzlich auch deren Daten neu generiert werden müssen, was einen erheblichen Aufwand bei selbst kleinen Änderungen bedeutet. Auch in dieser Hinsicht wurden einige Verbesserungen durchgeführt. Seite 107 Kapitel 6 Ein einfacher Informationsagent für SMART Obwohl die Umsetzung des hier vorgestellten einfachen Szenarios, aufgrund der vielen Problembereiche die sich dabei ergaben, nicht vollständig abgeschlossen wurde, ist der Autor dieser Arbeit nach wie vor davon überzeugt, dass die Konzepte die sich hinter SMART verbergen gut sind. Eines dieser Konzepte ist zum Beispiel die Widerverwendbarkeit von Komponenten. Ein Beispiel dafür ist die im Rahmen dieses SMART-Projekts entwickelte Timerkomponente, die es sehr komfortabel ermöglicht beliebige Zeitpunke und Zeitintervalle zu erstellen, und damit in verschiedensten Anwendungen einsetzbar ist. Der SMART-Prototyp stellt nur eine Basiskonfiguration dar, die erst durch das hinzufügen von Komponenten und Agenten zum „Leben“ erwacht. Wie auch in anderen Bereichen der Softwareentwicklung verbirgt sich dahinter aber ein langwieriger Entwicklungsprozess, der nicht im Rahmen von einer Diplomarbeit abgeschlossen ist, sondern kontinuierlich verbessert und weiterentwickelt werden muss. Seite 108 Kapitel 7 7 Zusammenfassung Das World Wide Web (WWW) mit seinen Möglichkeiten zur Veröffentlichung und Übertragung von Informationen hat die Palette der Anwendungen und Dienste für die Internetbenutzer enorm erweitert. Dies hat aber auch dazu geführt, dass die Menge an elektronisch verfügbarer Information in den letzten Jahrzehnten explosionsartig zugenommen hat. Aufgrund der weitgehend unstrukturierten Form des Internet, stellt die Wissensauffindung im Internet derzeit ein großes Problem für die Benutzer dar. Eine wichtige Hilfestellung leisten in diesem Zusammenhang die gegenwärtigen Suchdienste. Jedoch weisen diese eine Reihe von Schwächen auf. Sie stellen meist, für sich, isolierte Lösungen dar, die nicht in der Lage sind vorhandene Metainformationsdienste zu berücksichtigen bzw. zu kombinieren, bieten keine individuelle Unterstützung für die Benutzer und beliefern den Benutzer meist mit einer nahezu endlosen Liste an Suchergebnissen. In dieser Arbeit wurde der Einsatz von Agententechnologie untersucht, welche dazu dienen könnte oben geschilderte Probleme zu lösen. Dazu wurde die Arbeit in einen Untersuchungsteil und Gestaltungsteil gegliedert, wobei im Untersuchungsteil im Besonderen der Einsatz von Multiagentensystemen in diesem Bereich betrachtet wurde. Die daraus gewonnenen Erkenntnisse, flossen in die Konzeptionierung und prototypische Implementierung einer Agenten Plattform ein. Nach einer kurzen Einführung in die Thematik im ersten Kapitel, wurde im Kapitel 2 („Einführung und Begriffsbestimmung”) der Versuch unternommen den sehr unterschiedlich verwendeten Begriff „Agent” für den Kontext dieser Arbeit zu definieren. Dazu wurden unter anderem verschiedene Definitionen und Eigenschaften wie sie in der Literatur zu finden sind herangezogen. Zu den grundsätzlichen Eigenschaften eines Agenten zählen die Autonomie, die den Agenten befähigt selbständig zu handeln und zu entscheiden, die Reaktivität, die vom Agenten fordert angemessen auf Änderungen in seiner Umgebung zu reagieren, die Proaktivität, durch die Agenten in der Lage sind die Initiative zu übernehmen und dabei ein zielorientiertes Verhalten zu zeigen. Um diese Eigenschaften erfüllen zu können stehen Agenten in engem Kontakt mit ihrer Umwelt, mit „Sensoren“ nehmen sie ihre Umgebung wahr und beeinflussen ihre direkte Umgebung durch Aktivitäten. Doch Agenten stehen nicht nur mit ihrer direkten Umgebung in Kontakt, sondern sie kommunizieren auch mit anderen Agenten. In dieser Kommunikation stecken die stärken des Agenten Paradigmas. Es wird damit möglich Aufgaben an mehrere Agenten zu delegieren, die gemeinsam an der Lösung von Problemen arbeiten. Dabei treten allerdings sehr dynamische Kommunikationsmechanismen in Erscheinung, die nur durch die Verwendung spezieller Seite 109 Kapitel 7 Zusammenfassung Agentenkommunikationssprachen bewältigt werden können. Die genannten Eigenschaften machen den Einsatz von Agententechnologie in vielen Bereichen interessant. Einen großen Anwendungsbereich stellt dabei die Informationserschließung im Internet mittels so genannter Informationsagenten dar. Mit dieser Thematik beschäftigte sich Kapitel 3. Um den Bedarf an Unterstützung der Benutzer durch „intelligente“ Suchwerkzeuge zu unterstreichen wurden zunächst einige Problembereiche gängiger Suchdienste betrachtet und Studien vorgestellt, die sich mit den Benutzerverhalten im Umgang mit Suchdiensten befassen. Dabei lässt sich feststellen, dass Informationsagenten dem Benutzer in vielen Bereichen Unterstützung leisten könnten. Dazu zählen unter anderem die Organisation, Verwaltung und Darstellung, und vor allem das Filtern von relevanten Informationen, aber auch bei der Auswahl von Informationsquellen und bei der Formulierung bzw. Reformulierung von Suchanfragen könnten sie behilflich sein. Die Vorstellung einiger interessanter Beispiele von singulären Informationsagenten bzw. Informationsagenten innerhalb von Multiagentenumgebungen bildete den Abschluss dieses Kapitel, und stellt gleichzeitig auch die Motivation, für die im Rahmen dieser Diplomarbeit entwickelten Agenten Plattform dar. Im Hinblick auf den Entwurf einer Agenten Plattform befasste sich Kapitel 4 mit einigen ausgewählten Aspekten von Multiagentensystemen, und beendete damit den Untersuchungsbereich. Dazu wurden unter anderem die Eigenschaften solcher Systeme betrachtet. Weitere Schwerpunkte in diesem Kapitel bildeten die Agentenkommunikation, und die Agentenarchitekturen. Zum Schluss wurden noch einige Standarisierungsbemühungen in diesem Bereich vorgestellt. Aus diesen Betrachtungen ergaben sich folgende Erkenntnisse. Multiagentensysteme sind komplexe offene verteilte Systeme, die sich durch nichtdeterministisches Verhalten auszeichnen, und keiner zentralen Steuerung unterliegen. Durch Wissensaustausch und durch längerfristige Kooperationen werden so genannte „value-added services“ ermöglicht, eine Kombination einfacher Basisfunktionalitäten zu neuartigen. Bei der Kommunikation in Multiagentensystemen kommen heute vorwiegend sprechaktbasierte Agentenkommunikationssprachen zum Einsatz, durch die, im Gegensatz zur früher vorherrschenden Blackboard Kommunikation, auch eine direkte Kommunikation möglich ist. Gegenwärtig dominieren zwei Vertreter der sprechaktbasierten Kommunikationssprachen den Bereich der Agentenkommunikation, nämlich KQML (Knowledge Query and Manipulation Language) und FIPA-ACL. Abgestimmtes Handeln zwischen mehreren Agenten findet zumeist in Form von Interaktionsprotokollen statt. Eine zentrale Rolle bei der Kommunikation zwischen Agenten spielt die Ontologie, die den Wortschatz einer Anwendungs-Domäne definiert. Um den Kommunikationsaufwand zum Finden eines Kommunikationspartners zu mindern können so genannte FacilitatorAgenten eingesetzt werden, die einen „Yellow Pages“-Dienst anbieten, dabei entsteht ein so genanntes föderiertes System. Der Bereich der Standardisierung ist noch nicht sehr weit Fortgeschritten. Die aktivste Organisation in dieser Hinsicht bildet nach Meinung des Autors, der hier vorliegenden Arbeit die FIPA (Foundation for Intelligent Physical Agents). Im Gestaltungsbereich wurde mit Hilfe der herausgearbeiteten Erkenntnisse in Zusammenarbeit mit Steffan Kernbauer eine Agenten Plattform mit dem Namen SMART spezifiziert und prototypisch implementiert. Ziel von SMART war es, eine allgemeine Infrastruktur zur Realisierung von Multiagentensystemen zu schaffen, die nicht an bestimmte Anwendungsdomänen gebunden sind. Als Bausteine zur Entwicklung dienten Seite 110 die Programmiersprache Java und das am IICM Graz entwickelte Framework „Dino” (Distributed interactive Network Objects). Vor allem die Verwendung von Dino erwies sich als besonders sinnvoll, da von Dino die notwendige Basistechnologie bereitgestellt wird. Durch Dino wird ein gemeinsamer Adressraum für verteilte Objekte geschaffen, die dadurch transparent ansprechbar werden. Über Dino können Objekte aufeinander zugreifen und die jeweiligen Funktionen nützen. Auch die Entwicklung von mobilen Agenten wird durch Dino stark vereinfacht, da Dino Objekte per Definition mobile Objekte sind, die durch einfache Move oder Copy Befehle im Adressraum bewegt werden können. SMART Agenten bestehen aus Komponenten, die je nach Anforderung kombiniert werden. Das Zusammenfügen der Komponenten wird dabei automatisch vom System übernommen. Im SMART Prototyp ist eine Kombination von bis zu fünf Komponententypen vorgesehen, wobei ein zentraler Komponententyp (Functional Component) definiert ist, der durch Zusatzkomponenten ergänzt werden kann. Die Agenten (und somit deren Komponenten) werden sowohl direkt durch den Benutzer, als auch nach deren erbrachter Dienstleistungen bewertet, da SMART Agenten ihre Dienste Benutzern und auch anderen Agenten anbieten können. Im SMART System können gestellte Aufgaben nicht nur durch einen einzelnen Agenten erfüllt werden, sondern sie können durch Zusammenarbeit vieler Agenten erledigt werden. Die Zusammenarbeit von SMART Agenten wird durch zwei Arten von Kommunikation ermöglicht. Die einfachste Art der Kommunikation ist ein Methodenaufruf. So können Agenten über einen Wrapper auf die Methoden eines anderen Agenten zugreifen, vorausgesetzt die Methoden sind bekannt. Sind Methoden nicht bekannt, so können Agenten über den Austausch von Fipa-ACL Nachrichten kommunizieren. Der zweifache Kommunikationsansatz ist in jedem Fall sinnvoll, da nicht immer hochwertige Kommunikation mittels Nachrichten benötig wird und man auch durch einen einfachen Methodenaufruf Informationen übermitteln, oder Funktionen anfordern kann. Als erste Anwendungen der SMART Plattform wurden Agenten für ein E-Commerce Szenario entwickelt. Ein weiteres Szenario, in dem ein Informationsagent mit dem am IICM entwickelten Suchsystem xFIND kommuniziert wurde in Kapitel 6 dieser Arbeit beschrieben. Wie sich dabei gezeigt hat, treten bei der praktischen Umsetzung von solchen „SMART-Projekten“ kleinere und größere Probleme auf, die in Folgendem Unterkapitel kurz beschrieben werden 7.1 Erkenntnisse und Ausblick Als größeres Problem stelle sich heraus das der SMART-Prototyp keine Unterstützung für die persistente Speicherung von Agenten bietet. In der Praxis bedeutet dies, das bei jedem Neustart des Systems alle benötigten Agenten neu gestartet, und zusätzlich auch deren Daten neu generiert werden müssen, was einen erheblichen Aufwand bei selbst kleinen Änderungen bedeutet. Im SMART Prototypen fehlt die Anbindung an eine Datenbank, diese könnte z.B. von der Componentbase, der Agentbase und dem Directory Facilitator genutzt werden. Derzeit werden die Daten der Componentbase und der Agentbase in ein File geschrieben, Seite 111 Kapitel 7 Zusammenfassung der Directory Facilitator hält seine Daten nur im Hauptspeicher. Durch die Verwendung einer Datenbank könnte auch die vorher angesprochene persistente Speicherung von Agenten einfacher umgesetzt werden. Das FIPA Gateway wurde vorerst nicht implementiert, da es nicht zur zentralen Funktionalität gerechnet wurde. Dieses Gateway würde eine Kommunikation der SMART Agenten mit fremden FIPA-konformen Agenten ermöglichen. Im Gegensatz zum Konzept wurde der SMART Prototyp als „lokale” Version implementiert. Sowohl User Interface Agent, als auch das Administration Tool und die SMART Plattform werden in der gleichen virtuellen Maschine gestartet, d.h. sie befinden sich am selben lokalen Host. Dies wirkt sich sehr negativ auf die Performance aus. Als grundsätzliche Weiterentwicklung des SMART Prototypen, wäre die Entwicklung eines „verteilten” SMART Prototypen zu sehen. Verschiedene SMART Plattformen müssten über Dino kombiniert werden, um den vollen Umfang des SMART Konzeptes erproben zu können. Rückmeldungen und die Ergebnisse der Agenten erhält der User in Form einer Nachricht (SUsermessage). Diese sind im SMART Prototypen sehr einfach gehalten. Auch hier wäre eine Erweiterung denkbar. Zum Beispiel könnte ein „Mail” System Agent die Nachricht als Email versenden oder ein „Web-Server” System Agent könnte die Nachricht auf einem Webserver in Form eines HTML Files speichern, wodurch die Rückmeldung mit einem normale WebBrowser gelesen werden könnten. Im SMART Prototyp wurden 5 Kategorien von Komponenten spezifiziert. Dies ist ein sehr restriktiver Ansatz. In einer Weiterentwicklung des SMART Systems müsste diese Kategorisierung aufgebrochen und offener gestaltet werden. Abschließend kann gesagt werden, dass der SMART Prototyp eben nur einen Prototyp mit einer Basiskonfiguration und Basisfunktionalität darstellt. Die Idee von SMART ist, diese Basis durch das hinzufügen von Komponenten und Agenten zu erweitern. Wie auch in anderen Bereichen der Softwareentwicklung verbirgt sich dahinter aber ein langwieriger Entwicklungsprozess, der nicht im Rahmen von einer Diplomarbeit abgeschlossen ist, sondern kontinuierlich verbessert und weiterentwickelt werden muss. Seite 112 Seite 113 Abbildungsverzeichnis Abbildungsverzeichnis Abbildung 2.1: Datenstrukturen, Objekte und Agenten aus [Schimkat 2003] nach [Joseph et al. 2001] ........................................................................................ 17 Abbildung 2.2: Typologie nach Nwana [Nwana 1996] ......................................... 22 Abbildung 2.3: Die Funktionsweise von Interfaceagenten aus [Maes 1994] ........ 23 Abbildung 3.1: Einfaches Information Access Modell; aus [Guetl 2004] nach [Baeza et al. 1999] ......................................................................................... 33 Abbildung 3.2: Visualisierung der Verhaltensmuster bei der Informationssuche in Unternehmen nach [Choo et al. 2000], aus [Guetl 2004] .............................. 36 Abbildung 3.3: Beziehungsgeflecht der Suchdienste in Deutschland und International (Stand 10.06.2004) [Suchfibel 2004] ....................................... 37 Abbildung 3.4: Makrostruktur eines Systems von kooperativen Informationsagenten [Klusch 2001] .............................................................. 39 Abbildung 3.5: Letizia integration in Netscape-Interface [Liebermann 1997] ..... 41 Abbildung 3.6: Struktur des Multiagentensystems InfoSleuth [Nodine et al. 1999], aus [Klusch 2001] .......................................................................................... 42 Abbildung 3.7: RETSINA-Architektur eines kooperativen Agentensystems [Sycara et al 1996], aus [Klusch 2001] .......................................................... 44 Abbildung 3.8: Schichtenmodell in Daffodil [Fuhr 2000] .................................... 46 Abbildung 3.9: Klassenhierarchie für Anfrageobjekte in Daffodil [Fuhr 2000] ... 47 Abbildung 4.1: Prizip der Blackboard Kommunikation [Schneeberger 2001b] ... 53 Abbildung 4.2: Einordnung der Sprechakte nach Austin [Austin 1985] ............... 54 Abbildung 4.3: Beispiel einer KQML-Nachricht [Schneeberger 2001b] .............. 55 Abbildung 4.4: Schichtstruktur einer KQML-Nachricht [Schneeberger 2001b] .. 55 Abbildung 4.5: Ein Einfacher Frage-Antwort-Dialog mittels KQML [Schneeberger 2001b] .................................................................................... 56 Abbildung 4.6: Agent A abonniert bei Broker V alle Informationen über X [Schneeberger 2001b] .................................................................................... 56 Abbildung 4.7: Ein etwas komplexerer Dialog mittels KQML [Schneeberger 2001b] ............................................................................................................ 57 Abbildung 4.8: Ablauf der Kommunikation zwischen Manager und Kontraktor innerhalb des Contract-Net-Protokolls [Schneeberger 2001b] ...................... 58 Abbildung 4.9: FIPA Iterated Contract Net-Protokoll [Fipa 2002a] ..................... 59 Abbildung 4.10: FIPA Protokoll einer englischen Auktion [Fipa 2002b] ............. 60 Abbildung 4.11: Service Broker und Matchmaker [Klusch 2001] ........................ 62 Abbildung 4.12: Agenten in einem föderierten System [Fricke 2000] .................. 62 Abbildung 4.13: Prinzipieller Aufbau einer Komponentenarchitektur [Fricke 2000] .............................................................................................................. 64 Abbildung 4.14: Prinzipieller Aufbau einer Schichtstruktur [Fricke 2000] .......... 65 Abbildung 4.15: Strukturarmer Aufbau einer Agentenarchitektur [Fricke 2000] . 66 Abbildung 5.1: Das SMART Agentensystem [Kernbauer 1999] .......................... 74 Abbildung 5.2: Die Dino Struktur [Dino 1998] ..................................................... 75 Seite 114 Abbildung 5.3: Das FIPA Referenzmodell [Fipa 1997] ........................................ 77 Abbildung 5.4: Das SMART Agentensystem [Kernbauer 1999] .......................... 78 Abbildung 5.5: Die SMART Plattform [Kernbauer 1999] .................................... 81 Abbildung 5.6: Der SAgent Wrapper [Kernbauer 1999] ....................................... 84 Abbildung 6.1:Verteilte Architektur des xFIND Suchsystems [Gütl 2002] .......... 92 Abbildung 6.2: Die Kommunikationsbeziehungen im xFIND Beispielszenario .. 94 Abbildung 6.3: Der SMART UserManagerFrame ................................................ 96 Abbildung 6.4: Der SMART Add User Dialog ..................................................... 97 Abbildung 6.5: Der SMART Login Dialog ........................................................... 97 Abbildung 6.6: Das SMART Admin Tool............................................................. 98 Abbildung 6.7: Der SMART USER INTERFACE AGENT ................................. 98 Abbildung 6.8: Der SMART Systemcomponents Dialog ..................................... 99 Abbildung 6.9: Der Choose Class Dialog ............................................................ 100 Abbildung 6.10: Der Add Component Dialog ..................................................... 100 Abbildung 6.11: Der SMART Agentbase Systemagents Dialog ......................... 101 Abbildung 6.12: Der SMART Add Agent to Agentbase Dialog ......................... 102 Abbildung 6.13: Der Choose from Agentbase Dialog ......................................... 103 Abbildung 6.14: Der My Agents Dialog ............................................................. 103 Abbildung 6.15: Das xFIND Indexer Wrapper Interface .................................... 104 Abbildung 6.16: Das Userinterface der Timer Komponente ............................... 105 Abbildung 6.17: Das Userinterface der What's New Komponente ..................... 105 Abbildung 6.18: Der SMART Assistent .............................................................. 106 Seite 115 Literaturverzeichnis Literaturverzeichnis [Baeza et al. 1999] Baeza-Yates, R.; Ribeiro-Neto, B.: Modern Information Retrieval, Addison Wesley, Essex, England, 1999 [Bates 1994] J. Bates: The role of emotion in believable agents. Communications of the ACM, 1994, 37(7), S. 122 - 125. [Bigus et al. 2001] Joseph Bigus, Jennifer Bigus; Intelligente Agenten mit Java Programmieren; Addison Wesley 2001 [Bradshaw 1997] Jeffrey M. Bradshaw: Software Agents AAAI Press / The MIT Press 1997, 3-46 [Brando 1995] T. Brando: Comparing DCE and CORBA. Technical report MP 95B93,MITRE Corporation, März 1995, http://www.mitre.org/research/domis/reports/DCEvCORBA.html. [Brenner et al. 1998] Brenner, W.; Zarnekow, R.; Wittig, H.: Intelligente Softwareagenten, Springer Verlag, Berlin, 1998 [Burkhard 1998] Hans Dieter Burkhard: Einführung in die Agententechnologie it+ti Informationstechnik und Technische Informatik; Zeitschrift; Heft 4/98; R.Oldenburg Verlag 1998 6-11 [Caglayan 1998] Caglayan, A.K., Harrison, C.G.: Intelligente Software-Agenten, München/Wien 1998 [Cheong 1996] F. Cheong, Internet Agents: Spiders, Wanders, Brokers, and Bots. Indianapolis: New Riders, 1996. [Choo et al. 2000] Choo, C.W.; Detlor, B.; Turnbull, D.: Working With Knowledge. In Proceedings of CONSAL 2000, Congress of Southeast Asian Librarians, Singapore, April, 2000, http://donturn.fis.utoronto.ca/papers/hicss2000/hicss2000.html [Ciancarini et al. 2000] Ciancarini, P. and Wooldridge, Agent-oriented software engineering In Proceedings of the 22nd international Conference on Software Engineering (Limerick, Ireland, June 04 - 11, 2000). ICSE '00. ACM Press, New York, NY, 816-817. [Davis et al. 1983] R. Davis, R. G. Smith: Negotiation as a metaphor for distributed problem solving. AI Journal 20, 1983, S. 63 - 109. [Ferber 2001] Ferber, J.: Multiagentensysteme, Addison-Wesley-Verlag, München, 2001 [Fipa 2002a] FIPA Iterated Contract Net Interaction Protocol Specification, http://www.fipa.org/specs/SC00030H.pdf Seite 116 [Fipa 2002b] FIPA: The FIPA English Auction interaction protocol Specification, http://www.fipa.org/specs/ XC00031F.pdf [Fipa 2002c] FIPA: FIPA Dutch Auction Interaction Protocol Specification, Last Visit: 30.9.2005 http://www.fipa.org/specs/ XC00032F.pdf [Franklin et al. 1996] S. Franklin, A. Graesser: Is it an agent, or just a program? A taxonomy for autonomous agents. In: Third International Workshop on Agent Theories, Architectures, and Languages, Springer-Verlag, 1996. [Fricke 2000] Stefan Fricke: Werkzeuggestützte Entwicklung kooperativer Agenten im Dienstkontext, Dissertation an der Technischen Universität Berlin 2000, 04.2000; Last Visit: 30.7.2005 http://edocs.tu-berlin.de/diss/2000/fricke_stefan.pdf [Fuhr 2000] Norbert Fuhr; „Information Retrieval – Skriptum zur Vorlesung“; 2000; Last Visit: 09.06.2005 http://www.is.informatik.uni-duisburg.de/teaching/dortmund/lectures/ ir_ws00-01/irskall.pdf [Gilbert 1997] D. Gilbert: Intelligent agents - the right information at the right time. White paper, IBM, 1997 . http://www.networking.ibm.com/iag/iaghome.html. [Gütl 2002] Gütl, C.: Ansätze zur modernen Wissensauffindung im Internet, Dissertation an der Technischen Universität Graz, IICM, 09.2002, Last Update: 29.11.2002, Last Visit: 30.7.2005; http://www.iicm.edu/thesis/cguetl_diss/diss_cguetl.pdf [Gütl 2004] Gütl, C.: Smart Information Retrieval Concepts for Portals in Scientific Environments 09.2004, Last Update: 29.11.2004, Last Visit: 30.7.2005; http://www.iicm.edu/cguetl/publikations/SmartIR_v1_1.pdf [Jennings et al. 1998a] Jennings, N. R., Sycara, K., and Wooldridge, M. 1998. A Roadmap of Agent Research and Development. Autonomous Agents and Multi-Agent Systems 1, 1 (Jan. 1998), 7-38. [Jennings et al. 1998b] Jennings, N. R., Wooldridge, M. J. (Hrsg.), Applications of Intelligent Agents, in: Agent Technology - Foundations, Applications, and Markets, Springer-Verlag, Heidelberg 1998 [Jenkins et al. 2000] Jenkins, C.; Inman, D.: Adaptive Automatic Classification on the Web;Proceedings of the 11th International Workshop on Database and Expert Systems Applications (DEXA'00), 2000 [Joseph et al.2001] JOSEPH, S. und T. KAWAMURA: Why Autonomy Makes the Agent. In: Series in Machine Perception and Artificial Intelligence Agent Engineering, Band 43. World Scientific, Juni 2001. [Kernbauer 1999] Kernbauer, S.: Aspekte Intelligenter Software Agenten, IICM TU-Graz, September 1999, TU-Graz Hauptbibliothek II 128.100 Seite 117 Literaturverzeichnis [Klusch 2001] M. Klusch. Information agent technology for the internet: A survey. Data and Knowledge Engineering, 36(3):337--372, 2001 [Lackner 2004] Lackner, W.: Verteilte Informationsstrukturen zur modernen Wissensauffindung im Internet, IICM TU-Graz, Dezember 2004, Last Visit: 16.06.2005; http://www.iicm.edu/thesis/wlackner [Liebermann 1997] H. Liebermann. Autonomous interface agents. In Proc. ACM Conf. on Computers and HumanInteraction (CHI'97), Atlanta, USA, May 1997 [Lingnau et al. 1995] Lingau, A., Drobnik, O. and Doemel, P.: An HTTP-based Infastrukture for Mobile Agents, World Wide Web Journal, Boston 1995. [Nodine et al. 1999] Nodine, M.; Fowler, J. (1999): An overview of active information gathering in Infosleuth. Proc. Intern. Conference on Autonomous Agents, USA, AAAI Press. [Nwana 1996] H. S. Nwana: Software agents: An overview. Knowledge Engineering Review 11(3), 1996, S. 205 - 244. [Machill et al. 2004] Marcel Machill, Carsten Welp: Wegweiser im Netz 3. Auflage 2004; Bertelsmann Verlag [Maes 1994] Maes, P.. Agents that reduce work and information overload. Commun. ACM 37, 7 (Jul. 1994), 30-40. [Maes 1995] Maes, P.: Artificial Life meets Entertainment: Interacting with Lifelike Autonomous Agents, Special Issue on New Horizons of Commercial and Industrial AI. Communications of the ACM 38 (1995) 11, S. 108114. [Minsky 1985] Minsky, M.. The Society of Mind. New York: Simon and Schuster. 1985 [Middleton 2001] Stuart E. Middleton: Interface Agents: A review of the field Technical report, 28 pages, August 2001 Last Update: 10.08.2001, Last Visit: 30.7.2005; http:citeseer.ist.psu.edu/middleton01interface.html [Murch et al. 2000] Richard Murch, Tony Johnson: Agententechnologie die: Die Einführung; Addison-Wesley 2000 [Müller 1998] Jörg Müller: Kontrollarchitekturen für autonome kooperierende Agenten it+ti Informationstechnik und Technische Informatik; Zeitschrift; Heft 4/98; R.Oldenburg Verlag 1998 18-22 [Reiff 2000] Reiff G.: Moderne Aspekte der Wissensverarbeitung Diplomarbeit an der Technischen Universität Graz, IICM, Jänner 2000 http://www.iicm.edu/thesis/greif [Russell et al.1995] Russell, Stuart J. and Peter Norvig:, Artificial Intelligence: A Modern Approach, Englewood Cliffs, NJ: Prentice Hall 1995 Seite 118 [Schimkat 2003] Ralf-Dieter Schimkat: Techniken und Aspekte zur Realisierung proaktiver Informationssysteme, Dissertation an der Eberhard-KarlsUniversität Tübingen Last Update: 12.02.2003, Last Visit: 30.08.2005 http://w210.ub.unituebingen.de/dbt/volltexte/721/diss_schimkat.pdf [Schneeberger 2001a] Josef Schneeberger: Software Agenten I, Last Visit: 30.7.2005; http://www.bw.fh-deggendorf.de/kurse/ws/skripten/skript12.pdf [Schneeberger 2001b] Josef Schneeberger: Software Agenten II, Last Visit: 30.7.2005; http://www.bw.fh-deggendorf.de/kurse/ws/skripten/skript13.pdf [Schneppe 2000] Ulrich Schneppe: Langzeitrecherche im World-Wide-Web unter Berücksichtigung von Individualisierungskonzepten Diplomarbeit an der Fern Universität Hagen; Juli 2000 [Sycara et al. 1996] Pannu, A.; Sycara, K. (1996): A learning personal agent for text filtering and notification. Proc. Intern. Conference on Cooperative Knowledge-based Systems CKBS-96. [Teuteberg 1999] Frank Teuteberg: Agentenbasiertes Suchen, Filtern und Klassifizieren von Informationsangeboten im World Wide Web unter Einsatz von Künstlichen Neuronalen Netzen und Neuro-Fuzzy-Technologien; Last Visit:30.9.2005 http://wi99.iwi.unisb.de/de/DoktorandenSeminar/D_Teuteberg.pdf [Wayner et al. 1995] Wayner, P.; Joch, A.: Agents of Change in Byte (20) 3. McGrawHill, New-York, USA 1995. [Wooldridge et al. 1995] Michael Wooldridge, Nicholas R. Jennings: Intelligent Agents: Theory and Practice; Springer 1995 [Yang et al. 1996] Z. Yang, K. Duddy: CORBA: A platform for distributed object computing. Operating Systems Review 30(2), 1996, S. 4 - 31.
