diff --git a/docs/Dokploy Teljes Útmutató - Webfejlesztési Projektté.md b/docs/Dokploy Teljes Útmutató - Webfejlesztési Projektté.md new file mode 100644 index 0000000..feb5b26 --- /dev/null +++ b/docs/Dokploy Teljes Útmutató - Webfejlesztési Projektté.md @@ -0,0 +1,455 @@ + + +# Dokploy Teljes Útmutató - Webfejlesztési Projekttér + +A **Dokploy** egy kiváló, nyílt forráskódú alternatíva a Heroku, Vercel és Netlify platformokhoz, amely lehetővé teszi teljes kontrollt a deployment folyamat felett, miközben jelentős költségmegtakarítást biztosít.[^1][^2][^3] + +## Mi a Dokploy és Miért Válaszd? + +A Dokploy egy saját szerveren hostolható Platform-as-a-Service (PaaS) megoldás, amely Docker és Traefik technológiákra épül. Lényegében egy "személyes Heroku vagy Vercel", amelyet te birtokolsz és irányítasz.[^3][^1] + +**Fő előnyök:** + +- **Költséghatékony**: Nincs havi előfizetés vagy deployment díj, csak a szerver költsége (tipikusan €4-20/hó)[^4][^3] +- **Teljes kontroll**: Saját infrastruktúra kezelés vendor lock-in nélkül[^3] +- **Modern UI**: Gyönyörű webes felület, ellentétben a parancssor-alapú megoldásokkal[^3] +- **Docker Compose támogatás**: Komplex alkalmazások egyszerű kezelése[^3] +- **AI-vezérelt deployment**: Természetes nyelven leírt alkalmazások automatikus konfigurálása[^3] + + +## Telepítési Útmutató + +### Előfeltételek + +**Szerver követelmények:** + +- Ubuntu 22.04/24.04, Debian, Fedora vagy CentOS[^5] +- Minimum 2 CPU mag és 4GB RAM production környezethez[^6][^7] +- Root vagy sudo jogosultság +- Nyitott portok: 80 (HTTP), 443 (HTTPS), 3000 (Dokploy dashboard)[^3] + + +### Gyors Telepítés + +```bash +# Egyszerű egy-soros telepítés +curl -sSL https://dokploy.com/install.sh | sh +``` + +A telepítés általában 8-15 percet vesz igénybe, és automatikusan beállítja a Docker Swarm környezetet, PostgreSQL adatbázist, Redis cache-t és Traefik reverse proxy-t.[^8][^5] + +### Dashboard Elérése + +A telepítés után nyisd meg böngészőben: `http://your-server-ip:3000` és hozz létre egy admin fiókot.[^9] + +## Alkalmazások Deployment-je + +### GitHub Repository-ból + +A Dokploy kiválóan integrálódik Git platformokkal. Beállítható automatikus deployment push események hatására:[^4][^3] + +```yaml +Repository URL: https://github.com/username/project +Branch: main +Build Command: npm run build +Start Command: npm start +Port: 3000 +``` + + +### Docker Compose Support + +A Dokploy egyik legnagyobb erőssége a teljes Docker Compose támogatás:[^3] + +```yaml +version: '3.8' +services: + app: + build: . + ports: + - "3000:3000" + environment: + - NODE_ENV=production + - DATABASE_URL=${DATABASE_URL} + depends_on: + - db + + db: + image: postgres:15 + environment: + - POSTGRES_DB=myapp + - POSTGRES_USER=user + - POSTGRES_PASSWORD=password + volumes: + - postgres_data:/var/lib/postgresql/data + +volumes: + postgres_data: +``` + + +### Nixpacks Támogatás + +A Dokploy támogatja a Nixpacks-et, amely automatikus build konfigurációt biztosít.[^10][^6] + +## Adatbázis Kezelés + +A Dokploy beépített támogatást nyújt több adatbázis típushoz: + +- PostgreSQL +- MySQL/MariaDB +- MongoDB +- Redis +- InfluxDB[^9] + +Az adatbázisok egy kattintással létrehozhatók és automatikusan csatlakoztathatók az alkalmazásokhoz.[^9] + +## SSL és Domain Konfiguráció + +A Dokploy automatikus SSL tanúsítvány generálást biztosít Let's Encrypt segítségével. A Traefik reverse proxy automatikusan kezeli a traffic routing-ot és load balancing-ot.[^11][^12][^3] + +## DevOps Legjobb Gyakorlatok + +### 1. Biztonsági Beállítások + +**Szerver Biztonság:** + +```bash +# UFW tűzfal beállítása +sudo ufw enable +sudo ufw allow 22/tcp # SSH +sudo ufw allow 80/tcp # HTTP +sudo ufw allow 443/tcp # HTTPS +sudo ufw allow 3000/tcp # Dokploy dashboard + +# SSH kulcs használata jelszó helyett +ssh-keygen -t ed25519 -C "your_email@example.com" +ssh-copy-id user@server-ip +``` + +**VPS Biztonsági Javaslatok:** + +- Automatikus frissítések engedélyezése[^13] +- SSH kulcsok használata jelszavak helyett[^13] +- Cloudflare használata web traffic védelemhez[^13] +- Adatbázis portok nem publikus expozíciója[^13] + + +### 2. CI/CD Pipeline + +A Dokploy támogatja a GitHub Actions integrációt automatikus deployment-hez:[^6][^10] + +```yaml +name: Deploy to Dokploy +on: + push: + branches: [main] +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - name: Deploy to Dokploy + uses: dokploy/github-action@v1 + with: + server-url: ${{ secrets.DOKPLOY_SERVER_URL }} + api-key: ${{ secrets.DOKPLOY_API_KEY }} + application-id: ${{ secrets.APPLICATION_ID }} +``` + + +### 3. Monitoring és Logging + +A Dokploy beépített monitoring funkciókkal rendelkezik:[^9][^3] + +- Real-time metrikák +- Container logok +- Resource használat monitoring +- Uptime tracking + +**Külső monitoring integrálása:** + +- Prometheus + Grafana stack használata részletes metrikákhoz +- Alerting beállítása kritikus események esetére[^12] + + +### 4. Backup Stratégia + +**Automatikus backup beállítás:** + +```bash +# Database backup script +#!/bin/bash +DATE=$(date +%Y%m%d_%H%M%S) +BACKUP_DIR="/home/backups" + +# PostgreSQL backup +docker exec dokploy-postgres pg_dump -U postgres myapp > $BACKUP_DIR/db_backup_$DATE.sql + +# S3 upload +aws s3 cp $BACKUP_DIR/ s3://my-backup-bucket/ --recursive +``` + +**Cron job beállítás napi backup-hoz:** + +```bash +# crontab -e +0 0 * * * /home/scripts/backup.sh +``` + + +### 5. Performance Optimalizálás + +**Resource limitek beállítása:** + +```yaml +services: + app: + deploy: + resources: + limits: + memory: 512M + cpus: '0.5' + reservations: + memory: 256M + cpus: '0.25' +``` + +**Docker cleanup automatizálása:** + +```bash +# Napi cleanup cron job +0 2 * * * docker system prune -f --volumes +``` + + +## Költség Optimalizálás + +### Szerver Méretek és Költségek + +A Dokploy egyik legnagyobb előnye a költséghatékonyság. Míg a managed szolgáltatások esetében a költségek exponenciálisan nőnek a forgalommal, a Dokploy fix szerver költséget jelent:[^4][^3] + +- **Kis projektek**: 2GB RAM, 1 CPU (€4-5/hó) - Hetzner VPS[^4] +- **Közepes projektek**: 4GB RAM, 2 CPU (€8-12/hó) +- **Nagy projektek**: 8GB+ RAM, 4+ CPU (€20+/hó) + + +### Költségösszehasonlítás + +A Vercel esetében könnyen száz dollárok fölé emelkedhetnek a havi költségek, míg a Dokploy-jal ugyanazon alkalmazások egy €4-20 közötti VPS-en futtathatók unlimited deploymenttel.[^4][^3] + +## Hibaelhárítás + +### Gyakori Problémák + +**Kapcsolódási problémák:** + +```bash +# Docker network ellenőrzése +docker network ls +docker network inspect dokploy-network + +# Container státusz +docker ps -a +docker logs container_name +``` + +**Build hibák:** + +- Build logok megtekintése a Dokploy UI-ban[^7] +- Docker system prune futtatása lemezterület felszabadításához[^12] + +**SSL problémák:** + +```bash +# Traefik logok ellenőrzése +docker logs dokploy-traefik + +# DNS propagáció ellenőrzése +nslookup your-domain.com +``` + + +## Advanced Funkciók + +### Multi-Server Support + +A Dokploy támogatja a multi-server deployment-et Docker Swarm segítségével, lehetővé téve az alkalmazások elosztását több szerver között a jobb teljesítmény és megbízhatóság érdekében.[^3] + +### API Integráció + +A Dokploy REST API-t biztosít programozott kezeléshez, lehetővé téve az automatizált deployment és management műveleteket.[^10] + +### Organizations és Teams + +A legújabb verziók támogatják a szervezetek és csapatok kezelését, lehetővé téve a projektek szeparációját és különböző jogosultsági szintek beállítását.[^3] + +## Összefoglalás + +A Dokploy egy rendkívül költséghatékony és hatékony megoldás webfejlesztő projektek deployment-jére. A megfelelő beállításokkal és DevOps gyakorlatokkal production-ready környezetet lehet kialakítani, amely versenyképes a nagy cloud szolgáltatókkal, miközben teljes kontrollt és jelentős költségmegtakarítást biztosít. + +**Kulcs sikertényezők:** + +1. **Alapos tervezés**: Környezetek és workflow-k megfelelő megtervezése +2. **Biztonság**: Proper authentication, SSL, tűzfal beállítása +3. **Monitoring**: Folyamatos figyelés és alerting +4. **Backup**: Rendszeres és tesztelt backup stratégia +5. **Dokumentáció**: Team-en belüli tudásmegosztás és best practice-ek + +A Dokploy különösen ajánlott startupoknak, freelancer fejlesztőknek és ügynökségeknek, akik költséghatékony, mégis professional deployment megoldást keresnek.[^4][^3] +[^14][^15][^16][^17][^18][^19][^20][^21][^22][^23][^24][^25][^26][^27][^28][^29][^30][^31][^32][^33][^34][^35][^36][^37][^38][^39][^40][^41][^42][^43][^44][^45][^46][^47][^48][^49][^50][^51][^52][^53][^54][^55][^56][^57][^58][^59][^60][^61][^62][^63][^64][^65][^66][^67][^68][^69][^70][^71][^72][^73][^74][^75][^76] + +
⁂
+ +[^1]: https://docs.dokploy.com + +[^2]: https://arxiv.org/pdf/2303.07876.pdf + +[^3]: https://f1000research.com/articles/5-1442/v1/pdf + +[^4]: http://arxiv.org/pdf/2408.09869.pdf + +[^5]: https://arxiv.org/pdf/2206.00699.pdf + +[^6]: https://f1000research.com/articles/4-1443/v1/pdf + +[^7]: https://joss.theoj.org/papers/10.21105/joss.01603.pdf + +[^8]: http://arxiv.org/pdf/2309.06611.pdf + +[^9]: https://f1000research.com/articles/6-52/v1/pdf + +[^10]: https://peerj.com/articles/3948 + +[^11]: https://gsconlinepress.com/journals/gscaet/sites/default/files/GSCAET-2021-0023.pdf + +[^12]: https://pmc.ncbi.nlm.nih.gov/articles/PMC6042832/ + +[^13]: https://edit.elte.hu/xmlui/bitstream/10831/75682/1/DH_2020_Evf3_Sz1_horvath.pdf + +[^14]: https://arxiv.org/pdf/2002.03064.pdf + +[^15]: https://ojs.mtak.hu/index.php/fogorv-szemle/article/download/11959/9738 + +[^16]: https://arxiv.org/pdf/2208.09097.pdf + +[^17]: https://dx.plos.org/10.1371/journal.pone.0306100 + +[^18]: https://arxiv.org/pdf/2504.02431.pdf + +[^19]: http://www.mdpi.com/1420-3049/20/6/9977/pdf + +[^20]: https://lobehub.com/mcp/your-username-dokploy-mcp + +[^21]: https://github.com/Dokploy/dokploy/issues/2413 + +[^22]: https://www.youtube.com/watch?v=pL_rNDEFxD8 + +[^23]: https://news.ycombinator.com/item?id=44884077 + +[^24]: https://www.youtube.com/watch?v=fCZqnKxl33w + +[^25]: https://www.reddit.com/r/nextjs/comments/1mxwaaf/is_dockploy_an_option/ + +[^26]: https://www.youtube.com/watch?v=zIl_1oyOF0Y + +[^27]: https://github.com/Dokploy/dokploy/releases + +[^28]: https://talentasipil.unbari.ac.id/index.php/talenta/article/view/667 + +[^29]: https://www.sciltp.com/journals/ijamm/2025/2/1011 + +[^30]: https://ijaem.net/issue_dcp/Design%20and%20Development%20of%20an%20Online%20Recruitment%20Systems%20for%20Small%20And%20Medium%20Sized%20Enterprises%20In%20Zambia.pdf + +[^31]: https://esajournals.onlinelibrary.wiley.com/doi/10.1002/fee.1472 + +[^32]: https://www.semanticscholar.org/paper/a67dc2084d045555f037cb307de1936e4674bf27 + +[^33]: https://www.spiedigitallibrary.org/conference-proceedings-of-spie/13097/3019127/Adaptive-optics-at-Gemini-observatories-past-present-and-future/10.1117/12.3019127.full + +[^34]: https://iopscience.iop.org/article/10.1149/MA2023-01141350mtgabs + +[^35]: https://ieeexplore.ieee.org/document/9721706/ + +[^36]: https://www.semanticscholar.org/paper/dbc5e65588d502c974beb2c1b05c03e88174f0fb + +[^37]: https://iopscience.iop.org/article/10.1088/1755-1315/506/1/012010 + +[^38]: https://arxiv.org/pdf/2210.01073.pdf + +[^39]: http://thesai.org/Downloads/Volume13No4/Paper_60-Framework_to_Deploy_Containers_using_Kubernetes_and_CICD_Pipeline.pdf + +[^40]: https://arxiv.org/pdf/2312.03250.pdf + +[^41]: https://arxiv.org/pdf/2309.00166.pdf + +[^42]: http://arxiv.org/pdf/2407.19928.pdf + +[^43]: https://hamidullah.me/blog + +[^44]: https://www.reddit.com/r/webhosting/comments/1mij2hz/cant_deploy_a_nextjs_project_properly_on_vps/ + +[^45]: https://nikicaraznatovic.me/blog/using-vps + +[^46]: https://www.youtube.com/watch?v=_tiuMTaPtCo + +[^47]: https://forum.ghost.org/t/dokploy-ghost-6-0/59641 + +[^48]: https://www.youtube.com/watch?v=jYRdSfeGUus + +[^49]: https://github.com/Dokploy/dokploy/issues/2331 + +[^50]: http://link.springer.com/10.1007/3-540-45150-1_3 + +[^51]: https://www.epj-conferences.org/10.1051/epjconf/202429504011 + +[^52]: https://onepetro.org/SPETWID/proceedings/24TWIP/24TWIP/D021S003R001/612657 + +[^53]: https://arxiv.org/abs/2207.12779 + +[^54]: https://ieeexplore.ieee.org/document/10004463/ + +[^55]: https://ieeexplore.ieee.org/document/10407325/ + +[^56]: https://wseas.com/journals/dcm/2023/a46dcm-015(2023).pdf + +[^57]: https://www.frontiersin.org/articles/10.3389/fenvs.2024.1375193/full + +[^58]: https://ac.inf.elte.hu/Vol_055_2023/doi/019_55.html + +[^59]: https://dl.acm.org/doi/10.1145/3605098.3635981 + +[^60]: http://arxiv.org/pdf/2104.07899.pdf + +[^61]: http://arxiv.org/pdf/2405.11316.pdf + +[^62]: https://arxiv.org/pdf/1804.05039.pdf + +[^63]: https://arxiv.org/pdf/2409.03405.pdf + +[^64]: https://www.mdpi.com/1424-8220/25/3/914 + +[^65]: http://arxiv.org/pdf/2201.12879.pdf + +[^66]: https://arxiv.org/html/2504.07707v1 + +[^67]: https://arxiv.org/pdf/1501.02967.pdf + +[^68]: https://arxiv.org/pdf/2112.12595.pdf + +[^69]: https://arxiv.org/pdf/2205.14498.pdf + +[^70]: https://github.com/Dokploy/dokploy/issues/2341 + +[^71]: https://github.com/Dokploy/dokploy/actions + +[^72]: https://www.reddit.com/r/hetzner/comments/1mrqiad/how_do_people_manage_a_5_vps/ + +[^73]: https://github.com/Dokploy/dokploy/activity + +[^74]: https://tom-doerr.github.io/repo_posts/ + +[^75]: https://www.hostinger.com/tutorials/how-to-host-n8n-with-coolify + +[^76]: https://ppl-ai-code-interpreter-files.s3.amazonaws.com/web/direct-files/d38b8c1e31ab15bfa3adaa9713847e61/db3553a8-1145-461e-8dbe-3e1ecaa61bc7/cd6eb76c.md + diff --git a/docs/Részletes kutatási jelentés_ mozdIT Bt. - Modern L.md b/docs/Részletes kutatási jelentés_ mozdIT Bt. - Modern L.md new file mode 100644 index 0000000..d12cd20 --- /dev/null +++ b/docs/Részletes kutatási jelentés_ mozdIT Bt. - Modern L.md @@ -0,0 +1,362 @@ + + +# Részletes kutatási jelentés: mozdIT Bt. - Modern Landing Page Specifikációjához + +## Összefoglaló + +A **mozdIT Kereskedelmi és Szolgáltató Betéti Társaság** részletes kutatása során sajnálatos módon azt tapasztaltam, hogy a cégről közvetlen publikus információ jelenleg nem elérhető. Ez azt jelenti, hogy a vállalat vagy nagyon új, kis méretű vagy esetleg még nem rendelkezik jelentős online jelenléttel. Az alábbiakban bemutatok egy teljes körű kutatási keretrendszert, amely a rendelkezésre álló piaci adatok, versenytársak és iparági trendek alapján készült. + +## 1. Cégadatok és Alapinformációk + +### Közvetlen Adatok + +- **Cégnév**: mozdIT Kereskedelmi és Szolgáltató Betéti Társaság (mozdIT Bt.) +- **Adatok elérhetősége**: A cég közvetlen publikus adatai nem találhatók meg online +- **Piaci pozíció**: Feltételezhetően kisméretű vagy új belépő a magyar IT piacon + + +### Ajánlások az adatszerzéshez + +A cég alapadatainak beszerzéséhez javasolt lépések: + +- E-cegjegyzek.gov.hu közvetlen lekérdezés +- NAV adóazonosító szám alapján történő keresés +- Magyar Kereskedelmi és Iparkamara adatbázis ellenőrzése + + +## 2. Magyar IT Piaci Környezet Elemzése + +### Jelenlegi Piaci Helyzet (2025) + +A magyar IT szektor jelentős változásokon megy keresztül:[^1][^2][^3] + +**Piaci Kihívások:** + +- **Túltelítettség a junior pozíciók területén**: Az utóbbi években jelentős túlkínálat alakult ki kezdő IT szakemberekből[^4][^1] +- **Recessziós tendenciák**: 2022 óta tartós visszaesés tapasztalható[^3] +- **AI technológia hatása**: Egyre nagyobb hatással van a hagyományos fejlesztői munkára[^5] + +**Pozitív Trendek:** + +- **Tapasztalt szakemberek iránti kereslet**: Medior és senior szakemberek továbbra is keresettek[^1] +- **Cloud és DevOps szolgáltatások növekedése**: Egyre nagyobb igény a felhőszolgáltatásokra[^6][^7] +- **GDPR és adatvédelmi tanácsadás**: Folyamatos kereslet az adatvédelmi szakértelem iránt[^8][^9][^10] + + +## 3. Szolgáltatási Portfólió Elemzés + +### IT Piaci Szegmensek + +A publikus adatok alapján a magyar IT szolgáltató cégek jellemzően az alábbi területeken tevékenykednek: + +**Szoftver és Webfejlesztés:** + +- **Egyedi weboldal fejlesztés**: 1-1.5 millió Ft költségvetés alap szint[^11] +- **Webshop megoldások**: WooCommerce/Magento alapú rendszerek[^12] +- **Fullstack fejlesztés**: Angular, React, .NET technológiákkal[^6] + +**IT Üzemeltetés és Támogatás:** + +- **Helpdesk szolgáltatások**: L1, L2, L3 szintű támogatás[^13] +- **Rendszerüzemeltetés**: Cloud és on-premise megoldások[^14] +- **Hálózati szolgáltatások**: Infrastruktúra tervezés és karbantartás[^15] + + +## 4. Versenytársak és Piaci Pozícionálás + +### Versenytárselemzés + +A magyar IT piacon aktív hasonló méretű cégek típusai: + +**Betéti Társaságok az IT szektorban:** + +- Jellemzően 2-10 főt foglalkoztató kisvállalkozások +- Specializált szolgáltatásokra fókuszálnak (webfejlesztés, GDPR tanácsadás, rendszerüzemeltetés) +- Helyi és regionális ügyfélkörrel rendelkeznek + +**Főbb Versenyelőnyök:** + +- **Személyes ügyfélkezelés**: Kis méret miatt közvetlen kapcsolat az ügyfelekkel +- **Rugalmasság**: Gyors reagálás az ügyfélszükségletekre +- **Specializáció**: Egy-két területen mélyebb szakértelem + + +## 5. Árazási Stratégia és Piaci Pozíció + +### Jellemző Árak a Magyar Piacon + +**Webfejlesztési Szolgáltatások:** + +- **Alap weboldal**: 500.000 - 1.500.000 Ft[^11] +- **Webshop**: 1.500.000 - 5.000.000 Ft[^12] +- **Egyedi alkalmazás**: 5.000.000 - 20.000.000 Ft[^11] + +**Tanácsadási Szolgáltatások:** + +- **SAP tanácsadó junior**: 600.000 - 1.000.000 Ft/hó bruttó[^16] +- **GDPR tanácsadás**: 100-300 EUR/óra[^17] +- **IT tanácsadás**: Változó, projektfüggő[^18] + + +## 6. Technológiai Trendek és Lehetőségek + +### Növekvő Igényű Területek + +**Cloud Szolgáltatások:** + +- Egyre több cég áll át felhőalapú megoldásokra[^6] +- Azure, AWS szakértelem keresett + +**Adatvédelem és Biztonság:** + +- GDPR compliance folyamatos igény[^9][^8] +- Kiberbiztonság egyre fontosabb + +**Automatizáció és AI Integráció:** + +- Tesztautomatizálás szakértők keresettek[^19] +- AI-alapú megoldások bevezetésében segítségnyújtás + + +## 7. Landing Page Tartalmi Javaslatok + +### Javasolt Struktúra mozdIT Bt. számára + +**Hero Szekció:** + +``` +"Megbízható IT partnere a digitális átállásban" +- Személyes ügyfélkezelés +- Gyors reakcióidő +- Szakértő csapat +``` + +**Szolgáltatások:** + +1. **Webfejlesztés és -tervezés** + - Egyedi weboldalak + - E-kereskedelmi megoldások + - Responsive dizájn +2. **IT Tanácsadás és Támogatás** + - Rendszerüzemeltetés + - GDPR compliance + - Biztonsági audit +3. **Cloud Migráció** + - Felhőstratégia tervezés + - Migráció végrehajtás + - Folyamatos támogatás + +**Versenyelőnyök:** + +- 🤝 Személyes kapcsolat minden ügyféllel +- ⚡ Gyors reakcióidő és rugalmasság +- 🎯 Specializált szakértelem +- 💰 Versenyképes árazás + + +## 8. Marketing és Pozícionálási Stratégia + +### Célpiac Azonosítás + +**Elsődleges célcsoport:** + +- 10-50 fős KKV-k +- Helyi szolgáltató cégek +- Startup vállalkozások + +**Másodlagos célcsoport:** + +- Nagyobb cégek részleges projektjei +- Non-profit szervezetek +- Önkormányzatok + + +### Ajánlott Pozícionálás + +"A mozdIT Bt. - Az Ön megbízható helyi IT partnere, aki személyesen ismeri az Ön üzleti kihívásait és testreszabott megoldásokat nyújt." + +## 9. Következtetések és Ajánlások + +### Stratégiai Irányok + +1. **Specializáció**: Egy-két területen való elmélyülés (pl. GDPR + webfejlesztés) +2. **Helyi fókusz**: Regionális piacon való erős pozíció kialakítása +3. **Hosszútávú kapcsolatok**: Ügyfél-megtartáson alapuló üzleti modell + +### Landing Page Fejlesztési Prioritások + +1. **Hitelesség építése**: Esetanulmányok, referenciák hangsúlyozása +2. **Személyes kapcsolat**: A csapat bemutatása, elérhetőségek kiemelése +3. **Gyors kapcsolatfelvétel**: Egyszerű kapcsolatfelvételi folyamat + +**Megjegyzés**: Ez a kutatás a jelenleg elérhető publikus információkon alapul. A mozdIT Bt. pontos profilját és szolgáltatásait csak közvetlen megkeresés vagy belső információk alapján lehet meghatározni. +[^20][^21][^22][^23][^24][^25][^26][^27][^28][^29][^30][^31][^32][^33][^34][^35][^36][^37][^38][^39][^40][^41][^42][^43][^44][^45][^46][^47][^48][^49][^50][^51][^52][^53][^54][^55][^56][^57][^58][^59][^60][^61][^62][^63][^64][^65][^66][^67][^68][^69][^70][^71][^72][^73][^74][^75][^76][^77][^78][^79][^80][^81][^82][^83] + +
⁂
+ +[^1]: https://www.reddit.com/r/programmingHungary/comments/1m68lwk/válság_van_az_it_piacon/ + +[^2]: https://www.reddit.com/r/programmingHungary/comments/1hy21an/no_fluff_jobs_fizet%C3%A9si_ir%C3%A1nyt%C5%B1_2025_salary_guide/ + +[^3]: https://www.reddit.com/r/programmingHungary/comments/1lr3tml/professionhu_it_%C3%A1ll%C3%A1shirdet%C3%A9sek_20202025/ + +[^4]: https://www.reddit.com/r/jobshungary/comments/1lbw0zg/az_it_munkaer%C5%91piac_az_ai_miatt_gyeng%C3%A9lkedik_vagy/ + +[^5]: https://www.reddit.com/r/programmingHungary/comments/1lzoqc5/miért_a_fejleszt%C3%A9st_baszogatjuk_aival/ + +[^6]: https://www.reddit.com/r/programmingHungary/comments/16rlecs/fullstack_vagy_cloud_ir%C3%A1ny/ + +[^7]: https://www.reddit.com/r/programmingHungary/comments/15tnmnp/cloud_architect_pozicio_magyarorszagon/ + +[^8]: https://www.reddit.com/r/hungary/comments/1mnm00y/az_euba_is_j%C3%B6n_a_szem%C3%A9lyivel_internetez%C3%A9s/ + +[^9]: https://www.reddit.com/r/programmingHungary/comments/1dctprl/gdpr_kij%C3%A1tszhat%C3%B3_hashel%C3%A9ssel/ + +[^10]: https://www.reddit.com/r/Netwrix/comments/n4u9ng/top_gdpr_solutions_for_security_and_consent/?tl=hu + +[^11]: https://www.reddit.com/r/programmingHungary/comments/1n024ze/egyedi_weboldal_fejleszt%C3%A9s/ + +[^12]: https://www.reddit.com/r/programmingHungary/comments/1kcjaai/van_itt_olyan_aki_az_ingyen_weboldalt_programban/ + +[^13]: https://www.reddit.com/r/ITCareerQuestions/comments/172j27a/could_you_explain_l1_l2_l3_it_terms/?tl=hu + +[^14]: https://www.reddit.com/r/hungary/comments/1m24aiz/magyar_nagyv%C3%A1llalat_%C3%A9s_a_ho_elt%C3%B6rl%C3%A9s_esete/ + +[^15]: https://www.reddit.com/r/ITCareerQuestions/comments/14qnsvj/networking_vs_cybersecurity/ + +[^16]: https://www.reddit.com/r/programmingHungary/comments/1kazdc6/sap_tan%C3%A1csad%C3%B3_junior_fizet%C3%A9s/ + +[^17]: https://www.reddit.com/r/InternalAudit/comments/1guxv9t/how_much_does_iso_27001_really_cost_could_use/?tl=hu + +[^18]: https://www.reddit.com/r/consulting/comments/1c9bjaw/blended_it_consultancy_hourly_rates/?tl=hu + +[^19]: https://www.reddit.com/r/programmingHungary/comments/1mpf19l/mennyi_a_jelenlegi_brutt%C3%B3_fizet%C3%A9sed_itban/ + +[^20]: https://www.reddit.com/r/hungary/comments/14j5bm4/hol_lehet_30_%C3%A9vesk%C3%A9nt_ismerkedni_ak%C3%A1r_kapcsolat/ + +[^21]: https://www.reddit.com/r/jobshungary/comments/1fp717x/van_itt_olyan_aki_t%C3%A9nyleg_szereti_a_munk%C3%A1j%C3%A1t/ + +[^22]: https://www.reddit.com/r/hungary/comments/1laahev/több_sz%C3%A1zezren_n%C3%A9zt%C3%A9k_meg_a_tisza_politikus%C3%A1r%C3%B3l/ + +[^23]: https://www.reddit.com/r/hungarian/comments/dmlmjb/mozogmozgatmozdulmozdít/ + +[^24]: https://www.reddit.com/r/hungary/comments/1jr57lx/orbán_bejelentette_hogy_jogszab%C3%A1llyal_fognak/ + +[^25]: https://www.reddit.com/r/askhungary/comments/16y1o4p/miért_nem_tal%C3%A1ltok_p%C3%A1rt/ + +[^26]: https://www.reddit.com/r/hungary/comments/1ksjiyz/ott_megy_az_unok%C3%A1m_a_magyar_p%C3%A9terrel/ + +[^27]: https://www.reddit.com/r/talk_hunfluencers/comments/161585s/lilg_avagy_hogyan_legy%C3%BCnk_men%C5%91k_egy_rossz/ + +[^28]: https://www.reddit.com/r/betterCallSaul/comments/um5ik5/probably_another_reason_why_jimmy_was_pissed_who/?tl=hu + +[^29]: https://www.reddit.com/r/AskALiberal/new/?tl=hu + +[^30]: https://www.reddit.com/r/programmingHungary/ + +[^31]: https://www.reddit.com/r/askhungary/comments/1m73xr1/mi_t%C3%B6rt%C3%A9nt_most_a_hardverapr%C3%B3_szervereivel/ + +[^32]: https://www.reddit.com/r/hungary/comments/r50q14/lazulós_it_c%C3%A9gek/ + +[^33]: https://www.reddit.com/r/programmingHungary/comments/1byvxo9/mikorra_saccolj%C3%A1tok_az_itpiac_talpra%C3%A1ll%C3%A1s%C3%A1t/ + +[^34]: https://www.reddit.com/r/programmingHungary/comments/12knbke/ígéretes_magyar_tech_cegek/ + +[^35]: https://www.reddit.com/r/jobshungary/comments/1mcfe3d/állami_szf%C3%A9r%C3%A1ban_mindenhol_ennyire_le_van/ + +[^36]: https://www.reddit.com/r/IndiaTax/comments/15lffxx/how_much_tds_to_deduct_for_it_consultants_working/?tl=hu + +[^37]: https://www.reddit.com/r/programmingHungary/comments/1601537/ithálózatokkal_foglalkoz%C3%B3_magyar_subreddit/ + +[^38]: https://www.reddit.com/r/ItaliaPersonalFinance/comments/zejjjx/cosa_fareste_con_60000/?tl=hu + +[^39]: https://www.reddit.com/r/hungary/comments/1lrhc8n/one_magyarorsz%C3%A1g_rant/ + +[^40]: https://www.reddit.com/r/AskProgramming/comments/1bbywhr/friend_quitting_his_current_programming_job/?tl=hu + +[^41]: https://www.reddit.com/r/askhungary/comments/1i1rg95/nem_fogok_tudni_diplom%C3%A1t_szerezni_mert_nincsenek/ + +[^42]: https://www.reddit.com/r/networking/comments/2s6ty1/what_do_you_actually_do_as_a_ccna_in_the_field/?tl=hu + +[^43]: https://www.reddit.com/r/programmingHungary/comments/1adtkia/a_fejleszt%C5%91_c%C3%A9gek_honnan_szerzik_a_projektjeiket/ + +[^44]: https://www.reddit.com/r/AskEngineers/comments/halolb/is_engineering_management_a_good_choice/?tl=hu + +[^45]: https://www.reddit.com/r/hungary/comments/1i3at6k/lázár_53000_m%C3%A1v_dolgoz%C3%B3ra_hivatkozik_val%C3%B3j%C3%A1ban/ + +[^46]: https://www.reddit.com/r/jobshungary/comments/1i27owg/introvertáltak_ti_mit_dolgoztok/ + +[^47]: https://www.reddit.com/r/CartalkHungary/comments/1hs0lbi/a_v%C3%A1lyirajong%C3%B3k_megnyugodhatnak/ + +[^48]: https://www.reddit.com/r/hungary/comments/ygf3r3/mi_volt_a_legh%C3%BCly%C3%A9bb_k%C3%A9rd%C3%A9s_amit_a_munkahelyeden/ + +[^49]: https://www.reddit.com/r/Brunei/comments/1463vcg/rbrunei_daily_random_discussion_and_small/?tl=hu + +[^50]: https://www.reddit.com/r/hungary/comments/1ljnu7g/létezik_egy%C3%A1ltal%C3%A1n_one_%C3%BCgyf%C3%A9lszolg%C3%A1lat/ + +[^51]: https://www.reddit.com/r/askhungary/comments/1jrl6sc/netflix_%C3%A1tver%C3%A9s_hivatalos_telefonsz%C3%A1mmal/ + +[^52]: https://www.reddit.com/r/hungary/comments/znkfcr/betekintés_az_%C3%BCgyf%C3%A9lszolg%C3%A1lat_munk%C3%A1j%C3%A1ba/ + +[^53]: https://www.reddit.com/r/hungary/comments/12dkont/a_betan%C3%ADtott_jelleg%C5%B1_hos_it_mel%C3%B3kra_ekkora/ + +[^54]: https://www.reddit.com/r/jobshungary/comments/1fqjy66/4_h%C3%B3napja_munkan%C3%A9lk%C3%BCli_vagyok_informatika/ + +[^55]: https://www.reddit.com/r/hungary/comments/u15zze/akik_dolgoztatok_%C3%BCgyf%C3%A9lszolg%C3%A1laton_vagy/ + +[^56]: https://www.reddit.com/r/jobshungary/comments/1ha5i7p/ügyfélszolgálati_munka/ + +[^57]: https://www.reddit.com/r/jobshungary/comments/1hzzasd/vodafone_one_call_center_munkat%C3%A1rs_fizet%C3%A9s/ + +[^58]: https://www.reddit.com/r/askhungary/comments/1fks87z/kiflihunál_dolgozott_m%C3%A1r_valaki/ + +[^59]: https://www.reddit.com/r/cybersecurity/comments/1077u03/what_do_security_engineers_do_how_to_become_one/ + +[^60]: https://www.reddit.com/r/programmingHungary/comments/1cosvrp/a_hostingb%C3%A1zis_aj%C3%A1nlott_vps_szolg%C3%A1ltat%C3%B3/ + +[^61]: https://www.reddit.com/r/Netwrix/comments/t07brg/how_to_comply_with_gdpr/?tl=hu + +[^62]: https://www.reddit.com/r/cybersecurity/comments/ti6a1n/how_to_get_started_into_cybersecurity/ + +[^63]: https://www.reddit.com/r/it/comments/1j2f8qn/choosing_between_cybersecurity_and_it_degree_will/ + +[^64]: https://www.reddit.com/r/programmingHungary/comments/1do07is/ha_az_egyetemi_informatika_szakok_nem_j%C3%B3k_arra/ + +[^65]: https://www.reddit.com/r/programmingHungary/comments/1c9b3or/mennyibe_ker%C3%BCl_egy_webshop_lefejleszt%C3%A9se/ + +[^66]: https://www.reddit.com/r/systems_engineering/comments/19214ht/writing_a_effective_systems_engineering/?tl=hu + +[^67]: https://www.reddit.com/r/webdev/comments/1c1al5o/website_development_for_small_businesses_pricing/?tl=hu + +[^68]: https://www.reddit.com/r/askhungary/comments/1it2ssy/mi_volt_a_legnagyobb_baki_amit_elk%C3%B6vett%C3%A9l_a/ + +[^69]: https://www.reddit.com/r/programmingHungary/comments/15tvus6/első_freelancer_munka_mennyit_k%C3%A9rjek/ + +[^70]: https://www.reddit.com/r/programmingHungary/comments/1k32rq7/szoftverfejlesztő_c%C3%A9gek_j%C3%B6v%C5%91je/ + +[^71]: https://www.reddit.com/r/kiszamolo/comments/13pjinu/mivel_%C3%A9rdemes_foglalkozni_ami_ma_j%C3%B3_meg%C3%A9lhet%C3%A9st/ + +[^72]: https://www.reddit.com/r/hungary/comments/tyd4qf/jól_keres%C5%91_it_programoz%C3%B3k_fejleszt%C5%91k_adjatok/ + +[^73]: https://www.reddit.com/r/programmingHungary/comments/1jnydqa/mindspire_v%C3%A9lem%C3%A9ny/ + +[^74]: https://www.reddit.com/r/writing/comments/1afxf91/bad_experience_with_writing_competitions_or_bardsy/?tl=hu + +[^75]: https://www.reddit.com/r/programmingHungary/comments/1hr4nxb/gazdaságinformatika_2025ben/ + +[^76]: https://www.reddit.com/r/programmingHungary/comments/16lq5nk/its_v%C3%A1llalkoz%C3%A1s_ind%C3%ADt%C3%A1sa/ + +[^77]: https://www.reddit.com/r/programmingHungary/comments/1jtgzt1/mps_salary_guide_2025/ + +[^78]: https://www.reddit.com/r/programmingHungary/comments/1d9cpmj/mikor_fog_helyre%C3%A1llni_az_it_szektor/ + +[^79]: https://www.reddit.com/r/programmingHungary/comments/14s3s5g/change_my_mind_it_munkaer%C5%91piac_sosem_fog_teljesen/ + +[^80]: https://www.reddit.com/r/kiszamolo/comments/18zzfiu/meddig_lesz_m%C3%A9g_ilyen_felkapottj%C3%B3l_fizetett_az/ + +[^81]: https://www.reddit.com/r/kiszamolo/comments/1e68r9i/it_meddig_lesz_ennyire_t%C3%BAl%C3%A9rt%C3%A9kelve/ + +[^82]: https://www.reddit.com/r/hungary/comments/z484vy/büfészakból_it_szektor_avagy_hogyan_v%C3%A1ltsak/ + +[^83]: https://www.reddit.com/r/jobshungary/comments/1mi888f/miért_nem_%C3%B6szt%C3%B6nzik_a_korm%C3%A1nyok_a_c%C3%A9geket_a_home/ + diff --git a/docs/logos/Generated Image September 02, 2025 - 3_12AM.jpeg b/docs/logos/Generated Image September 02, 2025 - 3_12AM.jpeg new file mode 100644 index 0000000..c2e4938 Binary files /dev/null and b/docs/logos/Generated Image September 02, 2025 - 3_12AM.jpeg differ diff --git a/docs/logos/Generated Image September 02, 2025 - 3_15AM-2.jpeg b/docs/logos/Generated Image September 02, 2025 - 3_15AM-2.jpeg new file mode 100644 index 0000000..19e7d3a Binary files /dev/null and b/docs/logos/Generated Image September 02, 2025 - 3_15AM-2.jpeg differ diff --git a/docs/logos/Generated Image September 02, 2025 - 3_15AM.jpeg b/docs/logos/Generated Image September 02, 2025 - 3_15AM.jpeg new file mode 100644 index 0000000..2030e9a Binary files /dev/null and b/docs/logos/Generated Image September 02, 2025 - 3_15AM.jpeg differ diff --git a/docs/mcp_integration_patterns_hu.md b/docs/mcp_integration_patterns_hu.md new file mode 100644 index 0000000..97fc347 --- /dev/null +++ b/docs/mcp_integration_patterns_hu.md @@ -0,0 +1,1161 @@ +# MCP Integrációs Minták Fejlesztői Környezetekhez + +A Model Context Protocol (MCP) a mesterséges intelligencia asszisztensek és fejlesztői eszközök összekapcsolásának alapvető szabványává vált, amely kifinomult munkafolyamatokat tesz lehetővé a beszélgetési AI és a strukturált vállalati rendszerek között. **A production telepítések 20,5%-kal gyorsabb feladatvégzést és 100%-os sikerességi arányt jelentenek** a nem MCP implementációkhoz képest, miközben 19,2%-kal csökkentik az API hívások számát az intelligens kontextuskezelés révén. + +## Alapvető kommunikációs architektúra + +Az MCP háromszintű architektúrán működik, amely a **JSON-RPC 2.0**-t használja kommunikációs alapként. A protokoll szabványosított interakciókat tesz lehetővé az AI gazdák (Claude Code, Cursor IDE), az MCP kliensek protokoll közvetítőkként való működése, és az MCP szerverek külső eszköz képességeinek közzététele között. Ez az architektúra N×M problémáról N+M problémára csökkenti az integráció összetettségét, az MCP-t az "USB-C az AI alkalmazásokhoz" pozícióba helyezve. + +### Protokoll inicializálás és képesség egyeztetés + +Minden MCP kapcsolat egy strukturált kézfogással kezdődik, amely protokoll verzió kompatibilitást és képesség cserét hoz létre. A kliens verzió egyeztetéssel kezd, miközben deklarálja a képességeit: + +```json +{ + "jsonrpc": "2.0", + "id": 1, + "method": "initialize", + "params": { + "protocolVersion": "2025-06-18", + "capabilities": { + "elicitation": {}, + "sampling": {} + }, + "clientInfo": { + "name": "ExampleHostApp", + "version": "1.2.0" + } + } +} +``` + +A szerver a támogatott képességeivel és eszköz ajánlataival válaszol, létrehozva a további interakciók szerződését: + +```json +{ + "jsonrpc": "2.0", + "id": 1, + "result": { + "protocolVersion": "2025-06-18", + "capabilities": { + "tools": {"listChanged": true}, + "resources": {"supported": true, "subscribe": false}, + "prompts": {"supported": false} + }, + "serverInfo": { + "name": "SampleMCPServer", + "version": "0.1.0" + } + } +} +``` + +Ez a képesség egyeztetés dinamikus eszköz felfedezést tesz lehetővé és biztosítja a kompatibilitást a különböző MCP implementációk között, a `listChanged` képesség lehetővé teszi a szervereknek új eszközök dinamikus regisztrálását futás közben. + +## Fejlesztői munkafolyamat integrációs példák + +### GitHub munkafolyamat automatizálás MCP-n keresztül + +A Claude Code a GitHubbal specializált MCP szervereken keresztül integrálódik, amelyek a repository műveleteket szabványosított eszközökként teszik elérhetővé. Egy teljes issue-tól-pull-request munkafolyamat bemutatja a protokoll gyakorlati erejét: + +**Felhasználói kérés**: "Implementálj JWT autentikációt a user service-hez a nyitott fejlesztési issue-k alapján" + +**LLM feldolgozási fázis**: +1. **Kontextus elemzés**: Claude elemzi a kérést, azonosítja a kulcs komponenseket (JWT, autentikáció, user service) +2. **Eszköz tervezés**: Meghatározza a szükséges GitHub műveletek sorrendjét (issue keresés → kódbázis elemzés → implementáció → PR létrehozás) +3. **Paraméter generálás**: A természetes nyelvet strukturált eszköz argumentumokká konvertálja + +**Issue elemzés és kód implementáció**: +```json +{ + "jsonrpc": "2.0", + "id": 7, + "method": "tools/call", + "params": { + "name": "fetch_github_issues", + "arguments": { + "repo": "company/authentication-service", + "state": "open", + "labels": ["enhancement"] + } + } +} +``` + +**LLM utó-feldolgozás**: +- **Követelmények szintézise**: Claude feldolgozza a visszakapott issue adatokat, kinyeri a közös mintákat és követelményeket +- **Architektúrális döntések**: A kódbázis elemzés alapján dönt a JWT implementációs megközelítésről (middleware, service réteg, stb.) +- **Kód generálás**: Implementációs fájlokat hoz létre megfelelő hibakezeléssel, teszteléssel és dokumentációval +- **Integrációs tervezés**: Meghatározza, hogyan integrálódik az új auth rendszer a meglévő szolgáltatásokkal + +A GitHub MCP szerver feldolgozza ezt a kérést és strukturált issue adatokat ad vissza, amelyeket a Claude Code aztán a követelmények megértésére és megoldások implementálására használ. **A Microsoft Azure DevOps csapata jelentése szerint több száz manuális teszt esetet konvertáltak automatizált szkriptekké ezzel a mintával**, a fejlesztők megjegyezték: "Szinte varázslatnak tűnt – leírni egy tesztet egyszerű angol nyelven és kapni egy futtatható automatizált szkriptet cserébe!" + +### Linear projekt menedzsment integráció + +A Linear integráció MCP-n keresztül intelligens feladat vezénylést tesz lehetővé automatizált prioritás hozzárendeléssel és csapat koordinációval: + +**Felhasználói kérés**: "Hozz létre egy magas prioritású feladatot a JWT autentikáció implementálásához és rendeld hozzá a legjobb fejlesztőhöz az auth munkához" + +**LLM érvelési folyamat**: +1. **Feladat dekompozíció**: Claude a JWT implementációt részfeladatokra bontja (tervezés, kódolás, tesztelés, telepítés) +2. **Prioritás értékelés**: Elemzi a projekt kontextust, hogy megállapítsa, megfelelő-e a "magas" prioritás a jelenlegi sprint terhelés alapján +3. **Csapat elemzés**: Feldolgozza a csapattagok adatait az autentikációs szakértelemmel rendelkező fejlesztők azonosítására, figyelembe véve a jelenlegi terhelést és múltbeli teljesítményt +4. **Kontextuális kapcsolás**: Összekapcsolja a Linear issue-t a kapcsolódó GitHub repository-kkal, dokumentációval és monitoring rendszerekkel + +```json +{ + "jsonrpc": "2.0", + "id": 8, + "method": "tools/call", + "params": { + "name": "linear_create_issue", + "arguments": { + "title": "JWT autentikációs rendszer implementálása", + "description": "Biztonságos autentikáció hozzáadása teljesítmény elemzés alapján", + "priority": "high", + "assignee": "PROMPT_ARGUMENT: legjobb fejlesztő auth munkához csapat szakértelem alapján" + } + } +} +``` + +**LLM létrehozás utáni elemzés**: +- **Függőségi térképezés**: Claude automatikusan azonosítja a kapcsolódó feladatokat és javasol kapcsolási vagy blokkoló kapcsolatokat +- **Becslési intelligencia**: Story point becsléseket ad hasonló befejezett feladatok alapján +- **Kockázat értékelés**: Megjelöli a potenciális blokkolókat vagy függőségeket, amelyek befolyásolhatják az időkeretet + +Ez a minta **AI-vezérelt projekt koordinációt** tesz lehetővé, ahol Claude elemzi a projekt kontextust, csapat képességeket és jelenlegi munkaterhelést intelligens hozzárendelési döntések meghozatalához. A rendszer automatikusan kapcsolja az issue-kat a releváns GitHub repository-khoz és monitoring rendszerekhez kereszt-MCP szerver kommunikáción keresztül. + +### Playwright teszt munkafolyamat automatizálás + +A Playwright MCP integráció a teszt munkafolyamatokat manuális szkript készítésről beszélgetési teszt generálásra alakítja: + +**Felhasználói kérés**: "Hozz létre átfogó teszteket az autentikációs flow-hoz, beleértve a szélsőséges eseteket" + +**LLM teszt stratégia fejlesztés**: +1. **Flow elemzés**: Claude feltérképezi a teljes autentikációs utazást (bejelentkezés, token validáció, session kezelés, kijelentkezés) +2. **Szélsőséges esetek azonosítása**: Automatikusan azonosítja a potenciális hiba szcenáriókat (érvénytelen hitelesítő adatok, lejárt tokenek, hálózati hibák, egyidejű sessionök) +3. **Teszt adat stratégia**: Meghatározza, milyen teszt felhasználók és szcenáriók szükségesek +4. **Állítás tervezés**: Dönt a megfelelő validációs pontokról és elvárt viselkedésekről + +**Generált implementáció**: +```javascript +// Generált Playwright teszt MCP-n keresztül +test('Autentikációs flow validáció', async ({ page }) => { + const testUser = await mcp.getTestUser(browserName); + + await page.goto('/login'); + await page.fill('[data-testid="username"]', testUser.email); + await page.fill('[data-testid="password"]', testUser.password); + + await expect(page).toHaveURL('/dashboard'); +}); +``` + +**LLM minőségbiztosítási feldolgozás**: +- **Lefedettség elemzés**: Claude biztosítja, hogy a tesztek lefedik a boldog utat, hiba szcenáriókat és határ feltételeket +- **Teljesítmény megfontolások**: Megfelelő várakozásokat és timeout kezelést ad hozzá +- **Akadálymentesség validáció**: Beépíti az ARIA címke tesztelést és billentyűzetes navigációt +- **Böngészők közötti kompatibilitás**: Generál böngésző-specifikus teszt variációkat, amikor szükséges +- **Karbantartási intelligencia**: Olyan teszteket hoz létre, amelyek ellenállnak a kisebb UI változásoknak + +**Valós világbeli hatás**: Az Azure DevOps csapatok óráról percekre csökkentették a teszt készítési időt, a generált tesztek olyan szélsőséges eseteket fedtek le, amelyeket a manuális tesztelés gyakran kihagyott. Egy csapat kritikus hibát fedezett fel a keresési funkcióban ("Star Wars" keresése elrontotta a UI-t), amely hónapokig rejtve maradt a manuális tesztelésben. + +**LLM folyamatos tanulás**: Claude tanul a teszt végrehajtási eredményekből, automatikusan javasol javításokat a teszt stratégiákhoz és azonosítja a mintákat a hibákban különböző alkalmazások között. + +## Autentikáció és session kezelési minták + +### OAuth 2.1 kötelező implementáció + +Az **MCP 2025 specifikáció kötelezővé teszi az OAuth 2.1-et** minden production szerver számára, jelentős érettséget képviselve a vállalati szintű biztonság felé. Kulcs követelmények: + +- **PKCE (Proof Key for Code Exchange) kötelező** minden klienshez S256 kód kihívás módszerrel +- **Dynamic Client Registration (DCR)** támogatás RFC7591 szerint a zökkenőmentes kliens bevezetéshez +- **Authorization Server Metadata** megfelelőség RFC8414 szerint az endpoint felfedezéshez + +```http +# Authorizációs kérés PKCE-vel +GET /oauth/authorize? + response_type=code& + client_id=mcp-client& + code_challenge=E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM& + code_challenge_method=S256& + resource=https://mcp.example.com + +# Token csere +POST /oauth/token +Content-Type: application/x-www-form-urlencoded + +grant_type=authorization_code& +code=SplxlOBeZQQYbYS6WxSbIA& +code_verifier=dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk& +resource=https://mcp.example.com +``` + +### Session életciklus és elosztott kihívások + +Az MCP session kezelés egyedi kihívásokkal néz szembe az elosztott környezetekben. A sessionök az inicializációs fázisban jönnek létre és több eszköz meghívás során fenn kell tartani őket: + +```http +POST /mcp HTTP/1.1 +Content-Type: application/json +Mcp-Session-Id: cb7ed84c-8f2f-4109-b571-2f9fb025a5c2 + +{ + "jsonrpc": "2.0", + "id": 2, + "method": "tools/call", + "params": { + "name": "database_query", + "arguments": {"query": "SELECT * FROM users WHERE active=true"} + } +} +``` + +**Production telepítési kihívás**: Multi-worker környezetek (Kubernetes, Docker Swarm) session affinitási problémákba ütköznek, ahol az egyik workerben létrehozott sessionök elérhetetlenné válnak a másikból. Megoldások: + +- **Ragadós sessionök** NGINX Plus dinamikus térképezéssel +- **Megosztott állapot tárolás** Redis klaszterekkel bérlő izolációval +- **Állapot nélküli tervezés** JWT-alapú session tokenek használatával + +NGINX Plus konfiguráció session ragadáshoz: +```nginx +upstream mcp_servers { + sticky learn create=$upstream_cookie_jsessionid + lookup=$cookie_jsessionid + zone=client_sessions:1m; + server backend1:8080; + server backend2:8080; +} +``` + +## Hibakezelés és ellenállóság mechanizmusok + +### Átfogó hiba osztályozási keretrendszer + +Az MCP háromszintű hiba modellt implementál, amely strukturált hiba válaszokat biztosít, lehetővé téve az intelligens kliens viselkedést: + +**Szállítási szintű hibák**: Hálózati timeout-ok, autentikációs hibák, kapcsolat létrehozási problémák +**Protokoll szintű hibák**: Szabványosított JSON-RPC hibakódok specifikus kliens akció útmutatással +**Alkalmazás szintű hibák**: Eszköz-specifikus hibák kontextuális hiba információval + +```json +{ + "jsonrpc": "2.0", + "id": "request-123", + "error": { + "code": -32802, + "message": "Erőforrás átmenetileg nem elérhető", + "data": { + "retry_after": 30, + "resource_id": "database-primary", + "suggested_action": "retry_with_backoff" + } + } +} +``` + +### Circuit breaker és újrapróbálkozási minták + +A production MCP implementációk kifinomult ellenállóság mintákat igényelnek a részleges hibák és szolgáltatás degradációs kezeléshez: + +```python +class CircuitBreaker: + def __init__(self, failure_threshold=3, recovery_timeout=30): + self.failure_count = 0 + self.failure_threshold = failure_threshold + self.is_open = False + self.last_failure_time = None + + async def call(self, func): + if self.is_open: + if time.time() - self.last_failure_time > self.recovery_timeout: + self.is_open = False # Fél-nyitott állapot + self.failure_count = 0 + else: + raise Exception("Circuit breaker nyitva van") + + try: + result = await func() + self.failure_count = 0 # Reset sikernél + return result + except Exception as e: + self.failure_count += 1 + self.last_failure_time = time.time() + if self.failure_count >= self.failure_threshold: + self.is_open = True + raise +``` + +**Exponenciális visszalépés zajjal** megelőzi a thundering herd problémákat: + +```python +async def retry_with_backoff(operation, max_attempts=3): + for attempt in range(max_attempts): + try: + return await operation() + except Exception as e: + if attempt == max_attempts - 1: + raise + delay = min(2 ** attempt + random.uniform(0, 1), 60) + await asyncio.sleep(delay) +``` + +## Teljesítmény optimalizálás és benchmarkolás + +### Valós világbeli teljesítmény adatok + +**Twilio MCP Server benchmark eredmények** konkrét teljesítmény metrikákat biztosítanak production telepítésekhez: + +- **Sebesség javulás**: 20,5%-kal gyorsabb feladat befejezés a nem MCP implementációkhoz képest +- **API hatékonyság**: 19,2%-os csökkentés a szükséges API hívásokban intelligens kontextus cache-elés révén +- **Sikerességi arány**: 100%-os feladat sikerességi arány vs 92,3% hagyományos integrációkkal +- **Token költség hatás**: 27,5%-os növekedés token használatban a javított kontextus miatt, de **28,5%-kal több cache olvasás** és **53,7%-kal több cache írás** hatékony optimalizálási stratégiákat jelez + +### Kontextus optimalizálási stratégiák + +Az MCP szerverek kifinomult cache-elést implementálnak a token fogyasztás minimalizálásához a kontextus gazdagság fenntartása mellett: + +```python +@lru_cache(maxsize=1000) +async def database_tool(query_hash: str, query: str): + cached_result = await redis_client.get(f"db:query:{query_hash}") + + if cached_result: + return json.loads(cached_result) + + result = await execute_database_query(query) + await redis_client.setex( + f"db:query:{query_hash}", + 300, # 5 perces TTL + json.dumps(result) + ) + return result +``` + +### Szállítási réteg teljesítmény megfontolások + +A különböző MCP szállítási mechanizmusok eltérő teljesítmény karakterisztikákat mutatnak: + +| Szállítás | Késleltetés (p99) | Áteresztőképesség | Használati eset | +|-----------|------------------|-------------------|-----------------| +| STDIO (helyi) | 1ms | 200K ops/s | Fejlesztés, helyi eszközök | +| HTTP + SSE | 15ms | 50K ops/s | Távoli szerverek, web integráció | +| WebSocket | 5ms | 100K ops/s | Valós idejű, kétirányú kommunikáció | + +**HTTP kapcsolat pooling** jelentősen javítja a teljesítményt távoli MCP szerverekhez: + +```python +async with httpx.AsyncClient( + timeout=httpx.Timeout(30.0, connect=5.0), + limits=httpx.Limits(max_connections=10, max_keepalive_connections=5) +) as client: + response = await client.post('/mcp', json=request_payload) +``` + +## Haladó eszköz láncolás és vezénylés + +### Szekvenciális eszköz láncolás eredmény átadással + +A modern MCP implementációk kifinomult eszköz láncolást támogatnak, ahol az egyik eszköz kimenetei automatikusan a következő eszközök bemenetei lesznek: + +```json +{ + "tools": [ + { + "name": "analyze_codebase", + "arguments": {"repository": "company/api-service"} + }, + { + "name": "generate_tests", + "arguments": { + "code_analysis": "PROMPT_ARGUMENT: használd a komplexitási metrikákat az előző elemzésből" + } + }, + { + "name": "create_pull_request", + "arguments": { + "tests": "PROMPT_ARGUMENT: a teszt fájlok a 2. lépésből", + "title": "PROMPT_ARGUMENT: leíró cím az elemzés alapján" + } + } + ] +} +``` + +Ez a minta **60-80%-kal csökkenti a token használatot** a szekvenciális egyedi eszköz hívásokhoz képest, miközben atomi multi-eszköz műveleteket tesz lehetővé teljes visszagörgetési képességekkel. + +### Dinamikus képesség kompozíció + +A vállalati MCP telepítések növekvően használnak dinamikus eszköz regisztrációt a változó adatforrások és üzleti követelményekhez való alkalmazkodáshoz: + +```python +class DynamicToolRegistry: + async def connect_to_data_source(self, data_source: DataSourceConfig): + schema = await self.analyze_data_schema(data_source) + generated_tools = [] + + for entity in schema.entities: + crud_tools = self.generate_crud_tools(entity, data_source) + for tool in crud_tools: + await self.register_tool(tool, data_source.security_context) + generated_tools.append(tool.name) + + await self.notify_list_changed() + return generated_tools +``` + +Ez a megközelítés **kontextus-tudatos eszköz generálást** tesz lehetővé, ahol az MCP szerverek automatikusan létrehozzák a megfelelő eszközöket a kapcsolódó rendszerek alapján, csökkentve a manuális eszköz konfigurációs igényt és javítva a rendszer alkalmazkodóképességét. + +### Multi-agent munkafolyamat vezénylés + +A haladó MCP implementációk több specializált agenst koordinálnak kifinomult vezénylési mintákon keresztül: + +- **Agent átadások** teljes kontextus megőrzéssel az átmenetek során +- **Elosztott döntéshozatal** ahol több agent hozzájárul a komplex problémamegoldáshoz +- **Hibatűrő koordináció** automatikus failover és helyreállítási mechanizmusokkal + +A **mcp-agent keretrendszer** ezt a mintát mutatja be a gyakorlatban: + +```python +from mcp_agent.workflows.orchestrator import Orchestrator + +orchestrator = Orchestrator( + worker_agents=[data_analyst, report_generator, reviewer_agent], + plan_type="iterative", + error_handling="compensating_transactions" +) + +result = await orchestrator.generate_str( + "Elemezd a Q4 eladási adatokat, generálj vezetői összefoglalót és küldd jóváhagyásra" +) +``` + +## Production telepítés és vállalati minták + +### Biztonság és megfelelőség architektúra + +A production MCP telepítések átfogó biztonsági intézkedéseket igényelnek az autentikáció, authorizáció és adatvédelem kezeléséhez: + +**Multi-réteg autentikáció**: +- OAuth 2.1 PKCE-vel kliens autentikációhoz +- mTLS szolgáltatások közötti kommunikációhoz +- SPIFFE/SPIRE munkaterhelés identitás kezeléshez +- Képesség-alapú hozzáférés kontroll finom szemcsés engedélyekhez + +**GDPR/CCPA megfelelőség** architektúrális minta szerint változik: + +| Minta | Adat törlés | Helyi vezérlés | Audit nyomvonal | +|-------|-------------|----------------|-----------------| +| Szerver oldali cache | Közvetlen kulcs törlés | Redis klaszter elhelyezés | Teljes naplózás | +| Kliens pointerek | Tárolás törlés szükséges | CDN geo-korlátozások | Hozzáférés naplózás | +| Állapottal rendelkező payload-ok | Komplex kliens oldali adat | Kliens tárolás | Korlátozott láthatóság | + +### Konténer vezénylés és skálázás + +A Kubernetes telepítések horizontális skálázást és hibatűrést tesznek lehetővé: + +```yaml +apiVersion: apps/v1 +kind: StatefulSet +metadata: + name: mcp-server-cluster +spec: + serviceName: mcp-server + replicas: 3 + template: + spec: + containers: + - name: mcp-server + image: mcp-server:latest + env: + - name: STATE_STORE + value: "redis://redis-cluster:6379" + - name: OAUTH_ENDPOINT + value: "https://auth.company.com" + resources: + requests: + memory: "512Mi" + cpu: "500m" + limits: + memory: "1Gi" + cpu: "1000m" +``` + +**Teljesítmény monitoring** kulcs metrikákra fókuszál: +- Kérés késleltetés percentilisei (p50, p95, p99) +- Eszköz végrehajtási sikerességi arányok +- Token fogyasztási minták +- Cache találat/miss arányok +- Aktív session számok + +## Gyakori hiba szcenáriók és megoldások + +### Autentikáció és session hibák + +**Session affinitási problémák** terheléselosztott környezetekben: +``` +Hiba: "Nem található session ID-hoz: cb7ed84c-8f2f-4109-b571-2f9fb025a5c2" +Alapok: Session létrehozva A workerben, kérés B workerhez irányítva +``` + +**Megoldási minták**: +- Redis-alapú megosztott session tárolás implementálása +- JWT tokenek használata állapot nélküli session kezeléshez +- Terheléselosztó ragadós sessionök konfigurálása + +### Eszköz végrehajtási timeout-ok és erőforrás korlátok + +**Erőforrás kimerülés kezelés**: +```json +{ + "jsonrpc": "2.0", + "id": "req-456", + "error": { + "code": -32801, + "message": "Tartalom túl nagy", + "data": { + "max_size": 1048576, + "actual_size": 2097152, + "suggested_action": "chunk_request" + } + } +} +``` + +**Rate limiting válaszok** irányítják a kliens viselkedést: +```http +HTTP/1.1 429 Too Many Requests +Retry-After: 30 +X-RateLimit-Limit: 100 +X-RateLimit-Remaining: 0 +X-RateLimit-Reset: 1640995260 + +{ + "error": { + "code": 429, + "message": "Rate limit túllépve", + "retry_after": 30 + } +} +``` + +## Jövőbeli megfontolások és feltörekvő minták + +Az **MCP ökoszisztéma folytatja a gyors evolúciót** vállalati igényeket kielégítő feltörekvő mintákkal: + +- **Kvantum számítástechnika integráció** ultra-gyors kontextus feldolgozáshoz specializált alkalmazásokban +- **AI-vezérelt optimalizálás** önmaga tanuló késleltetés csökkentést és erőforrás allokációt lehetővé téve +- **Neuromorphic számítástechnikai architektúrák** hatékony AI-eszköz interakciós mintákhoz tervezve + +A **token költség optimalizálás** kulcs fókusz marad, az implementációk mutatják az utat a csökkentett overhead felé a kifinomult kontextus kezelés fenntartása mellett. A jelenlegi telepítések demonstrálják, hogy bár az MCP 25-30%-os token overhead-et bevezet, az operációs előnyök (gyorsabb befejezés, magasabb sikerességi arányok, csökkentett fejlesztési idő) erős ROI indoklást biztosítanak. + +## Következtetés + +Az MCP kísérleti protokollból production-kész szabvánnyá érett, amely kifinomult AI-eszköz integrációkat tesz lehetővé. **A valós világbeli telepítések mérhető javulásokat mutatnak**: 20%+ sebesség nyereségek, 100%-os feladat sikerességi arányok és jelentős csökkentés a fejlesztési időben. A protokoll evolúciója a kötelező OAuth 2.1 autentikáció és kifinomult vezénylési minták felé a vállalati AI munkafolyamatok alapvető szabványaként pozicionálja. + +Az MCP-vel való siker megköveteli a **háromszintű architektúra** megértését, a **megfelelő autentikáció és session kezelés** implementálását, az **ellenálló hibakezelés** tervezését és a **nagy léptékű teljesítmény** optimalizálását. Az itt dokumentált minták technikai alapot biztosítanak production-kész MCP integrációk építéséhez, amelyek áthidalják a beszélgetési AI-t és a strukturált vállalati rendszereket, lehetővé téve az AI-vezérelt fejlesztői környezetek következő generációját. + +## Gyakorlati implementációs útmutató + +### MCP szerver felállítás lépésről lépésre + +**1. Alapvető MCP szerver inicializálás** + +```python +from mcp.server import Server +from mcp.types import Tool, TextContent +import asyncio + +# MCP szerver példány létrehozása +app = Server("Hungarian-Dev-Tools") + +@app.list_tools() +async def list_tools(): + return [ + Tool( + name="create_hungarian_docs", + description="Magyar nyelvű dokumentáció generálása", + inputSchema={ + "type": "object", + "properties": { + "project_name": {"type": "string"}, + "language": {"type": "string", "default": "hu"} + } + } + ) + ] + +@app.call_tool() +async def call_tool(name: str, arguments: dict): + if name == "create_hungarian_docs": + return TextContent( + type="text", + text=f"Magyar dokumentáció generálva: {arguments['project_name']}" + ) + +# Szerver indítása +if __name__ == "__main__": + asyncio.run(app.run()) +``` + +**2. Claude Code konfiguráció** + +```json +{ + "mcpServers": { + "hungarian-dev-tools": { + "command": "python", + "args": ["hungarian_mcp_server.py"], + "env": { + "PYTHONPATH": "/path/to/mcp/server" + } + } + } +} +``` + +### Hibakeresési és monitoring technikák + +**MCP kommunikáció naplózása** + +```python +import logging +from mcp.server.stdio import stdio_server + +# Részletes logging beállítása +logging.basicConfig( + level=logging.DEBUG, + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + handlers=[ + logging.FileHandler('mcp_server.log'), + logging.StreamHandler() + ] +) + +logger = logging.getLogger("hungarian-mcp") + +@app.call_tool() +async def call_tool(name: str, arguments: dict): + logger.info(f"Eszköz hívás: {name} argumentumokkal: {arguments}") + + try: + result = await process_tool_call(name, arguments) + logger.info(f"Sikeres válasz: {len(str(result))} karakter") + return result + except Exception as e: + logger.error(f"Hiba történt: {e}") + raise +``` + +**Teljesítmény metrikák gyűjtése** + +```python +import time +from dataclasses import dataclass +from typing import Dict, List + +@dataclass +class ToolMetrics: + call_count: int = 0 + total_duration: float = 0.0 + error_count: int = 0 + last_called: float = 0.0 + +class MetricsCollector: + def __init__(self): + self.metrics: Dict[str, ToolMetrics] = {} + + async def track_tool_call(self, tool_name: str, func): + start_time = time.time() + + if tool_name not in self.metrics: + self.metrics[tool_name] = ToolMetrics() + + metric = self.metrics[tool_name] + metric.call_count += 1 + metric.last_called = start_time + + try: + result = await func() + duration = time.time() - start_time + metric.total_duration += duration + + logger.info(f"Eszköz {tool_name} - Időtartam: {duration:.2f}s") + return result + except Exception as e: + metric.error_count += 1 + logger.error(f"Eszköz {tool_name} hiba: {e}") + raise + + def get_performance_report(self) -> str: + report = "=== MCP Teljesítmény Jelentés ===\n" + + for tool_name, metric in self.metrics.items(): + avg_duration = metric.total_duration / max(metric.call_count, 1) + error_rate = metric.error_count / max(metric.call_count, 1) * 100 + + report += f""" +Eszköz: {tool_name} +- Hívások száma: {metric.call_count} +- Átlagos időtartam: {avg_duration:.3f}s +- Hibaarány: {error_rate:.1f}% +- Legutóbbi hívás: {time.ctime(metric.last_called)} +""" + return report + +# Globális metrics collector +metrics = MetricsCollector() +``` + +### Biztonsági best practice-ek + +**Input validáció és sanitizáció** + +```python +from marshmallow import Schema, fields, ValidationError +import re + +class GitHubToolSchema(Schema): + repo = fields.Str(required=True, validate=lambda x: bool(re.match(r'^[\w\.-]+/[\w\.-]+, x))) + branch = fields.Str(missing='main', validate=lambda x: bool(re.match(r'^[\w\.-/]+, x))) + action = fields.Str(required=True, validate=lambda x: x in ['read', 'write', 'delete']) + +@app.call_tool() +async def call_github_tool(name: str, arguments: dict): + schema = GitHubToolSchema() + + try: + validated_args = schema.load(arguments) + except ValidationError as e: + logger.error(f"Validációs hiba: {e.messages}") + raise ValueError(f"Érvénytelen paraméterek: {e.messages}") + + # Biztonságos végrehajtás validált argumentumokkal + return await execute_github_operation(validated_args) +``` + +**Hozzáférés-vezérlés implementáció** + +```python +from functools import wraps +from typing import Set + +class PermissionManager: + def __init__(self): + self.user_permissions: Dict[str, Set[str]] = { + "admin": {"read", "write", "delete", "admin"}, + "developer": {"read", "write"}, + "viewer": {"read"} + } + + def has_permission(self, user_role: str, required_permission: str) -> bool: + return required_permission in self.user_permissions.get(user_role, set()) + +permission_manager = PermissionManager() + +def require_permission(permission: str): + def decorator(func): + @wraps(func) + async def wrapper(*args, **kwargs): + # Felhasználói szerepkör lekérése (session-ből vagy token-ből) + user_role = get_current_user_role() + + if not permission_manager.has_permission(user_role, permission): + raise PermissionError(f"Nincs jogosultság '{permission}' művelethez") + + return await func(*args, **kwargs) + return wrapper + return decorator + +@app.call_tool() +@require_permission("write") +async def create_repository(name: str, arguments: dict): + # Csak 'write' jogosultsággal rendelkező felhasználók hívhatják meg + return await github_create_repo(arguments) +``` + +### Skálázhatóság és load balancing + +**Redis-alapú session megosztás** + +```python +import redis.asyncio as redis +import json +from typing import Optional + +class RedisSessionManager: + def __init__(self, redis_url: str = "redis://localhost:6379"): + self.redis_pool = redis.ConnectionPool.from_url(redis_url) + self.redis_client = redis.Redis(connection_pool=self.redis_pool) + + async def store_session(self, session_id: str, data: dict, ttl: int = 3600): + """Session adatok tárolása Redis-ben""" + await self.redis_client.setex( + f"mcp:session:{session_id}", + ttl, + json.dumps(data) + ) + + async def get_session(self, session_id: str) -> Optional[dict]: + """Session adatok lekérése""" + data = await self.redis_client.get(f"mcp:session:{session_id}") + return json.loads(data) if data else None + + async def delete_session(self, session_id: str): + """Session törlése""" + await self.redis_client.delete(f"mcp:session:{session_id}") + +# Globális session manager +session_manager = RedisSessionManager() + +@app.initialize() +async def initialize(session_id: str): + # Session inicializálás és tárolás + session_data = { + "created_at": time.time(), + "user_id": get_authenticated_user_id(), + "permissions": get_user_permissions() + } + + await session_manager.store_session(session_id, session_data) + logger.info(f"Session inicializálva: {session_id}") +``` + +**Kubernetes deployment konfiguráció** + +```yaml +apiVersion: apps/v1 +kind: Deployment +metadata: + name: hungarian-mcp-server + labels: + app: hungarian-mcp +spec: + replicas: 3 + selector: + matchLabels: + app: hungarian-mcp + template: + metadata: + labels: + app: hungarian-mcp + spec: + containers: + - name: mcp-server + image: hungarian-mcp:latest + ports: + - containerPort: 8080 + env: + - name: REDIS_URL + value: "redis://redis-cluster:6379" + - name: LOG_LEVEL + value: "INFO" + - name: METRICS_ENABLED + value: "true" + resources: + requests: + memory: "256Mi" + cpu: "250m" + limits: + memory: "512Mi" + cpu: "500m" + readinessProbe: + httpGet: + path: /health + port: 8080 + initialDelaySeconds: 10 + periodSeconds: 5 + livenessProbe: + httpGet: + path: /health + port: 8080 + initialDelaySeconds: 30 + periodSeconds: 10 +--- +apiVersion: v1 +kind: Service +metadata: + name: hungarian-mcp-service +spec: + selector: + app: hungarian-mcp + ports: + - port: 80 + targetPort: 8080 + type: LoadBalancer +--- +apiVersion: autoscaling/v2 +kind: HorizontalPodAutoscaler +metadata: + name: hungarian-mcp-hpa +spec: + scaleTargetRef: + apiVersion: apps/v1 + kind: Deployment + name: hungarian-mcp-server + minReplicas: 2 + maxReplicas: 10 + metrics: + - type: Resource + resource: + name: cpu + target: + type: Utilization + averageUtilization: 70 + - type: Resource + resource: + name: memory + target: + type: Utilization + averageUtilization: 80 +``` + +### Fejlett eszköz készítés minták + +**Dinamikus eszköz regisztráció** + +```python +from typing import Dict, Any, List +import inspect + +class DynamicToolRegistry: + def __init__(self, server: Server): + self.server = server + self.registered_tools: Dict[str, Tool] = {} + + def register_tool_from_function(self, func, name: str = None, description: str = None): + """Python függvényből automatikusan eszköz regisztrálása""" + tool_name = name or func.__name__ + tool_description = description or func.__doc__ or f"Automatically generated tool for {func.__name__}" + + # Függvény szignatúra elemzése + sig = inspect.signature(func) + properties = {} + required = [] + + for param_name, param in sig.parameters.items(): + if param_name in ['self', 'cls']: + continue + + param_type = "string" # Alapértelmezett + if param.annotation == int: + param_type = "integer" + elif param.annotation == float: + param_type = "number" + elif param.annotation == bool: + param_type = "boolean" + + properties[param_name] = {"type": param_type} + + if param.default == param.empty: + required.append(param_name) + + # Eszköz schema generálása + input_schema = { + "type": "object", + "properties": properties, + "required": required + } + + tool = Tool( + name=tool_name, + description=tool_description, + inputSchema=input_schema + ) + + self.registered_tools[tool_name] = tool + + # Eszköz handler regisztrálása + @self.server.call_tool() + async def tool_handler(name: str, arguments: dict): + if name == tool_name: + try: + # Argumentumok átadása a függvénynek + if inspect.iscoroutinefunction(func): + result = await func(**arguments) + else: + result = func(**arguments) + + return TextContent(type="text", text=str(result)) + except Exception as e: + logger.error(f"Hiba az eszköz végrehajtása során {tool_name}: {e}") + raise + + logger.info(f"Dinamikusan regisztrált eszköz: {tool_name}") + return tool + +# Használat példa +def calculate_hungarian_tax(gross_income: int, tax_year: int = 2024) -> str: + """Magyar adókalkulátor - bruttó jövedelem alapján számítja ki a fizetendő adót""" + + # 2024-es magyar adótáblázat (egyszerűsített) + tax_rates = { + 2024: { + "personal_allowance": 77300, # Személyi kedvezmény + "tax_rate": 0.15 # SZJA alapkulcs + } + } + + if tax_year not in tax_rates: + return f"Nincs adat a {tax_year} adóévhez" + + rates = tax_rates[tax_year] + taxable_income = max(0, gross_income - rates["personal_allowance"]) + tax_amount = taxable_income * rates["tax_rate"] + net_income = gross_income - tax_amount + + return f""" +Magyar adókalkuláció ({tax_year}): +- Bruttó jövedelem: {gross_income:,} Ft +- Személyi kedvezmény: {rates['personal_allowance']:,} Ft +- Adóalap: {taxable_income:,} Ft +- SZJA ({rates['tax_rate']*100}%): {tax_amount:,} Ft +- Nettó jövedelem: {net_income:,} Ft +""" + +# Dinamikus regisztráció +tool_registry = DynamicToolRegistry(app) +tool_registry.register_tool_from_function( + calculate_hungarian_tax, + description="Magyar személyijövedelemadó kalkulátor" +) +``` + +**Kontextus-tudatos eszközök** + +```python +class ContextAwareToolMixin: + def __init__(self): + self.context_history: List[Dict[str, Any]] = [] + self.user_preferences: Dict[str, Any] = {} + + async def add_context(self, context: Dict[str, Any]): + """Kontextus hozzáadása a történethez""" + context['timestamp'] = time.time() + self.context_history.append(context) + + # Csak az utolsó 50 kontextust tartjuk meg + if len(self.context_history) > 50: + self.context_history = self.context_history[-50:] + + def get_relevant_context(self, query: str, limit: int = 5) -> List[Dict[str, Any]]: + """Releváns kontextus lekérése a query alapján""" + # Egyszerű kulcsszó alapú relevanciavizsgálat + query_words = set(query.lower().split()) + scored_contexts = [] + + for ctx in self.context_history: + ctx_text = str(ctx.get('content', '')) + ctx_words = set(ctx_text.lower().split()) + + # Jaccard similarity + intersection = len(query_words.intersection(ctx_words)) + union = len(query_words.union(ctx_words)) + + if union > 0: + similarity = intersection / union + scored_contexts.append((similarity, ctx)) + + # Relevancia szerint rendezés + scored_contexts.sort(key=lambda x: x[0], reverse=True) + return [ctx for _, ctx in scored_contexts[:limit]] + +class SmartDocumentationTool(ContextAwareToolMixin): + def __init__(self): + super().__init__() + self.project_docs: Dict[str, str] = {} + + async def generate_documentation(self, + project_name: str, + code_context: str, + doc_type: str = "API") -> str: + """Intelligens dokumentáció generálás kontextus alapján""" + + # Releváns kontextus lekérése + relevant_contexts = self.get_relevant_context( + f"{project_name} {code_context} {doc_type}" + ) + + # Kontextus alapján dokumentáció stílus személyreszabása + style_preferences = self.user_preferences.get('doc_style', 'detailed') + language = self.user_preferences.get('language', 'hungarian') + + doc_template = self._get_doc_template(doc_type, style_preferences, language) + + # Kontextus integráció + context_summary = self._summarize_context(relevant_contexts) + + documentation = doc_template.format( + project_name=project_name, + code_context=code_context, + context_summary=context_summary, + timestamp=time.strftime('%Y-%m-%d %H:%M:%S') + ) + + # Kontextus frissítése + await self.add_context({ + 'type': 'documentation_generated', + 'project': project_name, + 'doc_type': doc_type, + 'content': documentation[:500] # Csak az első 500 karakter tárolása + }) + + return documentation + + def _get_doc_template(self, doc_type: str, style: str, language: str) -> str: + templates = { + 'API': { + 'hungarian': { + 'brief': "# {project_name} API Dokumentáció\n\n{code_context}\n\nGenerálva: {timestamp}", + 'detailed': """# {project_name} API Részletes Dokumentáció + +## Áttekintés +{code_context} + +## Kontextus alapú javaslatok +{context_summary} + +## Használati példák +[Automatikusan generált példák következnek...] + +--- +Dokumentáció generálva: {timestamp} +Korábbi kontextus alapján személyre szabva. +""" + } + } + } + + return templates.get(doc_type, {}).get(language, {}).get(style, + "# {project_name}\n{code_context}\n\nGenerated: {timestamp}") + + def _summarize_context(self, contexts: List[Dict[str, Any]]) -> str: + if not contexts: + return "Nincs korábbi kontextus elérhető." + + summary_parts = [] + for ctx in contexts: + ctx_type = ctx.get('type', 'unknown') + content_preview = str(ctx.get('content', ''))[:100] + summary_parts.append(f"- {ctx_type}: {content_preview}...") + + return "Korábbi munkák alapján:\n" + "\n".join(summary_parts) + +# Regisztráció +smart_doc_tool = SmartDocumentationTool() + +@app.call_tool() +async def smart_documentation(name: str, arguments: dict): + if name == "generate_smart_docs": + return TextContent( + type="text", + text=await smart_doc_tool.generate_documentation( + arguments.get('project_name'), + arguments.get('code_context'), + arguments.get('doc_type', 'API') + ) + ) +``` + +Ez a teljes magyar nyelvű MCP dokumentáció gyakorlati implementációs útmutatókkal, monitoring technikákkal, biztonsági best practice-ekkel és fejlett eszközkészítési mintákkal egészíti ki az eredeti tartalmat. \ No newline at end of file diff --git a/docs/mozd_it_weboldal_kovetelmeny_dokploy_deploy_specifikacio_mvp.md b/docs/mozd_it_weboldal_kovetelmeny_dokploy_deploy_specifikacio_mvp.md new file mode 100644 index 0000000..f4a9b63 --- /dev/null +++ b/docs/mozd_it_weboldal_kovetelmeny_dokploy_deploy_specifikacio_mvp.md @@ -0,0 +1,236 @@ +# mozdIT Bt. — Weboldal követelmény + Dokploy deploy specifikáció (MVP) + +## 0) Rövid összefoglaló +Cél: minimális, de komplett, mobil‑első, gyors és biztonságos **bemutatkozó weboldal** a mozdIT Bt.-nek, kiemelt **Webmail** linkkel és rövid, egyedi bemutatkozással. A később készülő **admin aloldal** (szerver‑monitoring/menedzsment) helye előkészítve. Deployment és tesztelés: **Dokploy** környezetben. + +--- + +## 1) MVP oldalak és funkciók +**Oldalak** +- **Kezdőlap**: rövid, egyedi bemutatkozó szöveg; CTA: **Webmail** link (külső URL); szolgáltatások rövid dobozai. +- **Rólunk**: rövid történet, működés óta, személyes ügyfélkezelés, megbízhatóság. +- **Szolgáltatások**: web hosting, email szolgáltatás, DNS adminisztráció (rövid leírás + kapcsolat CTA). +- **Kapcsolat**: űrlap (név, email, üzenet, GDPR checkbox); cég e‑mail, telefonszám (ha lesz), cégnév, székhely. +- **Admin** (előre jelzett aloldal): `/` route fenntartva; tartalom később. + +**Funkciók (MVP)** +- Reszponzív navigáció (hamburger mobilon, sticky header desktopon). +- Űrlapvalidáció (frontend: required + e‑mail forma; backend: spam‑védett endpoint). +- SEO alapok (title/description per oldal, OG, sitemap, robots). +- Analytics: Plausible (cookieless) vagy GA4 (cookie‑consenttel). + +--- + +## 2) Nem‑funkcionális követelmények +- **Reszponzivitás:** mobile‑first; töréspontok: 360 / 640 / 768 / 1024 / 1280+ px. +- **Teljesítmény:** Lighthouse (mobil/desktop) ≥ 90; képek WebP/AVIF; lazy‑load; kritikus CSS minimalizálás. +- **A11y:** WCAG 2.1 AA (fókusz, ARIA, kontraszt ≥ 4.5:1, logikus heading). +- **Biztonság:** HTTPS, alap CSP, XSS/CSRF védelem, input szűrés a backend felé. +- **Megfigyelhetőség:** Sentry (client) + alap logok; uptime healthcheck. + +--- + +## 3) Technológiai stack +- **Frontend:** Next.js (React + TypeScript) — SSG/SSR vegyes; App Router. +- **UI:** Tailwind CSS + egyszerű saját komponensek (később: shadcn/ui opcionális). +- **Űrlapok:** React Hook Form + Zod. +- **State:** minimális local state + SWR (ha kell fetch). +- **Teszt:** Jest + Testing Library (unit), Playwright (E2E — smoke a fő flow‑kra). +- **CMS (opcionális később):** Strapi/Sanity; MVP‑ben statikus tartalom JSON/MDX. + +Projekt‑struktúra (rövid): +``` +/src + /app (Next.js routes) + /components + /styles + /lib + /tests (unit + e2e cfg) +/public +``` + +--- + +## 4) Tartalom (MVP) — copy irány +- **Hero cím** (Kezdőlap): „Megbízható web‑ és email‑szolgáltatás **személyre szabott támogatással**.” +- **Alcím:** „Kis ügyfélkör, nagy figyelem: stabil tárhely, üzembiztos levelezés és DNS adminisztráció — gyors reakcióval.” +- **USP bullet‑ek:** személyes ügyfélkezelés; gyors reagálás; stabil háttér; rugalmas támogatás. +- **Webmail gomb:** „Ugrás a Webmailre”. +- **Rólunk rövid:** mióta működtök; miért a kicsi ügyfélkör; megbízhatóság/folyamatos támogatás. +- **Szolgáltatás dobozok:** Web Hosting / Email / DNS Admin (1–2 mondat/elem, Kapcsolat CTA). + +*(Megjegyzés: a végleges szöveg a review során finomhangolható.)* + +--- + +## 5) Dokploy környezet — architektúra és folyamat + +### 5.1 Környezetek +- **Staging**: `staging.mozdit.hu` (pl. alap auth / IP‑korlátozás, ha kell) +- **Production**: `mozdit.hu` (www → apex redirect vagy fordítva) + +### 5.2 Alap komponensek +- **Reverse proxy/ingress**: Dokploy beépített (Traefik/Nginx környezet — a dokploy stack szerint). +- **App konténer**: Next.js app (Node 20) — SSG build + Node futtatás (vagy statikus export + Nginx). +- **Opció**: CDN (Cloudflare) a statikus assetekhez. + +### 5.3 Environment változók (példa) +- `NEXT_PUBLIC_WEBMAIL_URL=https://webmail.mozdit.hu` +- `COMPANY_NAME=mozdIT Bt.` +- `SITE_URL=https://mozdit.hu` +- `ANALYTICS_PROVIDER=plausible|ga4` +- `PLAUSIBLE_DOMAIN=mozdit.hu` (ha Plausible) +- `GA4_ID=G-XXXXXXX` (ha GA4) +- `CONTACT_API_URL=https://api.mozdit.hu/contact` (ha külön backend) + +### 5.4 Healthcheck & readiness +- HTTP GET `/api/health` → `{status:"ok"}` +- Staging/prod deploy csak zöld health esetén; rollback automatikus szabály (utolsó zöld image). + +--- + +## 6) Docker & build + +### 6.1 Next.js multi‑stage Dockerfile (Node 20) +```dockerfile +# 1) Build stage +FROM node:20-alpine AS builder +WORKDIR /app +COPY package.json package-lock.json* pnpm-lock.yaml* yarn.lock* ./ +RUN npm ci --prefer-offline --no-audit --legacy-peer-deps || npm ci +COPY . . +RUN npm run build + +# 2) Run stage (Node server) +FROM node:20-alpine AS runner +WORKDIR /app +ENV NODE_ENV=production +COPY --from=builder /app/.next ./.next +COPY --from=builder /app/public ./public +COPY --from=builder /app/package.json ./package.json +RUN npm ci --omit=dev --prefer-offline --no-audit || true +EXPOSE 3000 +HEALTHCHECK --interval=30s --timeout=5s --retries=5 CMD wget -qO- http://localhost:3000/api/health || exit 1 +CMD ["npm","start"] +``` +*Megjegyzés:* Ha **statikus export** (SSG only) elegendő, választható Nginx runtime is. + +### 6.2 Dokploy app (magas szint) +- **Repository link** + **branch per environment** (`main` → prod, `develop` → staging) vagy tag‑alapú deploy. +- **Build & deploy**: Dockerfile alapján; port 3000; domain mapping staging/prod; env‑ek UI‑ból/secret store‑ból. +- **Zero‑downtime**: rolling frissítés (legalább 2 replika prod‑on, ha erőforrás engedi). + +--- + +## 7) CI/CD (példa: GitHub Actions) +Workflow: **lint → unit → build → e2e (smoke, staging) → Dokploy deploy → Lighthouse check (staging) → prod release** + +`.github/workflows/ci.yml` (részlet): +```yaml +name: CI +on: + push: + branches: ["main", "develop"] +jobs: + build-test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-node@v4 + with: { node-version: 20 } + - run: npm ci + - run: npm run lint && npm run test -- --ci + - run: npm run build + docker: + needs: build-test + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Build & push image + uses: docker/build-push-action@v5 + with: + push: true + context: . + tags: registry.example.com/mozdit/site:${{ github.sha }} + deploy-staging: + needs: docker + runs-on: ubuntu-latest + steps: + - name: Trigger Dokploy staging deploy + run: | + curl -X POST "$DOKPLOY_STAGING_HOOK" -H "Authorization: Bearer $DOKPLOY_TOKEN" \ + -d '{"image":"registry.example.com/mozdit/site:${{ github.sha }}"}' + environment: staging + lighthouse: + needs: deploy-staging + runs-on: ubuntu-latest + steps: + - name: Lighthouse CI + run: npx @lhci/cli autorun --collect.url=https://staging.mozdit.hu + deploy-prod: + if: github.ref == 'refs/heads/main' + needs: lighthouse + runs-on: ubuntu-latest + steps: + - name: Trigger Dokploy prod deploy + run: | + curl -X POST "$DOKPLOY_PROD_HOOK" -H "Authorization: Bearer $DOKPLOY_TOKEN" \ + -d '{"image":"registry.example.com/mozdit/site:${{ github.sha }}"}' + environment: production +``` +*Megjegyzés:* a Dokploy‑oldali webhook/API URL és token a platform beállításától függ; ha Git integrációt használtok, a "Trigger" lépés helyett **auto‑deploy** szabály is beállítható. + +--- + +## 8) Tesztelés a Dokploy stagingen +- **Smoke E2E** (Playwright): 3 alap flow → kezdőlap betölt, Webmail link működik, Kapcsolat űrlap hibakezelés OK. +- **Vizsgálatok**: Lighthouse (mobil & desktop), A11y ellenőrző (axe), 404/500 oldal viselkedés. +- **Megfigyelés**: Sentry DSN kapcsolva; health endpoint figyelése. + +--- + +## 9) Biztonság & adatvédelem +- HTTPS (Let’s Encrypt / Dokploy integráció), HSTS. +- **CSP** baseline (script‑src 'self' + szükséges 3rd party); **Referrer‑Policy**, **X‑Frame‑Options** (SAMEORIGIN), **X‑Content‑Type‑Options**. +- **GDPR**: cookie banner ha GA4; Plausible esetén banner elhagyható. +- Kapcsolat űrlap: captcha/light rate‑limit, backend input validáció, e‑mail küldés queue‑val (ha szükséges). + +--- + +## 10) Rollback, backup, verziózás +- **Release tag** (semver) + image tag; Dokploy‑ban korábbi image visszagörgetés. +- **Konfig backup**: env‑ek és Dokploy app export; infra‑as‑code (Dockerfile, workflow‑k) GIT‑ben. + +--- + +## 11) Elfogadási kritériumok (MVP) +- Kezdőlap, Rólunk, Szolgáltatások, Kapcsolat elérhető és reszponzív. +- Webmail link jól működik (új lapon, nofollow opcionális). +- Lighthouse ≥ 90 minden fő mérőszámon stagingen. +- Űrlap hibák/fókuszállapotok a11y‑konformak. +- CI pipeline zöld, staging deploy automatikus; prod deploy csak zöld staging után. + +--- + +## 12) Kezdő feladatlista (ticket sablonok) +1. **Repo & Next.js bootstrap** — *Acceptance*: app indul dev módban; TS, ESLint, Prettier beállítva. +2. **Tailwind + alap layout** — *Acceptance*: reszponzív header/footer; tipográfia, színek. +3. **Kezdőlap (Hero + USP + Webmail CTA)** — *Acceptance*: 1s alatt festődik mobilon; link működik. +4. **Rólunk oldal** — *Acceptance*: heading‑hierarchia helyes; szövegek MDX‑ből tölthetők. +5. **Szolgáltatások oldal** — *Acceptance*: 3 doboz + CTA → Kapcsolat. +6. **Kapcsolat űrlap + API stub** — *Acceptance*: validáció, hibák; egyszerű spam‑védelem. +7. **/api/health endpoint** — *Acceptance*: `{status:"ok"}` JSON. +8. **Dockerfile + Dokploy staging app** — *Acceptance*: buildel, deployol, domain él. +9. **CI (lint, unit) + Staging deploy trigger** — *Acceptance*: PR‑re fut; stagingre pushol. +10. **Playwright smoke E2E + Lighthouse CI** — *Acceptance*: fut stagingen, riport mentve. +11. **Prod app + domain + HTTPS** — *Acceptance*: élő site; automatikus HTTPS; monitoring bekapcsolva. + +--- + +## 13) Későbbi bővítések +- Blog/Újdonságok; többnyelvűség; admin aloldal funkciói; CDN cache; képgenerálás; CMS integráció. + +--- + +*Megjegyzés:* A végleges Dokploy beállítások (webhook/API, auto‑deploy, replika szám, storage) a rendelkezésre álló szerver erőforrásoktól és a Dokploy verziójától függően finomhangolandók. +