Situatie

nvață cum să construiești un agent AI pentru Windows 11 folosind Python și OpenAI API. Agentul poate deschide programe, crea și modifica fișiere, organiza documente și executa automat sarcini pe calculator.

Inteligența artificială devine mult mai interesantă în momentul în care nu se limitează la a răspunde la întrebări.

Imaginează-ți că poți scrie:

„Creează un folder pentru proiectul meu, generează un fișier cu ideile pentru articol și apoi deschide Notepad.”

Iar calculatorul chiar face aceste lucruri.

„Citește fișierele din folderul proiectului și fă-mi un rezumat.”

Agentul verifică fișierele, citește conținutul și îți prezintă rezultatul.

Acesta este principiul unui AI Agent pentru Windows 11: modelul AI reprezintă „creierul”, iar tu îi oferi un set de instrumente prin care poate interacționa cu sistemul de operare.

În acest tutorial vom construi o primă versiune funcțională folosind:

Windows 11;
Python;
OpenAI API;
OpenAI Agents SDK;
funcții Python care controlează anumite operații din Windows.

Important: nu vom oferi AI-ului acces nelimitat la PowerShell sau permisiunea de a executa orice comandă dorește. Un agent bun trebuie să fie capabil, dar controlabil.

Solutie

Mai întâi: nu folosești „tokenul de la ChatGPT”

Există o confuzie destul de frecventă aici.

Pentru aplicația pe care o construim nu trebuie să extragi cookie-uri, tokenuri de sesiune sau alte informații din ChatGPT.

Ai nevoie de o OpenAI API key, generată din platforma API OpenAI.

OpenAI recomandă ca această cheie să fie păstrată secretă și încărcată printr-o variabilă de mediu, nu scrisă direct în codul aplicației.

De asemenea, abonamentul ChatGPT și utilizarea OpenAI API sunt servicii facturate separat. Chiar dacă ai un abonament ChatGPT plătit, consumul făcut de programul tău prin API este gestionat separat.

Cum funcționează agentul nostru

Arhitectura este mai simplă decât pare.

Vom avea:

TU
 |
 | "Creează un folder numit Proiect și un fișier idei.txt"
 v
+-----------------------+
|     AGENTUL OPENAI    |
|   înțelege cererea    |
+-----------------------+
           |
           | decide ce unealtă trebuie folosită
           v
+-----------------------+
|   TOOL-uri PYTHON     |
|                       |
| create_folder()       |
| write_file()          |
| read_file()           |
| open_app()            |
| list_files()          |
| open_website()        |
+-----------------------+
           |
           v
+-----------------------+
|      WINDOWS 11       |
+-----------------------+

Modelul nu controlează magic Windows.

Noi îi spunem:

„Ai voie să folosești următoarele funcții.”

Agentul decide când trebuie apelată fiecare funcție, iar programul nostru execută efectiv operația.

OpenAI Agents SDK este construit tocmai pentru acest tip de aplicație: un agent poate avea instrucțiuni, tools, guardrails, handoffs și un runtime care gestionează apelarea instrumentelor pe parcursul unui task.

Pasul 1: instalează Python

Pentru acest tutorial recomand Python 3.10 sau mai nou.

După instalare, deschide Windows Terminal sau PowerShell și verifică:

python --version

Ar trebui să primești ceva asemănător:

Python 3.12.x

Pasul 2: creează proiectul

În PowerShell:

mkdir windows-ai-agent
cd windows-ai-agent
python -m venv .venv

Activează mediul virtual:

.venv\Scripts\Activate.ps1

Instalează OpenAI Agents SDK:

pip install openai-agents

Aceasta este și metoda indicată în documentația actuală a OpenAI Agents SDK.

Pasul 3: creează cheia OpenAI API

Din platforma OpenAI creezi o cheie API pentru proiectul tău.

Cheia va arăta aproximativ astfel:

sk-xxxxxxxxxxxxxxxx

Nu publica această cheie.

Nu o pune pe GitHub.

Nu o introduce într-un tutorial.

Nu o trimite altor persoane.

OpenAI precizează că secretul complet este afișat la crearea cheii și trebuie păstrat într-un loc sigur.

În PowerShell o poți seta pentru sesiunea curentă astfel:

$env:OPENAI_API_KEY="sk- cheia-ta-aici"

OpenAI Agents SDK poate citi automat variabila:

OPENAI_API_KEY

Pasul 4: creăm agentul pentru Windows 11

Creează un fișier:

agent.py

Vom construi agentul în mai multe etape.

Mai întâi importurile:

from agents import Agent, Runner
from agents.decorators import tool

from pathlib import Path
import subprocess
import webbrowser

Acum definim un folder special în care agentul are voie să lucreze:

WORKSPACE = Path.home() / "AI-Agent-Workspace"
WORKSPACE.mkdir(exist_ok=True)

Rezultatul va fi ceva asemănător cu:

C:\Users\NumeleTau\AI-Agent-Workspace

De ce facem asta?

Pentru că nu vrem ca prima versiune a agentului să poată modifica orice fișier de pe calculator.

Îi oferim propriul său spațiu de lucru.

Pasul 5: îi oferim agentului posibilitatea de a crea foldere

Adaugă:

@tool
def create_folder(folder_name: str) -> str:
    """Creează un folder în workspace-ul agentului."""

    path = (WORKSPACE / folder_name).resolve()

    if WORKSPACE.resolve() not in path.parents and path != WORKSPACE.resolve():
        return "Operație refuzată: folderul trebuie să fie în workspace."

    path.mkdir(parents=True, exist_ok=True)

    return f"Folder creat: {path}"

Acum modelul are la dispoziție un tool numit:

create_folder

Descrierea din docstring îl ajută să înțeleagă ce face funcția.

Agents SDK poate transforma funcțiile Python în tools și poate genera automat schema parametrilor lor.

Pasul 6: agentul poate crea și modifica fișiere

Adăugăm:

@tool
def write_text_file(relative_path: str, content: str) -> str:
    """Scrie un fișier text în workspace."""

    path = (WORKSPACE / relative_path).resolve()

    if WORKSPACE.resolve() not in path.parents:
        return "Operație refuzată: fișierul trebuie să fie în workspace."

    path.parent.mkdir(parents=True, exist_ok=True)

    path.write_text(
        content,
        encoding="utf-8"
    )

    return f"Fișier salvat: {path}"

Acum îi putem spune:

Creează folderul Blog și în el creează fișierul idei.txt
cu 10 idei de articole despre inteligență artificială.

Agentul poate decide:

create_folder("Blog")

și apoi:

write_text_file(
    "Blog/idei.txt",
    "..."
)

Practic, AI-ul nu mai generează doar text.

Începe să transforme intenția utilizatorului în acțiuni.

Pasul 7: agentul trebuie să poată și citi fișiere

Adăugăm încă un tool:

@tool
def read_text_file(relative_path: str) -> str:
    """Citește un fișier text din workspace."""

    path = (WORKSPACE / relative_path).resolve()

    if WORKSPACE.resolve() not in path.parents:
        return "Operație refuzată."

    if not path.exists():
        return "Fișierul nu există."

    if not path.is_file():
        return "Calea indicată nu este un fișier."

    return path.read_text(
        encoding="utf-8",
        errors="replace"
    )

Acum putem spune:

Citește Blog/idei.txt și alege cele mai bune trei idei.

Agentul va putea consulta fișierul înainte să răspundă.

Pasul 8: listarea fișierelor

Pentru ca agentul să se poată orienta prin propriul workspace:

@tool
def list_files(relative_folder: str = ".") -> str:
    """Listează fișierele și directoarele din workspace."""

    folder = (WORKSPACE / relative_folder).resolve()

    if WORKSPACE.resolve() not in folder.parents and folder != WORKSPACE.resolve():
        return "Operație refuzată."

    if not folder.exists():
        return "Folderul nu există."

    items = []

    for item in folder.iterdir():
        item_type = "DIR" if item.is_dir() else "FILE"
        items.append(f"[{item_type}] {item.name}")

    if not items:
        return "Folderul este gol."

    return "\n".join(items)

Putem întreba:

Ce proiecte am în workspace?

Agentul poate apela singur list_files().

Pasul 9: deschiderea programelor din Windows

Acum lucrurile devin mai interesante.

Putem permite agentului să deschidă anumite aplicații.

În loc să-i oferim posibilitatea de a executa orice program de pe calculator, folosim o listă permisă.

ALLOWED_APPS = {
    "notepad": ["notepad.exe"],
    "calculator": ["calc.exe"],
    "explorer": ["explorer.exe"],
    "paint": ["mspaint.exe"],
}


@tool
def open_app(app_name: str) -> str:
    """Deschide una dintre aplicațiile Windows aprobate."""

    name = app_name.lower().strip()

    if name not in ALLOWED_APPS:
        return (
            "Aplicația nu este permisă. "
            f"Aplicații disponibile: {', '.join(ALLOWED_APPS.keys())}"
        )

    subprocess.Popen(ALLOWED_APPS[name])

    return f"Am deschis aplicația: {name}"

Putem spune:

Deschide calculatorul.

Deschide Notepad.

Modelul va putea selecta open_app.

Observă un principiu important:

NU:
AI -> execută orice comandă Windows

DA:
AI -> selectează dintre operațiile aprobate

Această diferență este extrem de importantă atunci când începi să construiești agenți care controlează calculatoare reale.

Pasul 10: agentul poate deschide site-uri

Adăugăm:

@tool
def open_website(url: str) -> str:
    """Deschide un URL HTTP sau HTTPS în browserul implicit."""

    if not url.startswith(("https://", "http://")):
        return "URL invalid. Sunt permise doar adrese HTTP și HTTPS."

    webbrowser.open(url)

    return f"Am deschis: {url}"

Acum putem spune:

Deschide site-ul openai.com.

Browserul implicit se va deschide automat.

Codul complet al primului nostru agent

Fișierul agent.py poate arăta astfel:

from agents import Agent, Runner
from agents.decorators import tool

from pathlib import Path
import subprocess
import webbrowser


WORKSPACE = Path.home() / "AI-Agent-Workspace"
WORKSPACE.mkdir(exist_ok=True)


def safe_path(relative_path: str) -> Path:
    path = (WORKSPACE / relative_path).resolve()
    root = WORKSPACE.resolve()

    if root != path and root not in path.parents:
        raise ValueError("Calea este în afara workspace-ului.")

    return path


@tool
def create_folder(folder_name: str) -> str:
    """Creează un folder în workspace-ul agentului."""

    try:
        path = safe_path(folder_name)
    except ValueError:
        return "Operație refuzată."

    path.mkdir(parents=True, exist_ok=True)

    return f"Folder creat: {path}"


@tool
def write_text_file(relative_path: str, content: str) -> str:
    """Creează sau modifică un fișier text din workspace."""

    try:
        path = safe_path(relative_path)
    except ValueError:
        return "Operație refuzată."

    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content, encoding="utf-8")

    return f"Fișier salvat: {path}"


@tool
def read_text_file(relative_path: str) -> str:
    """Citește un fișier text din workspace."""

    try:
        path = safe_path(relative_path)
    except ValueError:
        return "Operație refuzată."

    if not path.exists():
        return "Fișierul nu există."

    if not path.is_file():
        return "Calea nu reprezintă un fișier."

    return path.read_text(
        encoding="utf-8",
        errors="replace"
    )


@tool
def list_files(relative_folder: str = ".") -> str:
    """Listează fișierele și directoarele din workspace."""

    try:
        folder = safe_path(relative_folder)
    except ValueError:
        return "Operație refuzată."

    if not folder.exists():
        return "Folderul nu există."

    items = []

    for item in folder.iterdir():
        item_type = "DIR" if item.is_dir() else "FILE"
        items.append(f"[{item_type}] {item.name}")

    return "\n".join(items) if items else "Folderul este gol."


ALLOWED_APPS = {
    "notepad": ["notepad.exe"],
    "calculator": ["calc.exe"],
    "explorer": ["explorer.exe"],
    "paint": ["mspaint.exe"],
}


@tool
def open_app(app_name: str) -> str:
    """Deschide o aplicație Windows aprobată."""

    name = app_name.lower().strip()

    if name not in ALLOWED_APPS:
        return (
            "Aplicația nu este permisă. "
            f"Poți folosi: {', '.join(ALLOWED_APPS.keys())}"
        )

    subprocess.Popen(ALLOWED_APPS[name])

    return f"Aplicația {name} a fost deschisă."


@tool
def open_website(url: str) -> str:
    """Deschide un site în browserul implicit."""

    if not url.startswith(("https://", "http://")):
        return "URL invalid."

    webbrowser.open(url)

    return f"Pagina a fost deschisă: {url}"


agent = Agent(
    name="Windows Assistant",

    instructions="""
Ești asistentul meu AI pentru Windows 11.

Scopul tău este să transformi cererile utilizatorului
în acțiuni concrete folosind instrumentele disponibile.

Poți:
- crea foldere;
- crea și modifica fișiere text;
- citi fișiere;
- lista fișiere;
- deschide aplicațiile Windows aprobate;
- deschide pagini web.

Folosește instrumentele atunci când este necesar.

Nu pretinde niciodată că ai executat o operație dacă
instrumentul nu confirmă că aceasta a fost executată.

Nu încerca să accesezi fișiere din afara workspace-ului.

Pentru cereri ambigue sau acțiuni cu potențial distructiv,
cere confirmarea utilizatorului.
""",

    tools=[
        create_folder,
        write_text_file,
        read_text_file,
        list_files,
        open_app,
        open_website,
    ],
)


print("=" * 50)
print("Windows AI Agent")
print(f"Workspace: {WORKSPACE}")
print("Scrie 'exit' pentru oprire.")
print("=" * 50)


while True:

    command = input("\nTu: ").strip()

    if command.lower() in {"exit", "quit"}:
        break

    if not command:
        continue

    try:
        result = Runner.run_sync(
            agent,
            command
        )

        print("\nAgent:")
        print(result.final_output)

    except Exception as exc:
        print(f"\nEroare: {exc}")

Agent și Runner reprezintă componente de bază ale actualului OpenAI Agents SDK, iar runner-ul gestionează bucla în care modelul decide când trebuie utilizate instrumentele disponibile.

Pasul 11: pornește agentul

Din PowerShell:

python agent.py

Ar trebui să apară:

==================================================
Windows AI Agent
Workspace: C:\Users\...\AI-Agent-Workspace
Scrie 'exit' pentru oprire.
==================================================

Acum începe distracția.

Încearcă:

Creează un folder numit Articole.

După aceea:

În Articole creează un fișier idei.txt și scrie
10 idei de articole despre inteligența artificială.

Apoi:

Citește fișierul și alege cele mai bune trei idei.

Creează un folder numit ProiectNou,
un fișier README.txt în el și apoi deschide Notepad.

Agentul trebuie să identifice singur succesiunea de operații necesare.

Acesta este momentul în care diferența dintre un simplu chatbot și un agent AI devine evidentă.

Cum îl transformăm într-un agent care „îmi face toată treaba”?

Versiunea de mai sus este doar fundația.

Puterea unui agent vine din instrumentele pe care i le oferi.

Poți adăuga treptat:

Agent AI
 |
 +-- Windows
 |    +-- deschide programe
 |    +-- gestionează fișiere
 |    +-- organizează foldere
 |
 +-- Browser
 |    +-- cercetare
 |    +-- formulare
 |    +-- aplicații web
 |
 +-- E-mail
 |    +-- citește e-mailuri
 |    +-- pregătește răspunsuri
 |    +-- trimite după aprobare
 |
 +-- Calendar
 |    +-- verifică programul
 |    +-- creează întâlniri
 |
 +-- Documente
 |    +-- Word
 |    +-- PDF
 |    +-- Excel
 |
 +-- Programare
 |    +-- scrie cod
 |    +-- verifică proiecte
 |    +-- rulează teste
 |
 +-- Automatizări
      +-- task-uri zilnice
      +-- rapoarte
      +-- organizare

OpenAI Agents SDK suportă inclusiv orchestrarea mai multor agenți, sessions, guardrails, tracing și scenarii human-in-the-loop.

Astfel, în loc de un singur agent gigantic, poți construi mai mulți specialiști.

De exemplu:

             MASTER AGENT
                  |
       +----------+----------+
       |          |          |
       v          v          v
   FILE AGENT  WEB AGENT  EMAIL AGENT

Master Agent primește:

Pregătește raportul săptămânal și trimite-l echipei.

El poate delega:

agentului pentru fișiere — colectarea informațiilor;
agentului pentru web — verificarea datelor externe;
agentului pentru documente — realizarea raportului;
agentului pentru e-mail — pregătirea mesajului.

Aceasta este direcția în care agenții AI devin cu adevărat interesanți.

Dar poate controla efectiv mouse-ul și interfața Windows?

Da, însă aici trebuie să faci diferența dintre două tipuri de automatizare.

Prima este:

AI -> API / funcție -> aplicație

Aceasta este în general cea mai robustă.

A doua este:

AI
 ↓
vede ecranul
 ↓
decide unde trebuie să dea click
 ↓
controlează mouse-ul și tastatura

Aceasta seamănă mai mult cu un angajat virtual care folosește calculatorul.

OpenAI documentează în ecosistemul Agents SDK inclusiv tools pentru folosirea unui computer și pentru execuție în medii controlate.

Totuși, pentru un agent personal recomand să folosești automatizarea GUI doar acolo unde aplicația nu oferă o metodă mai sigură și mai predictibilă.

API-urile și funcțiile controlate sunt aproape întotdeauna preferabile unui robot care apasă orbește pe butoane.

Nu îi da acces nelimitat la PowerShell

Una dintre primele tentații atunci când construiești un asemenea proiect este să creezi:

def execute_command(command):
    os.system(command)

și apoi să oferi această funcție modelului.

În acel moment agentul poate teoretic executa aproape orice comandă permisă contului tău Windows.

Este o idee foarte proastă pentru prima versiune.

În schimb, creează instrumente specializate:

create_folder()
read_file()
write_file()
open_program()
move_file()
create_document()

Fiecare are reguli precise.

Pentru operații sensibile, introdu un sistem de aprobare.

De exemplu:

Agent:
Vreau să șterg 43 de fișiere din folderul Temp.

Aprobi operația?
[DA] [NU]

Abia după aprobare programul execută operația.

Agents SDK include mecanisme pentru scenarii în care execuția agentului poate fi întreruptă pentru aprobare umană și reluată ulterior.

Ce operații ar trebui să ceară confirmare?

Eu aș pune obligatoriu confirmare înainte de:

ștergerea fișierelor;
suprascrierea documentelor importante;
trimiterea unui e-mail;
postarea pe social media;
cumpărături;
plăți;
instalarea sau dezinstalarea programelor;
modificarea setărilor Windows;
executarea comenzilor PowerShell;
transmiterea fișierelor către servicii externe;
operații care afectează multe fișiere simultan.

Agentul poate pregăti acțiunea.

Utilizatorul păstrează însă ultimul cuvânt.

Adaugă și log-uri

Un alt lucru pe care merită să-l implementezi este un fișier:

agent.log

În care să fie salvate acțiunile:

18:32 - USER: Creează folderul ClientX
18:32 - TOOL: create_folder("ClientX")
18:32 - RESULT: SUCCESS

18:34 - USER: Creează raport.txt
18:34 - TOOL: write_text_file(...)
18:34 - RESULT: SUCCESS

În cazul în care agentul face ceva neașteptat, poți vedea exact ce s-a întâmplat.

OpenAI Agents SDK oferă și tracing pentru inspectarea și depanarea fluxurilor agentice.

Următorul nivel: memorie

Agentul nostru actual primește câte o comandă.

Dar un asistent personal adevărat ar trebui să știe lucruri precum:

Proiectul Alpha se află în folderul X.

Pentru rapoarte folosesc template-ul Y.

Documentele pentru clientul Z trebuie salvate în folderul Z.

Prefer rapoartele în limba română.

Aici intră în joc sistemele de sessions și memorie.

Agents SDK oferă mecanisme pentru păstrarea contextului între rulările agentului, astfel încât aplicațiile agentice să poată avea conversații și workflow-uri persistente.

Și mai interesant: un agent permanent în Windows

După ce versiunea din terminal funcționează bine, poți construi o interfață.

De exemplu:

┌───────────────────────────────────────┐
│ 🤖 Windows AI Assistant               │
├───────────────────────────────────────┤
│                                       │
│ Ce vrei să fac?                       │
│                                       │
│ > Organizează documentele proiectului │
│                                       │
│                 [ Execută ]           │
│                                       │
├───────────────────────────────────────┤
│ ✓ 14 fișiere analizate                │
│ ✓ 4 foldere create                    │
│ ✓ documentele au fost organizate      │
└───────────────────────────────────────┘

Poți realiza interfața în:

PySide6;
PyQt;
Tkinter;
Electron;
.NET;
sau chiar ca aplicație web locală.

Ulterior îi poți adăuga:

o iconiță în system tray;
shortcut global;
activare vocală;
speech-to-text;
text-to-speech;
notificări Windows.

Și ajungi foarte aproape de ideea unui AI OS Assistant personal.

Cât de departe poate merge?

În principiu, foarte departe.

Imaginează-ți următoarea comandă:

Pregătește-mi ziua de lucru.

În spatele unei singure propoziții agentul ar putea:

1. verifica agenda;

2. verifica mesajele importante;

3. crea lista de task-uri;

4. deschide proiectele la care lucrezi;

5. pregăti documentele necesare;

6. cerceta informațiile de care ai nevoie;

7. genera un rezumat;

8. pregăti răspunsurile la e-mailuri;

9. solicita aprobarea pentru trimiterea lor.

Sau îi poți spune:

Pregătește un articol despre Windows 11.

Agentul ar putea:

Research Agent
      ↓
caută informațiile

Writing Agent
      ↓
scrie articolul

SEO Agent
      ↓
optimizează titlul și structura

File Agent
      ↓
salvează articolul

Browser Agent
      ↓
deschide WordPress

      ↓

TU APROBI PUBLICAREA

Asta este adevărata putere a sistemelor agentice.

Nu faptul că modelul poate genera un text bun, ci faptul că poate coordona mai multe acțiuni pentru atingerea unui obiectiv.

Costurile trebuie monitorizate

Fiecare interacțiune a agentului cu modelul prin OpenAI API poate genera consum.

Într-un workflow complex, o singură comandă de la utilizator poate determina mai multe apeluri către model.

De aceea este important să:

monitorizezi consumul;
limitezi numărul de pași;
alegi modelul potrivit fiecărui task;
folosești modele mai mici pentru operațiile simple;
setezi limite pentru proiectul API.

OpenAI Agents SDK poate raporta utilizarea unei rulări, inclusiv numărul cererilor și tokenii de intrare și ieșire, ceea ce permite monitorizarea costurilor.

Regula de aur pentru agenții AI

Există o regulă pe care merită să o ții minte:

Capabilitățile agentului trebuie extinse progresiv, nu toate din prima zi.

Începi cu:

AI
↓
fișiere într-un workspace controlat

Apoi:

AI
↓
fișiere + aplicații

Apoi:

AI
↓
fișiere + aplicații + browser

Apoi:

AI
↓
e-mail + calendar + documente

Și abia după ce ai sisteme solide de permisiuni, confirmări și logging:

AI
↓
automatizări complexe în Windows

Este mult mai ușor să oferi agentului o nouă permisiune decât să repari problemele provocate de un agent căruia i-ai oferit prea multe din prima zi.

Concluzie

Construirea propriului agent AI pentru Windows 11 nu mai este un proiect rezervat laboratoarelor de cercetare.

Cu Python, OpenAI API și câteva funcții bine definite poți construi deja un agent care:

înțelege cereri formulate natural;
decide singur ce instrumente trebuie folosite;
creează foldere;
citește și scrie fișiere;
organizează informații;
deschide programe;
deschide pagini web;
execută workflow-uri formate din mai mulți pași.

Iar aceasta este doar versiunea 1.0.

Dacă adaugi treptat browser automation, e-mail, calendar, documente, memorie, voce și agenți specializați, proiectul poate evolua într-un adevărat asistent personal pentru Windows 11.

Un fel de angajat digital care stă permanent pe calculatorul tău.

Diferența importantă este că nu trebuie să-i dai acces total la PC.

Construiește-l astfel:

AI-ul decide. Instrumentele execută. Regulile limitează. Iar utilizatorul aprobă operațiile importante.

Aceasta este arhitectura pe care merită construit un agent AI care să facă, într-adevăr, o parte tot mai mare din munca ta.

Tip solutie

Permanent

Follow Us

Cum îți construiești propriul agent AI pentru Windows 11 cu OpenAI API: un asistent care chiar execută task-uri pe PC

Situatie

Solutie

Mai întâi: nu folosești „tokenul de la ChatGPT”

Cum funcționează agentul nostru

Pasul 1: instalează Python

Pasul 2: creează proiectul

Pasul 3: creează cheia OpenAI API

Pasul 4: creăm agentul pentru Windows 11

Pasul 5: îi oferim agentului posibilitatea de a crea foldere

Pasul 6: agentul poate crea și modifica fișiere

Pasul 7: agentul trebuie să poată și citi fișiere

Pasul 8: listarea fișierelor

Pasul 9: deschiderea programelor din Windows

Pasul 10: agentul poate deschide site-uri

Codul complet al primului nostru agent

Pasul 11: pornește agentul

Cum îl transformăm într-un agent care „îmi face toată treaba”?

Dar poate controla efectiv mouse-ul și interfața Windows?

Nu îi da acces nelimitat la PowerShell

Ce operații ar trebui să ceară confirmare?

Adaugă și log-uri

Următorul nivel: memorie

Și mai interesant: un agent permanent în Windows

Cât de departe poate merge?

Costurile trebuie monitorizate

Regula de aur pentru agenții AI

Concluzie

Tip solutie

Voteaza

Despre Autor

branisteanu alexandru

Leave A Comment? × Cancel Reply

Follow Us

Situatie

Solutie

Mai întâi: nu folosești „tokenul de la ChatGPT”

Cum funcționează agentul nostru

Pasul 1: instalează Python

Pasul 2: creează proiectul

Pasul 3: creează cheia OpenAI API

Pasul 4: creăm agentul pentru Windows 11

Pasul 5: îi oferim agentului posibilitatea de a crea foldere

Pasul 6: agentul poate crea și modifica fișiere

Pasul 7: agentul trebuie să poată și citi fișiere

Pasul 8: listarea fișierelor

Pasul 9: deschiderea programelor din Windows

Pasul 10: agentul poate deschide site-uri

Codul complet al primului nostru agent

Pasul 11: pornește agentul

Cum îl transformăm într-un agent care „îmi face toată treaba”?

Dar poate controla efectiv mouse-ul și interfața Windows?

Nu îi da acces nelimitat la PowerShell

Ce operații ar trebui să ceară confirmare?

Adaugă și log-uri

Următorul nivel: memorie

Și mai interesant: un agent permanent în Windows

Cât de departe poate merge?

Costurile trebuie monitorizate

Regula de aur pentru agenții AI

Concluzie

Tip solutie

Voteaza

Despre Autor

branisteanu alexandru

Solutii Asemanatoare

Leave A Comment? × Cancel Reply