Jedan članak objašnjava principe i praksu MCP-a

Yang Fan3317 reči11 minuta

Uvod od Alibaba sestre

MCP (Model Context Protocol) predstavlja uspostavljanje standarda za interakciju AI-a sa spoljašnjim alatkama i podacima. Kroz ovaj članak možemo saznati suštinu, vrednost, upotrebu i razvoj MCP-a.

Šta je MCP

MCP je otvoreni, univerzalni, konsenzusni protokol standard koji vodi Anthropic (Claude).

MCP je standardni protokol, kao da ste na AI velikom modelu instalirali "univerzalno priključak", tako da AI model može da nesmetano interaguje sa različitim izvorima podataka i alatkama. On je kao USB-C priključak, pruža standardizovani metod za povezivanje AI modela sa različitim izvorima podataka i alatkama.
MCP cilja da zameni fragmentirane integracije Agent koda, čineći AI sisteme pouzdanijim i efikasnijim. Uvodom univerzalnog standarda, provajderi usluga mogu da nude svoje AI sposobnosti na osnovu protokola, čime podržavaju programere da brže grade moćnije AI aplikacije. Programeri ne moraju ponovo da "pronalazu tople", kroz open-source projekte mogu da izgrade moćan AI Agent ekosistem.
MCP može da održava kontekst između različitih aplikacija/usluga, poboljšavajući ukupnu sposobnost autonomnog izvršavanja zadataka.

Arhitektura MCP-a

MCP sledi arhitekturu klijent-server, uključuje sledeće ključne delove:

MCP domaćini (MCP Hosts): AI aplikacija koja inicira zahtev, npr. chatbot, AI pokrećeni IDE itd.
MCP klijenti (MCP Clients): unutar programa domaćina, održavaju 1:1 vezu sa MCP serverom.
MCP serveri (MCP Servers): pružaju kontekst, alatke i informacije o promptovima za MCP klijente.
Lokalni resursi (Local Resources): resursi na lokalnom računaru kojima MCP server može bezbedno da pristupa, npr. datoteke, baze podataka.
Udaljeni resursi (Remote Resources): resursi na koje MCP server može da se poveže, npr. podaci dostavljeni putem API-ja.

Na primer, trenutno još uvek ne možemo istovremeno kroz neku AI aplikaciju da obavimo pretragu na internetu, slanje imejlova, objavljivanje blogova itd., pojedinačne funkcije nisu teško za realizovati, ali ako želimo sve da integrišemo u jedan sistem, postaje ne dostižno. Možete da zamislite svakodnevni razvoj, imate IDE, možete kroz AI IDE da obavite sledeće poslove.

Pitati AI da upita podatke iz lokalne baze podataka da pomogne razvoju
Pitati AI da pretraži Github Issue da prosudi da li je neki problem poznati bug
Putem AI poslati mišljenja o PR-u kolegi u instant messaging softver (npr. Slack) za Code Review
Putem AI upiti ili izmeniti trenutnu AWS, Azure konfiguraciju da dovrši deployment

Ako imate MCP? Ako druge usluge slede MCP standard, onda je kao univerzalni priključak, razvoj postaje efikasniji.

Pretpostavimo da koristite AI programerskog pomoćnika da vam pomogne da napišete kod. Ovaj AI pomoćnik je MCP domaćin. Treba da pristupi nekim spoljašnjim resursima, npr. repozitorijumu koda, dokumentaciji ili alatkama za otklanjanje grešaka. MCP server je kao posrednik, povezuje ove resurse sa AI pomoćnikom.

Kada treba da pronađete upotrebu neke funkcije, AI pomoćnik šalje zahtev MCP serveru putem MCP klijenta.
MCP server prima zahtev, traži relevantne informacije u repozitorijumu koda ili dokumentaciji.
Nakon pronalaženja informacija, MCP server vraća rezultat AI pomoćniku.
AI pomoćnik na osnovu vraćenih informacija generiše kod ili objašnjenje i prikazuje vam.

Nakon korišćenja MCP-a, možete direktno reći AI: "pomozite mi da proverim prosečnu ocenu poslednjeg matematikog testa, pripremite spisak studenata koji nisu položili u dnevni red i podsetite ih na dopunski ispit u WeChat grupi". AI će automatski obaviti: povezati se sa vašim računarom putem "univerzalnog priključka" MCP, pročitati Excel ocene. Povezati se sa WeChat-om putem MCP, pronaći relevantne istorijat ćaskanja. Izmeniti online dokument putem MCP, ažurirati dnevni red. Ceo proces ne zahteva ručno uplitanje, podaci ne napuštaju vaš uređaj, bezbedno i efikasno.

Dakle, moć MCP-a je u tome što ne treba ponovo "pronalazići tople". Ranije je svaki softver (npr. WeChat, Excel) morao zasebno da radi interfejs za AI, sada MCP unificira standard, kao svi uređaji koriste USB-C priključak za punjenje, AI jednim interfejsom može da se poveže sa svim alatkama. Pored toga, podaci se ne šalju u oblak, AI ih direktno procesira lokalno. Na primer, vaša lista ocena postoji samo na vašem računaru, AI je čita i analizira putem MCP-a, ali podaci neće procuriti.

MCP čini AI "više razume" kontekst, npr. ako pitate AI "sumiraj ključne tačke sastanka klase prošle nedelje", on može automatski da dozove snimak sastanka, istorijat ćaskanja, beleške, sintetiše te informacije i vam daje odgovor, umesto da izmišlja. Dakle, MCP pruža moćnu alatku za AI aplikacije, omogućavajući im fleksibilnije i bezbednije interakciju sa spoljašnjim svetom.

Princip MCP-a

VS Function Call

Rođenje MCP-a označava da je prompt engineering ušao u novi fazu razvoja, kroz pružanje strukturiranijih informacija o kontekstu značajno poboljšava sposobnosti modela. Prilikom dizajniranja prompt-a, naš cilj je možemo integrisati konkretnije informacije (npr. lokalne datoteke, sadržaj baze podataka ili podatke u realnom vremenu sa mreže), kako bi model mogao da bolje razume i reši stvarne probleme.

U vreme bez MCP-a, da bismo rešili složene probleme, morali smo ručno da filtriramo informacije iz baze podataka ili koristimo alatke da pronađemo relevantne informacije i da ih jednu po jednu dodajemo u prompt. Ovaj metod je efikasan za rešavanje jednostavnih problema (kao što je model radi sumiranje), ali kako se složenost problema povećava, ovaj metod postaje sve teži.

Da bi se prevazišli ovi izazovi, mnoge platforme velikih jezičkih modela (LLM) (npr. OpenAI i Google) uvele su function call funkcionalnost. Ovaj mehanizam dozvoljava modelu da po potrebi poziva predefinisane funkcije da bi dobio podatke ili izvršio specifične operacije, značajno poboljšavajući stepen automatizacije. Međutim, function call ima i svoja ograničenja, uključujući visoku zavisnost o platformi i razlike u API implementaciji između različitih LLM platformi, što programere primorava da prepisuju kod pri promeni modela, povećavajući troškove razvoja. Pored toga, postoje izazovi u bezbednosti i interaktivnosti.

U stvari, podaci i alatke su uvek tamo, ključno je kako ih inteligentnije i unifikovanije povezati sa modelom. Anthropic je na osnovu ovakvih potreba dizajnirao MCP, kao "univerzalni adapter" za AI modele, omogućavajući LLM-u lako pristup podacima ili pozivanje alatki. Konkretno, prednosti MCP-a se ogledaju u sledećem:

Ekosistem: MCP pruža bogatu bibliotecu dodataka, vaše AI aplikacije mogu direktno da koriste. Svi provajderi usluga mogu da se priključe po MCP protokolu, programeri mogu direktno da koriste. Može se predvideti, ovaj ekosistem će postajati sve veći, što je ekosistem veći, to je AI moćniji.
Kompatibilnost: sve dok svi slede jedan set protokola, mogu se ostvariti "povezivanje svih stvari". Ne ograničava se na specifični AI model, bilo koji model koji podržava MCP može fleksibilno da se menja i koristi.

Kako model inteligentno bira Agent/alatku

MCP je ključni što nam omogućava lako pozivanje više alatki, ali uz to dolazi i pitanje: kada LLM (model) odlučuje koje alatke da koristi? Anthropic nam je dao detaljno objašnjenje, kada korisnik postavi pitanje:

Klijent (Claude Desktop / Cursor) šalje pitanje LLM-u.
LLM analizira dostupne alatke i odlučuje koju da koristi (ili više njih).
Klijent izvršava izabrane alatke putem MCP Server-a.
Rezultati izvršenja alatke šalju se natrag LLM-u.
LLM sintetiše rezultate i generiše prirodni jezik za prikaz korisniku!

Prvo razumite prvi korak: kako model određuje koje alatke da koristi? Možemo se referisati na zvanični client example MCP-a kao primer, i relevantan kod smo pojednostavili (uklonili smo deo koda za upravljanje izuzecima koji ne utiče na razumevanje logike). Analizom ovog koda, možemo videti da model se oslanja na prompt da prepozna koje su alatke trenutno dostupne. Konkretno, opis upotrebe svake alatke pretvaramo u tekst i šaljemo modelu, tako da model može da zna koje alatke mogu biti izabrane i na osnovu trenutne situacija donosi najbolji izbor. Pogledajte komentare u kodu:

... # izostavili smo nevezani kod

 async def start(self):

     # inicijalizujemo sve mcp servere

     for server in self.servers:

         await server.initialize()

     # dobijamo sve alatke i nazivamo ih all_tools

     all_tools = []

     for server in self.servers:

         tools = await server.list_tools()

         all_tools.extend(tools)

     # formatiramo opis svih alatki u string za LLM

     # tool.format_for_llm() sam stavio na kraj ovog koda, radi lakšeg čitanja.

     tools_description = "\n".join(

         [tool.format_for_llm() for tool in all_tools]

     # pitamo LLM (Claude) koje alatke treba da koristi.

     system_message = (

         "You are a helpful assistant with access to these tools:\n\n"

         f"{tools_description}\n"

         "Choose the appropriate tool based on the user's question. "

         "If no tool is needed, reply directly.\n\n"

         "IMPORTANT: When you need to use a tool, you must ONLY respond with "

         "the exact JSON object format below, nothing else:\n"

         "{\n"

         '    "tool": "tool-name",\n'

         '    "arguments": {\n'

         '        "argument-name": "value"\n'

         "    }\n"

         "}\n\n"

         "After receiving a tool's response:\n"

         "1. Transform the raw data into a natural, conversational response\n"

         "2. Keep responses concise but informative\n"

         "3. Focus on the most relevant information\n"

         "4. Use appropriate context from the user's question\n"

         "5. Avoid simply repeating the raw data\n\n"

         "Please use only the tools that are explicitly defined above."

     messages = [{"role": "system", "content": system_message}]

     while True:

         # Final... pretpostavimo da je ovo već procesiralo unos korisnika.

         messages.append({"role": "user", "content": user_input})

         # šaljemo system_message i poruku korisnika zajedno LLM-u

         llm_response = self.llm_client.get_response(messages)

... # kasnije nije vezano za određivanje alatki

class Tool:

"""Represents a tool with its properties and formatting."""

def __init__(

    self, name: str, description: str, input_schema: dict[str, Any]

) -> None:

    self.name: str = name

    self.description: str = description

    self.input_schema: dict[str, Any] = input_schema

# pretvara ime alatke / opis alatke (description) i parametre alatke (args_desc) u tekst

def format_for_llm(self) -> str:

    """Format tool information for LLM.

    Returns:

       A formatted string describing the tool.

"""

    args_desc = []

    if "properties" in self.input_schema:

        for param_name, param_info in self.input_schema["properties"].items():

            arg_desc = (

                f"- {param_name}: {param_info.get('description', 'No description')}"

            if param_name in self.input_schema.get("required", []):

                arg_desc += " (required)"

            args_desc.append(arg_desc)

    return f"""

Tool:

Description:

Arguments:

"""


Gde dolazi opis alatke i input_schema u kodu? Daljom analizom izvornog koda MCP Python SDK-a možemo otkriti: u većini slučajeva, kada koristimo dekorater @mcp.tool() da dekoriramo funkciju, odgovarajući name i description itd. zapravo potiču direktno iz imena funkcije koju je definisao korisnik i docstring-a funkcije itd. Ovde sam naveo mali deo, za više detalja pogledajte originalni kod.

@classmethod

def from_function(

cls,

fn: Callable,

name: str | None = None,

description: str | None = None,

context_kwarg: str | None = None,

) -> "Tool":

"""Create a Tool from a function."""

func_name = name or fn.__name__ # dobija ime funkcije

if func_name == "&lt;lambda&gt;":

    raise ValueError("You must provide a name for lambda functions")

func_doc = description or fn.__doc__ or "" # dobija docstring funkcije

is_async = inspect.iscoroutinefunction(fn)

    ... # za više detalja pogledajte originalni kod...

Zaključak: model određuje koje alatke da koristi putem prompt engineering-a, tj. pružanjem strukturisanog opisa svih alatki i few-shot primera. S druge strane, Anthropic je sigurno specijalno trenirao Claude, jer je to njihov protokol, Claude bolje razume prompt alatki i izlazni strukturirani tool call json kod.

Mehanizam izvršenja alatki i povratne informacije

Izvršenje alatki je prilično jednostavno i direktno. Na osnovu prethodnog koraka, šaljemo system prompt (instrukcije i opis poziva alatki) i poruku korisnika zajedno modelu, zatim primamo odgovor modela. Kada model analizira zahtev korisnika, odlučuje da li treba da pozove alatku:

Bez potrebe za alatkom: model direktno generiše odgovor na prirodnom jeziku.
Potrebna alatka: model izlazi sa strukturnim JSON zahtevom za poziv alatke.

Ako odgovor sadrži strukturni JSON zahtev za poziv alatke, klijent će izvršiti odgovarajuću alatku na osnovu ovog json koda. Konkretna logika implementacije je u process_llm_response, kod i logika su vrlo jednostavni.

Ako model izvrši tool call, rezultat izvršenja result će se zajedno sa system prompt-om i porukom korisnika ponovo poslati modelu, tražeći od modela da generiše konačan odgovor. Šta ako json kod tool call-a ima problem ili model generiše halucinaciju? Čitanjem koda možemo videti da će preskočiti nevažeće zahteve. Relevantni kod i komentari su sledeći:

... # izostavili smo nevezani kod

 async def start(self):

    ... # gore smo već predstavili kako model bira alatke

    while True:

        # pretpostavimo da je ovo već procesiralo unos korisnika.

        messages.append({"role": "user", "content": user_input})

        # dobijamo izlaz LLM-a

        llm_response = self.llm_client.get_response(messages)

        # procesiramo izlaz LLM-a (ako ima tool call, izvršavamo odgovarajuću alatku)

        result = await self.process_llm_response(llm_response)

        # ako result i llm_response nisu isti, znači da je izvršen tool call (ima dodatnih informacija)

        # tada rezultat tool call-a ponovo šaljemo LLM-u za procesiranje.

        if result != llm_response:

            messages.append({"role": "assistant", "content": llm_response})

            messages.append({"role": "system", "content": result})

            final_response = self.llm_client.get_response(messages)

            logging.info("\nFinal response: %s", final_response)

            messages.append(

                {"role": "assistant", "content": final_response}

        # inače znači da nije izvršen tool call, direktno vraćamo izlaz LLM-a korisniku.

        else:

            messages.append({"role": "assistant", "content": llm_response})

Na osnovu gore navedene analize principa, može se videti da je dokumentacija alatki ključna. Model se oslanja na tekstualni opis alatki da razume i odabere odgovarajuću alatku, što znači da je pažljivo pisanje imena alatke, docstring-a i opisa parametara od posebne važnosti. S obzirom da mehanizam izbora MCP-a bazira na prompt-u, teoretski bilo koji model može biti kompatibilan sa MCP-om ako može da pruži odgovarajući opis alatki.

Praksa razvoja MCP Server-a

Za većinu AI programera, pored razumevanja principa MCP-a, više se brine o implementaciji Server-a. Zato ovde pripremim najjednostavniji primer da predstavim kako implementirati MCP Server. MCP serveri mogu da pruže tri glavne vrste funkcionalnosti:

Tools (alatke): funkcije ili interfejsi spoljašnjih usluga koje LLM može da poziva, zahteva autorizaciju korisnika.
Resources (resursi): pružaju strukturirane podatke slične datotekama, za LLM čitanje i analizu. Npr. sadržaj lokalne datoteke, JSON podatke vraćeni sa remote API-ja, rezultati upita baze podataka itd.
Prompts (promptovi): prethodno pripremljeni šabloni koji pomažu korisnicima da obave specifične zadatke

Ovaj tutorijal će se uglavnom fokusirati na alatke (Tools).

1, Najbolja praksa korišćenja LLM-a za izgradnju MCP-a

Pre početka, Anthropic nam je pružio najbolju praksu razvoja MCP Server-a na osnovu LLM-a (https://modelcontextprotocol.io/tutorials/building-mcp-with-llms), Guide posebno naglašava, ova praksa se bazira na Claude, ali se može koristiti i sa drugim LLM-ovima. Zaključak je sledeći:

Uvedite domain knowledge (ljudski jezik: recite mu neke primere i materijale za razvoj MCP Server-a)

Posetite https://modelcontextprotocol.io/llms-full.txt i kopirajte kompletan tekst dokumenta. (Merenje je predugo, možete ignorisati)
Navigirajte do MCP TypeScript SDK ili Python SDK Github projekta i kopirajte relevantan sadržaj.
Koristite ovo kao prompt i unesite ga u vaš chat dijalog (kao kontekst).

Opišite vaše potrebe

Koje resurse će vaš server otvoriti
Koje alatke će pružiti
Kakva vođstva ili savete treba dati
Sa kojim spoljašnjim sistemima treba da interaguje

Dajte primer prompt-a:

... (ovde je već uvedeno domain knowledge)

Izgradite MCP server koji može: `

Povezati se sa PostgreSQL bazom podataka moje kompanije
Izložiti strukturu tabela kao resurs
Pružiti alatke za izvršavanje read-only SQL upita
Uključiti vođstva za česte zadatke analize podataka

Ostatak je takođe važan, ali je više metodološki, manje praktičan, neću se širiti, preporučujem da direktno pogledate link: https://modelcontextprotocol.io/tutorials/building-mcp-with-llms.

2, Praktični rad

Ovaj deo se uglavnom odnosi na zvaničnu dokumentaciju: Quick Start: For Server Developers (https://modelcontextprotocol.io/quickstart/server). Ovde sam pripremio jednostavan primer, korišćenjem Python-a implementiram MCP Server za brojanje txt datoteka na trenutnom desktop-u i dobijanje imena odgovarajućih datoteka (možete razumeti kao da nema nikakve koristi, ali dovoljno je jednostavan, uglavnom za čitaoce koji teško konfigurišu okruženje da pružim dovoljno kratak zapis prakse). Sve prakse su izvršene na mom MacOS sistemu.

Step1. Priprema

Instalirajte Claude Desktop.
Python 3.10+ okruženje
Python MCP SDK 1.2.0+

Step2. Konfiguracija okruženja

# instalirajte uv

curl -LsSf https://astral.sh/uv/install.sh | sh

kreirajte direktorijum projekta

uv init txt_counter

cd txt_counter

 `
`
`
# podesite Python 3.10+ okruženje

echo "3.11" > .python-version

kreirajte virtuelno okruženje i aktivirajte

uv venv

source .venv/bin/activate

 `
`
`
# Instalirajte zavisnosti

uv add "mcp[cli]" httpx

Kreirajte našu server datoteku

touch txt_counter.py


> Pitanje: šta je uv i kakva je razlika u odnosu na conda?
> Odgovor: Ultra brzi (100x) menadžer Python paketa i okruženja napisan u Rust-u, razvijen od Astral. Pozicioniran kao zamena za pip i venv, fokusira se na brzinu, jednostavnost i moderni Python workflow.

#### Step3. Konstruišite prompt

"""

... (ovde je već uvedeno domain knowledge)

""" Izgradite MCP server koji može:

Funkcionalnosti: - Broji txt datoteke na trenutnom desktop-u - Dobija imena odgovarajućih datoteka Zahtevi:
Nemojte dati prompt i resource vezane kod. `
Možete pretpostaviti da je putanja vašeg desktop-a /Users/{username}/Desktop `

Domain Knowledge kopirano iz README datoteke MCP Python SDK-a (https://raw.githubusercontent.com/modelcontextprotocol/python-sdk/refs/heads/main/README.md)

Step4. Implementacija MCP Server-a

Sledeći kod je direktno generisan od strane Claude 3.7. Naravno, ovde je zato što su zahtevi dovoljno jednostavni, kada treba implementirati složen MCP Server, možda treba više koraka vođenja i Debug-a da bi se dobio konačni kod.

import os

from pathlib import Path

from mcp.server.fastmcp import FastMCP
`
`
`
`
`
# kreirajte MCP Server

mcp = FastMCP("Desktop TXT brojač")
`
`
`
`
`
@mcp.tool()

def count_desktop_txt_files() -> int:

     """Count the number of .txt files on the desktop."""

     # Get the desktop path

     username = os.getenv("USER") or os.getenv("USERNAME")

     desktop_path = Path(f"/Users/{username}/Desktop")
`
`
`
`
`

 # Count .txt files

 txt_files = list(desktop_path.glob("*.txt"))

 return len(txt_files)

` @mcp.tool()

def list_desktop_txt_files() -> str:

"""Get a list of all .txt filenames on the desktop."""

# Get the desktop path

username = os.getenv("USER") or os.getenv("USERNAME")

desktop_path = Path(f"/Users/{username}/Desktop")

    # Get all .txt files

    txt_files = list(desktop_path.glob("*.txt"))
`
`
`
`
`

# Return the filenames

if not txt_files:

    return "No .txt files found on desktop."

    # Format the list of filenames

    file_list = "\n".join([f"- {file.name}" for file in txt_files])

    return f"Found {len(txt_files)} .txt files on desktop:\n{file_list}"
`
`
`
`
`
`
`
if __name__ == "__main__":

    # Initialize and run the server

    mcp.run()

Zadatak je vrlo jednostavan, potreban je samo poziv veoma osnovnog os-a da bi se dovršio.

Step5. Testiranje MCP Server-a

$ mcp dev txt_counter.py

Starting MCP inspector...

Proxy server listening on port 3000
`
`
`
`
`
`
MCP Inspector je pokrenut na http://localhost:5173

Nakon toga ulazite u dati link, možete raditi kao na slici:

Step6. Integracija sa Claude-om

Poslednji korak je integrisati naš MCP u Claude Desktop. Proces je sledeći:

# otvorite claude_desktop_config.json (MacOS / Linux)

# ako koristite cursor ili vim, zamenite odgovarajuću komandu

code ~/Library/Application\ Support/Claude/claude_desktop_config.json

U konfiguracionu datoteku dodajte sledeći sadržaj, ne zaboravite da zamenite relevantne putanje stvarnim putanjama.

   "mcpServers": {

      "txt_counter": {

        "command": "/opt/homebrew/bin/uv",

        "args": [

           "--directory",

           "/Users/yangfan/mcp/txt_counter",

           "run",

           "txt_counter.py"

Najbolje je da uv bude apsolutna putanja, preporučujem da koristite which uv da biste je dobili.

Nakon konfigurisanja, restartujte Claude Desktop, ako nema problema, trebalo bi da vidite odgovarajući MCP Server.

Step7. Stvarna upotreba

Zatim, kroz jednostavan prompt vršimo stvarni test:

Da li možete da nagovestite značenje imena txt datoteka na mom trenutnom desktop-u?

Može vas zatražiti za dozvolu za upotrebu, kao na slici 1, možete kliknuti Allow for This Chat

Izgleda da naš MCP Server radi normalno!

3, MCP Server Debug

Debug je vrlo složena tema, ovde direktno preporučujem zvanični tutorijal:

Official Tutorial: Debugging:https://modelcontextprotocol.io/docs/tools/debugging
Official Tutorial: Inspector:https://modelcontextprotocol.io/docs/tools/inspector

Zaključak

MCP (Model Context Protocol) predstavlja uspostavljanje standarda za interakciju AI-a sa spoljašnjim alatkama i podacima. Kroz ovaj članak možemo saznati:

Suštinu MCP-a: to je unificirani protokol standard, omogućava AI modelu da na dosledan način povezuje različite izvore podataka i alatke, slično "USB-C" priključku u AI svetu.
Vrednost MCP-a: rešava problem zavisnosti o platformi tradicionalnog function call-a, pruža jedinstveniji, otvoreniji, bezbedniji i fleksibilniji mehanizam poziva alatki, omogućavajući korisnicima i programerima da profitiraju.
Upotrebu i razvoj: za obične korisnike, MCP pruža bogate postojeće alatke, korisnici mogu da ih koriste bez razumevanja tehničkih detalja; za programere, MCP pruža jasnu arhitekturu i SDK, čime razvoj alatki postaje relativno jednostavan.

MCP je još uvek u fazi ranog razvoja, ali njegov potencijal je ogroman. Važnije od toga je ekosistem, ekosistem izgrađen na osnovu unificiranog standarda će takođe pozitivno promicati razvoj čitave oblasti. Možete pogledati platformu MCP alatki: https://mcp.so/

Tongyi Qianwen i LangChain izgradnjuju dijalog servis

Kombinacija Tongyi Qianwen i LangChain tehnologije gradi efikasan model dijaloga, ovaj model se bazira na tehnologiji obrade prirodnog jezika za poboljšanje semantičkog razumevanja i korisničkog iskustva interakcije.

Kliknite "Pročitajte originalni tekst" za detalje.