Tekoäly on siirtynyt suljetuista laboratorioista arkipäivän sovelluksiin, ja nyt entistä useammat organisaatiot, tutkijat ja harrastajat voivat rakentaa omia AI-agenttejaan erilaisiin käyttötarkoituksiin. Olipa kyseessä asiakaspalvelun automaatio, oppimisen personointi, data-analyysin tehostaminen tai pelien pelimoottorit, AI-agentti voi toimia älykkäänä apurina tai itsenäisenä päätöksentekijänä.

Tämä sivu toimii oppaana tekoälyagenttien rakentamiseen – alkaen perustavanlaatuisista konsepteista, edeten työkaluihin ja arkkitehtuureihin, ja lopulta siihen, miten voit itse toteuttaa agentin, joka havainnoi, oppii, päättää ja toimii omassa ympäristössään.

Sivulta löydät:

• Mitä AI-agentit ovat ja miten ne eroavat tavallisesta ohjelmoinnista
• Miten suunnitellaan agentin tavoitteet, toimintalogiikka ja oppimismekanismit
• Millä työkaluilla ja alustoilla agentteja voi rakentaa (esim. LangChain, AutoGPT, Python + open source -kirjastot)
• Tietoturva- ja eettiset näkökulmat AI-agentin kehityksessä
• Case-esimerkkejä: agentti asiakaspalvelussa, agentti tutkimusapuna, agentti dataa puhdistamassa

Tavoitteena on tarjota selkeä, käytännönläheinen ja innostava reitti tekoälyagentin rakentamiseen – myös sinulle, vaikkei taustalla olisi syvää koneoppimisen koulutusta.

Aloitetaan perusasioista: mitä agentti tarvitsee toimiakseen ja miten saat ensimmäisen agenttisi valmiiksi jo tänään!

AI-agenttien rakentamisen työkalut – esimerkkejä ja käyttötapoja

Jos haluat hypätä suoraan tekoälyagenttien luomiseen, tässä on joukko käytännöllisiä ja suosittuja työkaluja, joilla voit toteuttaa monipuolisia agenttirakenteita:

LangChain

• Suunniteltu erityisesti kielimallien ympärille rakennettavien agenttien tekoon
• Mahdollistaa ketjutettujen toimintojen, muistien, työkalujen ja agenttien hallinnan
• Yhteensopiva OpenAI:n, Anthropicin, Hugging Facen ja monien muiden mallien kanssa

AutoGen (Microsoft)

• Avoimen lähdekoodin framework, joka mahdollistaa agenttien välistä yhteistyötä ja keskustelua
• Sopii monimutkaisten monivaiheisten tehtävien ratkaisuun useamman agentin kautta
• Hyödyntää mm. GPT-malleja työtehtävien suorittamiseen

AutoGPT / AgentGPT

• Luo itsenäisesti toimivia agentteja, joille voi antaa tehtävän ja ne pyrkivät toteuttamaan sen vaiheittain
• Sopivat kokeellisiin ja tutkimuksellisiin tarkoituksiin
• Vaatii yleensä teknistä osaamista ja API-avaimen kielimalliin

Python + open source -kirjastot

• Esim. transformers, langchain, openai, sentence-transformers, faiss jne.
• Voit rakentaa täysin omia agenttikonsepteja – havainto, muisti, päätöksenteko ja toiminta kaikki koodattuna

Rasa

• Hyvä erityisesti chatbot-agenttien rakentamiseen
• Tukee luonnollisen kielen ymmärtämistä, dialogin hallintaa ja koneoppimista
• Soveltuu tuotantotason sovelluksiin ja integroituu muihin järjestelmiin

Web- ja API-integraatiot

• Agentteja voidaan yhdistää muihin palveluihin esim. hakukoneisiin, tietokantoihin tai käyttöliittymiin
• Web scraping, API-kutsut ja ulkoisten työkalujen integrointi agentin päätöksenteon tueksi

Käyttöesimerkki:
Voisit rakentaa agentin, joka toimii “virtuaalisena tutkijana”: se etsii tietoa verkosta, tiivistää sen, vertailee lähteitä ja laatii yhteenvedon. Tähän voisi käyttää LangChainia + OpenAI GPT + Pythonin requests + BeautifulSoup.

Python-pohjainen itse koodattu AI-agentti:

Tässä on yksinkertainen mutta toimiva Python-pohjainen AI-agentti, joka pystyy:

1. Saamaan tehtävän käyttäjältä
2. Hakemaan tietoa webistä (yksinkertaisesti simuloiden)
3. Antamaan yhteenvedon vastauksena

Tämä on pelkistetty malli, mutta se antaa hyvän käsityksen agentin rakenteesta:

import random

class SimpleAIAgent:
    def __init__(self, name):
        self.name = name
        self.knowledge_base = {}

    def receive_task(self, task):
        print(f"{self.name} sai tehtävän: '{task}'")
        self.search_information(task)

    def search_information(self, query):
        # Simuloidaan tiedonhakua
        print(f"{self.name} etsii tietoa aiheesta: '{query}'...")
        # Tässä voisi käyttää esim. langchainia, openai-apia tai web-scrapingia
        info = self.simulated_web_search(query)
        self.knowledge_base[query] = info
        self.summarize_information(query)

    def simulated_web_search(self, query):
        possible_answers = [
            f"Aiheeseen '{query}' liittyy paljon mielenkiintoista tutkimusta.",
            f"{query} on keskeinen osa nykyaikaista teknologiaa.",
            f"{query} voi viitata useisiin eri sovelluksiin riippuen kontekstista."
        ]
        return random.choice(possible_answers)

    def summarize_information(self, query):
        summary = self.knowledge_base[query]
        print(f"Yhteenveto aiheesta '{query}': {summary}")

# Agentin käyttö:
agentti = SimpleAIAgent("TekoBot")
agentti.receive_task("Tekoälyn soveltaminen lääketieteessä")

Miten tätä voi kehittää eteenpäin?

• Käytä oikeita web-hakutyökaluja kuten requests + BeautifulSoup
• Integroi GPT-malli (OpenAI API) yhteenvedon tekoon
• Lisää muistimekanismi (LangChainin memory)
• Lisää tehtävien priorisointi, arviointi ja jakaminen usealle agentille (Multi-agent setup)

Kehittyneempi Python AI-agentti esimerkki:

Tässä kehittyneempi versio aiemmasta, joka käyttää:

1. GPT-kielimallia tekstin generointiin
2. Dialogia ja yksinkertaista vuorovaikutusta
3. Muistia, jotta se muistaa aiempia keskusteluja

import openai

class ConversationalAgent:
    def __init__(self, name, api_key):
        self.name = name
        self.api_key = api_key
        self.memory = []  # Muistilista vuorovaikutukseen
        openai.api_key = self.api_key

    def receive_input(self, user_input):
        print(f"Käyttäjä: {user_input}")
        self.memory.append(f"User: {user_input}")
        response = self.generate_response()
        print(f"{self.name}: {response}")
        self.memory.append(f"Agent: {response}")

    def generate_response(self):
        prompt = "\n".join(self.memory) + f"\n{self.name}:"
        completion = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",  # tai "gpt-4" jos saatavilla
            messages=[{"role": "system", "content": "Olet ystävällinen keskusteluagentti."},
                      {"role": "user", "content": prompt}]
        )
        return completion.choices[0].message['content']

# Käyttö:
# Vaihda 'YOUR_OPENAI_API_KEY' omaan avaimeseesi!
agentti = ConversationalAgent("TekoBot", api_key="YOUR_OPENAI_API_KEY")

# Agentti keskustelee
agentti.receive_input("Hei! Mitä voit tehdä?")
agentti.receive_input("Kerro minulle tekoälystä ja sen sovelluksista.")

Mitä tämä agentti tekee ja miten se toimii?

Ominaisuus	Selitys
Keskustelu	Käyttäjä syöttää tekstiä, agentti vastaa
Muisti	Agentti tallentaa keskustelun vuorot, jolloin se muistaa aiemmat jutut
GPT-vastaus	Agentti käyttää oikeaa kielimallia (GPT) tekstin ymmärtämiseen ja tuottamiseen
API-avain	Tarvitset OpenAI:n API-avaimen, jotta agentti voi käyttää kielimallia

Selkokielinen esitys agentin toiminnasta

• Kun kirjoitat agentille jotain, se tallentaa viestin ja muodostaa “keskusteluhistorian”.
• Agentti muodostaa uuden vastauksen GPT-mallin avulla.
• Koska se muistaa aiemmat viestit, se voi vastata kontekstiin sopivalla tavalla.
• Jokainen uusi viesti lisätään muistiin, jolloin dialogi jatkuu luonnollisesti.

Monipuolinen AI-agentti python koodilla:

Tehdään monipuolinen AI-agentti, joka osaa:

1. Tehdä web-hakuja
2. Kommunikoida verkkopalvelujen kanssa (API)
3. Lukea ja jäsentää PDF-dokumentteja
4. Toimia ikkunasovelluksena (graafinen käyttöliittymä)

Käytämme tuttuja Python-kirjastoja: openai, requests, PyPDF2, tkinter ja webbrowser. Tässä koko agentin runko selityksineen:

import openai
import requests
import PyPDF2
import tkinter as tk
from tkinter import filedialog
import webbrowser

class MultiToolAgent:
    def __init__(self, name, api_key):
        self.name = name
        openai.api_key = api_key
        self.memory = []

    def chat_with_user(self, user_input):
        self.memory.append({"role": "user", "content": user_input})
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "system", "content": "Olet monipuolinen apuagentti."}] + self.memory
        )
        reply = response.choices[0].message["content"]
        self.memory.append({"role": "assistant", "content": reply})
        return reply

    def web_search(self, query):
        print(f"Tehdään haku: {query}")
        webbrowser.open(f"https://www.google.com/search?q={query}")

    def call_api(self, url):
        try:
            response = requests.get(url)
            return response.json() if response.headers["Content-Type"] == "application/json" else response.text
        except Exception as e:
            return f"Virhe API-kutsussa: {e}"

    def read_pdf(self, path):
        try:
            with open(path, 'rb') as file:
                reader = PyPDF2.PdfReader(file)
                text = ''
                for page in reader.pages:
                    text += page.extract_text()
            return text
        except Exception as e:
            return f"PDF-lukuvirhe: {e}"

#  Graafinen käyttöliittymä (GUI):
def run_gui():
    agent = MultiToolAgent("TekoBot", api_key="YOUR_OPENAI_API_KEY")

    def handle_input():
        user_input = entry.get()
        result = agent.chat_with_user(user_input)
        output.delete(1.0, tk.END)
        output.insert(tk.END, result)

    def handle_pdf():
        path = filedialog.askopenfilename(filetypes=[("PDF Files", "*.pdf")])
        text = agent.read_pdf(path)
        output.delete(1.0, tk.END)
        output.insert(tk.END, text)

    def handle_search():
        query = entry.get()
        agent.web_search(query)

    def handle_api():
        url = entry.get()
        result = agent.call_api(url)
        output.delete(1.0, tk.END)
        output.insert(tk.END, str(result))

    window = tk.Tk()
    window.title("TekoBot Agentti")
    entry = tk.Entry(window, width=50)
    entry.pack()

    tk.Button(window, text="Puhu agentin kanssa", command=handle_input).pack()
    tk.Button(window, text="Tee Google-haku", command=handle_search).pack()
    tk.Button(window, text="Lue PDF-tiedosto", command=handle_pdf).pack()
    tk.Button(window, text="Soita API-osoitteeseen", command=handle_api).pack()

    output = tk.Text(window, height=20, width=60)
    output.pack()
    window.mainloop()

# Käynnistä käyttöliittymä
run_gui()

Mitä agentti osaa tehdä?

Ominaisuus	Toiminta
Keskustelu	Käyttää GPT-mallia vastauksiin käyttäjän viesteihin
Web-haku	Avaa selaimessa Google-haun
API-kutsu	Hakee sisältöä ulkoisesta verkkopalvelusta
PDF-luku	Poimii tekstin PDF-tiedostosta ja näyttää sen
GUI	Tarjoaa graafisen käyttöliittymän nappeineen

Selitykset peruskäyttäjille

• openai.ChatCompletion.create käyttää kielimallia – syötät viestin, saat älykkään vastauksen.
• webbrowser.open avaa Googlen haun selaimessa.
• requests.get kutsuu verkkopalvelun (API), esim. säätiedot tai uutisfeedin.
• PyPDF2 lukee PDF-tiedoston sisältä ja poimii tekstin.
• tkinter luo ikkunan, jossa voit syöttää viestejä, klikata nappeja ja nähdä vastaukset.

Vielä hiukan kehittyneempi esimerkki Python koodilla:

Nyt päivitetään meidän monitoimi-AI-agentti niin, että se osaa:

• Puhua ääneen käyttäjän kanssa (tekstistä puhetta)
• Kääntää tekstiä eri kielille (esim. suomi ↔ englanti)
• Hakea YouTube-videoita hakusanan perusteella

Käytettävät lisäkirjastot

Kirjasto	Tarkoitus
pyttsx3	Puheominaisuus (tekstistä puheeksi)
googletrans	Käännökset eri kielille
youtube_search	YouTube-haku hakusanalla

Ennen käyttöä: Asenna nämä komennolla:

pip install pyttsx3 googletrans==4.0.0-rc1 youtube-search-python

import openai
import requests
import PyPDF2
import tkinter as tk
from tkinter import filedialog
import webbrowser
import pyttsx3
from googletrans import Translator
from youtubesearchpython import VideosSearch

# AI-agentin määrittely
class MultiToolAgent:
    def __init__(self, name, api_key):
        self.name = name
        openai.api_key = api_key
        self.memory = []
        self.speaker = pyttsx3.init()
        self.translator = Translator()

    def chat_with_user(self, user_input):
        self.memory.append({"role": "user", "content": user_input})
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "system", "content": "Olet monipuolinen apuagentti."}] + self.memory
        )
        reply = response.choices[0].message["content"]
        self.memory.append({"role": "assistant", "content": reply})
        return reply

    def speak(self, text):
        self.speaker.say(text)
        self.speaker.runAndWait()

    def translate_text(self, text, target_lang="en"):
        translated = self.translator.translate(text, dest=target_lang)
        return translated.text

    def web_search(self, query):
        webbrowser.open(f"https://www.google.com/search?q={query}")

    def call_api(self, url):
        try:
            response = requests.get(url)
            return response.json() if response.headers["Content-Type"] == "application/json" else response.text
        except Exception as e:
            return f"Virhe API-kutsussa: {e}"

    def read_pdf(self, path):
        try:
            with open(path, 'rb') as file:
                reader = PyPDF2.PdfReader(file)
                text = ''
                for page in reader.pages:
                    text += page.extract_text()
            return text
        except Exception as e:
            return f"PDF-lukuvirhe: {e}"

    def youtube_search(self, query):
        search = VideosSearch(query, limit=3)
        results = search.result()["result"]
        links = [f"{vid['title']}: {vid['link']}" for vid in results]
        return "\n".join(links)

# Graafinen käyttöliittymä
def run_gui():
    agent = MultiToolAgent("TekoBot", api_key="YOUR_OPENAI_API_KEY")

    def handle_input():
        user_input = entry.get()
        result = agent.chat_with_user(user_input)
        output.delete(1.0, tk.END)
        output.insert(tk.END, result)

    def handle_speak():
        text = output.get(1.0, tk.END)
        agent.speak(text)

    def handle_translate():
        user_input = entry.get()
        translated = agent.translate_text(user_input, target_lang="en")
        output.delete(1.0, tk.END)
        output.insert(tk.END, translated)

    def handle_pdf():
        path = filedialog.askopenfilename(filetypes=[("PDF Files", "*.pdf")])
        text = agent.read_pdf(path)
        output.delete(1.0, tk.END)
        output.insert(tk.END, text)

    def handle_search():
        query = entry.get()
        agent.web_search(query)

    def handle_api():
        url = entry.get()
        result = agent.call_api(url)
        output.delete(1.0, tk.END)
        output.insert(tk.END, str(result))

    def handle_youtube():
        query = entry.get()
        result = agent.youtube_search(query)
        output.delete(1.0, tk.END)
        output.insert(tk.END, result)

    window = tk.Tk()
    window.title("TekoBot Agentti")
    entry = tk.Entry(window, width=50)
    entry.pack()

    tk.Button(window, text="Keskustele agentin kanssa", command=handle_input).pack()
    tk.Button(window, text="Lue PDF", command=handle_pdf).pack()
    tk.Button(window, text="Google-haku", command=handle_search).pack()
    tk.Button(window, text="Soita API", command=handle_api).pack()
    tk.Button(window, text="Käännä englanniksi", command=handle_translate).pack()
    tk.Button(window, text="Puhu vastaus ääneen", command=handle_speak).pack()
    tk.Button(window, text="Etsi YouTube-videoita", command=handle_youtube).pack()

    output = tk.Text(window, height=20, width=60)
    output.pack()
    window.mainloop()

# Käynnistä GUI
run_gui()

Kuinka agentin uudet ominaisuudet toimivat?

Toiminto	Kuvaus
Puhu teksti ääneen	pyttsx3 muuntaa vastauksen puheeksi
Käännä teksti	googletrans kääntää käyttäjän syötteen englanniksi
YouTube-haku	Hakee 3 videolinkkiä hakusanan perusteella

Lisätään vielä puheentunnistus ja äänikomentoaktivointi mukaan python koodiin:

Nyt lisätään agentille puheentunnistus ja äänikomentoaktivointi – eli:

1. Agentti kuuntelee puhetta ja muuntaa sen tekstiksi
2. Agentti aktivoituu tietyllä “herätyssanalla”, kuten “Hei TekoBot”

Toteutetaan tämä Pythonissa käyttäen speech_recognition-kirjastoa:

Asennettavat lisäkirjastot

pip install SpeechRecognition pyaudio

Huom: Windows-käyttäjillä pyaudio voi vaatia asennuksen binääristä. Jos tulee virhe, käytä valmiiksi koottua versiota esim. täältä: https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyaudio

Päivitetty agenttikoodi: puheentunnistus + herätyskomento

Lisätään nämä meidän aiempaan MultiToolAgent-luokkaan ja graafiseen käyttöliittymään:

import speech_recognition as sr

class MultiToolAgent:
    def __init__(self, name, api_key):
        self.name = name
        openai.api_key = api_key
        self.memory = []
        self.speaker = pyttsx3.init()
        self.translator = Translator()
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()

    def listen(self, wake_word="Hei TekoBot"):
        print("🎧 Agentti odottaa herätyssanaa...")
        while True:
            with self.microphone as source:
                self.recognizer.adjust_for_ambient_noise(source)
                audio = self.recognizer.listen(source)

            try:
                text = self.recognizer.recognize_google(audio, language="fi-FI")
                print(f"Kuultu: {text}")
                if wake_word.lower() in text.lower():
                    print("Herätyssana havaittu – agentti aktivoituu!")
                    return text
            except sr.UnknownValueError:
                print("Ei tunnistettavaa puhetta")
            except sr.RequestError as e:
                print(f" Tunnistusvirhe: {e}")

    def speech_to_text(self):
        print("Sano jotain agentille...")
        with self.microphone as source:
            self.recognizer.adjust_for_ambient_noise(source)
            audio = self.recognizer.listen(source)

        try:
            return self.recognizer.recognize_google(audio, language="fi-FI")
        except sr.UnknownValueError:
            return "En kuullut selkeästi"
        except sr.RequestError as e:
            return f"Virhe tunnistuksessa: {e}"

GUI-painikkeet (täydennys aiempaan käyttöliittymään):

Lisää nämä tk.Button(...)-rivit run_gui-funktioon:

    tk.Button(window, text="Kuuntele herätyssanaa", command=lambda: output.insert(tk.END, agent.listen())).pack()
    tk.Button(window, text="Muunna puhe tekstiksi", command=lambda: output.insert(tk.END, agent.speech_to_text())).pack()

Miten nämä toiminnot toimivat?

Toiminto	Kuvaus
Herätyssana (“Hei TekoBot”)	Agentti kuuntelee jatkuvasti mikrofonia ja aktivoituu kun herätyssana kuullaan
Puheentunnistus	Käyttäjä puhuu → agentti muuntaa puheen tekstiksi Google Speech API:n avulla
Melunsäätö & odotus	Agentti kalibroi taustamelun ja odottaa puhetta selkeästi
TekoBot reagoi	Herätyssanan jälkeen agentti voi tehdä vaikkapa automaattisen vastauksen tai kysyä lisätietoa

Mihin tätä voi käyttää?

• Handsfree-käyttö → puhut agentille ilman näppäimistöä
• Älykäs kodin agentti (pienellä säätämisellä )
• Interaktiiviset esittelyt, koulutusohjelmat tai tapahtuma-agentit