O Protocolo de Contexto de Modelo (MCP) surgiu da questão da incompatibilidade. Em nossas vidas diárias, a incompatibilidade nos traz transtornos de várias maneiras.
Você já levou um aparelho para cabelo ou um dispositivo eletrônico em uma viagem ao exterior e percebeu que o plugue era incompatível com a tomada? Do ponto de vista do desenvolvedor, esse problema é tão frustrante quanto criar APIs e ferramentas de desenvolvimento para seu agente de IA, que parecem não conseguir se conectar nem invocar corretamente. É exatamente aí que o MCP alivia esse problema de incompatibilidade.
O Model Context Protocol (MCP) introduzido pela Anthropic em 2024 serve como uma camada de padronização para aplicações de IA se comunicarem de forma eficaz com serviços externos, como ferramentas, fontes de dados/conjuntos de dados e modelos predefinidos. O MCP serve essencialmente como um padrão aberto e conector para interações entre IA e ferramentas. A arquitetura MCP pode ser dividida em três componentes arquitetônicos principais:
- MCP host: Uma aplicação de IA recebe as solicitações do usuário e busca acesso ao contexto por meio do MCP
- Cliente MCP: A comunicação no ecossistema MCP entre o host e o servidor deve passar por um cliente. Esse cliente existe dentro do host e converte as solicitações do usuário em um formato estruturado que o protocolo aberto pode processar.
- Servidor MCP: O serviço externo que apresenta o contexto para o LLM convertendo as solicitações do usuário em ações do servidor. Exemplos de integrações de servidores MCP, também conhecidos como conectores MCP, são Slack, GitHub, Git, Docker ou pesquisa na web.
Primeiro, o que é IBM Bob? O IBM Bob é um ambiente de desenvolvimento integrado (IDE) e assistente de modernização com tecnologia de IA generativa. Pense no Bob como seu IDE com ênfase em IA e seu parceiro de programação: uma ferramenta que entende sua intenção, sua base de código e os padrões da sua organização.
A criação do seu próprio servidor MCP do zero pode ser demorado, especialmente para desenvolvedores iniciantes. Em vez disso, neste tutorial vamos explorar como iniciar rapidamente esse fluxo de trabalho com o IBM Bob utilizando alguns prompts simples de linguagem natural.
A integração do MCP estende a funcionalidade do Bob conectando-se a ferramentas e serviços externos, configuráveis no nível global (aplica-se a todos os espaços de trabalho) ou no projeto (compartilhável pela equipe por meio de níveis .Bob/mcp.json). O MCP aceita dois tipos de transporte: entrada/saída padrão (STDIO) para servidores locais de baixa latência e eventos enviados pelo servidor (SSE) para servidores MCP remotos acessíveis por meio de HTTP/HTTPS. Os usuários podem configurar servidores com arquivos JSON no menu de configurações do Bob, definindo comandos, variáveis de ambiente e ferramentas aprovadas automaticamente. Ambos os tipos de transporte permitem ativar ou desativar servidores, aprovar automaticamente ferramentas específicas e gerenciar suas operações por meio do painel de configurações do MCP do Bob.
- IDE IBM Bob instalada. Inscreva-se para acesso antecipado ao IBM Bob.
Vamos começar. Se preferir acompanhar este tutorial no GitHub, confira nosso repositório..
Passo 1. Configure seu cadastro com o Bob
1. Abra a IDE IBM Bob que você instalou como pré-requisito e familiarize-se com o layout do seu novo parceiro de programação de AI Coding.
2. Para acessar o painel de configurações do MCP, clique nos três pontos ao lado do ícone de engrenagem no canto superior direito da janela de chat. Em seguida, selecione os servidores MCP. a partir do menu suspenso.
Aqui você pode habilitar ou desabilitar o MCP globalmente ou por servidor e gerenciar as ferramentas (por exemplo, aprovação automática, exclusão ou reinicialização). Também podemos explorar servidores comunitários por meio do Bob Marketplace ou criar nossos próprios com o SDK do MCP.
Se você optar por instalar um servidor do mercado, notará que as configurações podem ser definidas em dois níveis: global (armazenado em
As configurações em nível de projeto substituem as globais, oferecendo flexibilidade para adaptar o comportamento do MCP a diferentes casos de uso. Para gerenciar essas configurações, você pode editar arquivos JSON diretamente através do menu de configurações do Bob, onde você define detalhes do servidor como comandos, variáveis de ambiente e ferramentas aprovadas automaticamente. Neste tutorial usaremos o SDK.
3. Certifique-se de que a configuração Habilitar Criação de Servidores MCP esteja ativa para criar servidores MCP personalizados com o Bob.
4. Se você tiver um diretório preferido para configurar seu projeto, você mesmo poderá abri-lo dentro do IDE ou pedir que Bob faça isso por você na janela de chat.
Etapa 2. Ative um ambiente virtual
- Vamos sair do painel de configurações e voltar à janela de chat.
- Você deve ter notado que há modos diferentes do Bob, como plan, code, advanced, ask e orchestrator. Para este projeto, defina o modo como avançado.
3. É prática comum criar ambientes virtuais do Python para isolar as dependências de um projeto para projetos diferentes não entrarem em conflito. Para isso, digite o seguinte comando: “Neste diretório, ative um ambiente virtual Python”.
4. Você deverá ver o Bob executar uma série de comandos de terminal. Esses comandos provavelmente serão semelhantes a:
source venv/bin/activate
Recomendamos que você mantenha o controle de aprovação automática desabilitado para poder aprovar ou negar cada comando antes que Bob o execute em tempo real.
Ótimo. Bob criou e ativou com sucesso um novo ambiente virtual no diretório
Etapa 3. Bob gera um plano
Com nosso ambiente virtual configurado, agora podemos avançar para a criação do servidor MCP. Solicitando que o Bob gere código, ou qualquer modelo de IA ou assistente de IA, é útil incluir detalhes importantes. Para ver o Bob em ação, vamos enviar o prompt:
“Crie um servidor MCP que forneça acesso somente leitura ao arXiv. O servidor deve:
- Expor uma ferramenta de busca para consultar artigos do arXiv
- Limitar os resultados a metadados e resumos em papel (sem PDFs)
- Impor limites razoáveis de consultas e resultados
- Normalizar as respostas em um esquema limpo e estruturado”
Com esse único prompt simples, Bob tem informações suficientes para entender a tarefa e formular uma "lista de tarefas" de etapas a fim de concluir a tarefa. Observe que a lista contém não apenas a criação do servidor MCP, como também sua configuração e teste. Ótimo.
Observe que usamos a API arXiv neste tutorial como um exemplo simples que não requer nenhuma chave de API ou autenticação para começar. No entanto, este é um exemplo e Bob também está bem equipado para lidar com servidores mais complexos com permissões necessárias.
Etapa 4. Bob cria um servidor MCP personalizado.
- Bob agora está pronto para iniciar a série de tarefas para construir o servidor arXiv MCP. Para começar, Bob cria a estrutura do projeto manualmente executando:
Antes de cada comando ser executado, podemos aprovar ou negar a ação. Se você perceber que os comandos estão sendo executados automaticamente, pode ser que você tenha ativado o botão de aprovação automática.
2. Em seguida, Bob cria um arquivo
{
"name": "arxiv-server",
"version": "0.1.0",
"description": "MCP server for read-only access to arXiv papers",
"type": "module",
"bin": {
"arxiv-server": "./build/index.js"
},
"arquivos": [
"build"
],
"scripts": {
"build": "tsc && node -e \"require('fs').chmodSync('build/index.js', '755')\"",
"prepare": "npm run build",
"watch": "tsc --watch"
},
"palavras-chave": [
"mcp",
"arxiv",
"research"
"papers"
],
"dependências": {
"@modelcontextprotocol/sdk": "^1.0.4",
"axios": "^1.7.9",
"zod": "^3.24.1"
},
"devDependencies": {
"@types/node": "^22.10.5",
"typescript": "^5.7.3"
}
}
- Em seguida, o Bob cria o arquivo
arxiv-server/tsconfig.json
{
"compilerOptions": {
"target": "ES2022",
"module": "Node16",
"moduleResolution": "Node16",
"outDir": "./build",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"resolveJsonModule": true,
"declaration": true
}, "include": ["src/**/*"], "exclude": ["node_modules", "build"] }
4. Em seguida, a implementação do servidor principal com funcionalidade de pesquisa arXiv é armazenada em
- Importa todas as bibliotecas necessárias.
- Define a estrutura das respostas da API arXiv.
- Converte a resposta XML do arXiv em um objeto JavaScript estruturado (já que a API do arXiv retorna XML, não JSON).
- Extrações:
- Detalhes do artigo (título, autores, resumo etc.).
- Informações de paginação (total de resultados, índice inicial, itens por página).
- Pega os dados analisados e os formata em uma string legível para exibição no terminal.
- Define uma função de pesquisa que recebe uma consulta, oferece suporte a filtros opcionais, busca dados da API do arXiv e retorna resultados formatados (ou um erro é algo errado).
- Inicia o servidor.
#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import axios from 'axios';
// Define types for arXiv API responses
interface ArxivEntry {
id: string;
title: string;
summary: string;
authors: Array<{ name: string }>;
published: string;
updated: string;
categories: string[];
primary_category: string;
links: Array<{ href: string; rel: string; type?: string }>;
}
interface ArxivSearchResult {
entries: ArxivEntry[];
totalResults: number;
startIndex: number;
itemsPerPage: number;
}
// Create an MCP server
const server = new McpServer({
name: "arxiv-server",
version: "0.1.0"
});
// Create axios instance for arXiv API
const arxivApi = axios.create({
baseURL: 'http://export.arxiv.org/api',
timeout: 30000,
});
/**
* Parse arXiv API XML response to JSON
*/
function parseArxivXML(xmlData: string): ArxivSearchResult {
const entries: ArxivEntry[] = [];
// Extract total results
const totalResultsMatch = xmlData.match(/<opensearch:totalResults[^>]*>(\d+)<\/opensearch:totalResults>/);
const totalResults = totalResultsMatch ? parseInt(totalResultsMatch[1]) : 0;
const startIndexMatch = xmlData.match(/<opensearch:startIndex[^>]*>(\d+)<\/opensearch:startIndex>/);
const startIndex = startIndexMatch ? parseInt(startIndexMatch[1]) : 0;
const itemsPerPageMatch = xmlData.match(/<opensearch:itemsPerPage[^>]*>(\d+)<\/opensearch:itemsPerPage>/);
const itemsPerPage = itemsPerPageMatch ? parseInt(itemsPerPageMatch[1]) : 0;
// Extract entries
const entryRegex = /<entry>([\s\S]*?)<\/entry>/g;
let entryMatch;
while ((entryMatch = entryRegex.exec(xmlData)) !== null) {
const entryXml = entryMatch[1];
// Extract ID
const idMatch = entryXml.match(/<id>([^<]+)<\/id>/);
const id = idMatch ? idMatch[1] : '';
// Extract title
const titleMatch = entryXml.match(/<title>([^<]+)<\/title>/);
const title = titleMatch ? titleMatch[1].trim().replace(/\s+/g, ' ') : '';
// Extract summary
const summaryMatch = entryXml.match(/<summary>([^<]+)<\/summary>/);
const summary = summaryMatch ? summaryMatch[1].trim().replace(/\s+/g, ' ') : '';
// Extract authors
const authors: Array<{ name: string }> = [];
const authorRegex = /<author>\s*<name>([^<]+)<\/name>/g;
let authorMatch;
while ((authorMatch = authorRegex.exec(entryXml)) !== null) {
authors.push({ name: authorMatch[1].trim() }); } // Extrai data de publicação const publishedMatch = inputXml.match(/<published>([^<]+)<\/published>/);
const published = publishedMatch ? publishedMatch[1] : --; // Extrai a data atualizada const UpdatedMatch = inputXml.match(/<updated>([^<]+)<\/updated>/);
const updated = updatedMatch ? CreatedMatch[1] : ”; // Extrai categorias const Categories: string[] = []; const CategoriesRegex = /<category[^>]+term="([^"]+)"/g; let CategoriesMatch; while ((categoryMatch = CategoriesRegex.exec(entryXml)) !== null) {
categories.push(categoryMatch[1]);
}
const primary_category = Categories [0] || “;
//Extrai links
const links: Array<{ href: string; rel: string; type?: string }> = [];
const linkRegex = /<link[^>]+href="([^"]+)"[^>]+rel="([^"]+)"(?:[^>]+type="([^"]+)")?/g;
let linkMatch;
while ((linkMatch = linkRegex.exec(entryXml)) !== null) {
links.push({
href: linkMatch[1],
rel: linkMatch[2],
type: linkMatch[3]
}); } inputs.push({
id,
title,
summary,
authors,
published,
updated,
categories,
primary_category,
links
});
}
retorne {
entries,
totalResults,
startIndex,
itemsPerPage
};
}
/**
* Formata resultados de busca para exibição
*/
função formatSearchResults(resultado: ArxivSearchResult): string {
let output = `Found ${result.totalResults} results (showing ${result.entries.length})\n\n`;
result.entries.forEach((entry, index) => {
output += `${index + 1}. ${entry.title}\n`;
produção += ` ID: ${entry.id}\n`;
produção += ` Autores: ${entry.authors.map(a => a.name).join(', ')}\n`;
produção += ` Publicado: ${entry.published}\n`;
produção += ` Categories: ${entry.categories.join(', ')}\n`;
produção += ` Abstract: ${entry.summary.substring(0, 300)}${entry.summary.length > 300 ? '...' : ''}\n`;
// Encontrar link para abstract (não PDF)
const abstractLink = entry.links.find(l => l.rel === 'alternate'); if (abstractLink) {
output += ` URL: ${abstractLink.href}\n`; } produção += '\n'; }); return produção; } // Adiciona uma ferramenta para pesquisar papéis de arXiv server.tool(
"search_arxiv", {
query: z.string().describe("Search query (supports arXiv query syntax)"),
max_results: z.number().min(1).max(50).optional().describe("Maximum number of results to return (1-50, default: 10)"),
start: z.number().min(0).optional().describe("Starting index for pagination (default: 0)"),
sort_by: z.enum(["relevance", "lastUpdatedDate", "submittedDate"]).optional().describe("Sort order (default: relevance)"),
sort_order: z.enum(["ascending", "descending"]).optional().describe("Sort direction (default: descending)")
}, async ({ query, max_results = 10, start = 0, sort_by = "relevance", sort_order = "descending" }) => {
try {
// Enforce reasonable limits
const limitedMaxResults = Math.min(max_results, 50);
const limitedStart = Math.max(start, 0);
// Build query parameters
const params: Record<string, string | number> = {
search_query: query,
start: limitedStart,
max_results: limitedMaxResults,
}; if (sort_by) {
params.sortBy = sort_by;
} if (sort_order) {
params.sortOrder = sort_order;
} const response = await arxivApi.get('/query', { params }); // Analisa a resposta XML const resultados = parseArxivXML(response.data);
// Formata resultados
const formattedResults = formatSearchResults(resultados);
return {
content: [
{
type: "text",
text: formattedResults,
},
],
};
} catch (error) {
if (axios.isAxiosError(error)) {
return {
content: [
{
type: "text",
text: `arXiv API error: ${error.response?.data?.message ?? error.message}`,
},
],
isError: true,
};
}
throw error;
}
}
);
// Comece a receber mensagens por stdin e a enviar mensagens por stdout
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('arXiv servidor MCP em execução no stdio'); // Feito com Bob
Nesse estágio, se o servidor exigir alguma chave de API, o Bob as solicitará.
5. Como próxima etapa, Bob instala as dependências dentro do diretório arxiv-server executando o seguinte comando.
- Bob agora está pronto para adicionar as configurações do servidor MCP ao arquivo de configurações. Servidores MCP globais são configurados em
mcp_settings.json.Bob/mcp.json
{
"mcpServers": {}
"mcpServers": {
"arxiv": {
"command": "node",
"args": [ "/here/is/the/path/to/arxiv-server/build/index.js"
],
"disabled": false,
"alwaysAllow": [],
"disabledTools": []
}
}
}
Essas informações completam a série de etapas que Bob segue para configurar o servidor MCP.
Etapa 5. Teste o servidor MCP
Para concluir a série de tarefas da "lista de tarefas", Bob testa o servidor MCP. Como visto na tela anterior, Bob consulta a ferramenta
Após a execução bem-sucedida, que você pode ver clicando na cenoura virada para baixo para expandir a janela, Bob fez outro teste. Desta vez, a consulta é para dois artigos de aprendizado de máquina classificados por data de envio decrescente. Mesmo com o uso dos parâmetros diferentes, essa chamada de ferramenta MCP também foi executada com sucesso.
Com os testes bem-sucedidos, Bob agora concluiu todas as subtarefas.
Bob já testou o servidor MCP para nós. No entanto, vamos tentar algumas consultas próprias na janela de chat para ver se Bob consegue extrapolar os termos de pesquisa corretos e os parâmetros necessários.
Pergunte ao Bob: "Quais são os artigos mais recentes sobre rastreamento de agentes da LLM?"
Por conta própria, Bob extraiu a consulta correta do nosso prompt e acrescentou algumas palavras-chave adicionais para melhorar a pesquisa. Bob também definiu o número máximo de resultados como 10 e classificou os artigos por relevância. Ótimo.
Vamos tentar mais uma consulta.
Curiosamente, o Bob ajustou automaticamente a consulta de pesquisa ao perceber resultados indesejados. Bob não está executando cegamente chamadas de ferramentas, mas sim colaborando com o usuário como um agente útil. Depois de duas iterações, Bob retornou vários artigos que se alinham bem com nossa tarefa inicial.
Etapa 6. Documente o servidor
Muitos servidores MCP de código aberto também contêm documentos para outras pessoas começarem a utilizar com facilidade. Vamos colar este prompt na janela de chat:
“Neste diretório, crie um arquivo README.md para documentar este servidor MCP. Inclua instruções de configuração e uso.”
Com um simples prompt, Bob criou um documento
Etapa 7. (opcional) Criar agente do watsonx Orchestrate
Talvez você tenha interesse em construir um agente de IA especializado em pesquisa com o watsonx Orchestrate® que possa acessar esse servidor MCP? O Bob pode criar um agente com apenas um prompt simples. Primeiro instale o servidor ADK do watsonx Orchestrate criado previamente a partir do mercado encontrado no painel de configurações do MCP que exploramos na etapa 1. Depois envie este comando:
“Crie um agente watsonx Orchestrate que utilize esse servidor arxiv MCP.”
Se você tiver o serviço watsonx Orchestrate em execução no local, Bob executará os comandos necessários para você. Se você preferir executar os comandos por conta própria posteriormente, o Bob escreverá os scripts e documentará todos os comandos necessários.
Vamos examinar cada arquivo para entender melhor o que Bob gerou. Aqui está o arquivo toolkit-config.yaml
kind: mcp name: arxiv-toolkit description: Toolkit para pesquisar artigos de pesquisa arXiv. Dá acesso a metadados de artigos, resumos e informações de publicação do banco de dados arXiv.
package_root: /local/path/to/arxiv-server
language: node
command: node /local/path/to/arxiv-server/arxiv-server/build/index.js
tools:
- "*"
# Feito com o Bob
Em seguida, vamos abrir o arquivo pesquisa-assistant-agent.yaml
name: research-assistant
kind: native
description: assistente de pesquisa de IA que ajuda a encontrar e resumir artigos acadêmicos da arXiv. Especializa-se em pesquisar literatura científica, explicar resultados de pesquisas e apresentar citações.
título: Instruções do assistente de pesquisa: | Você é um assistente de pesquisa especializado em pesquisa de literatura acadêmica no arXiv.
## Seus recursos
- Pesquise no arXiv artigos sobre qualquer tópico científico
- Resumar as conclusões da pesquisa a partir de resumos em linguagem simples.
- Identifique autores-chave e tendências de pesquisa
- Sugira artigos e tópicos relacionados.
- Apresente citações adequadas com IDs e URLs do arXiv.
## Ao responder aos usuários
1. Sempre informe as IDs do arXiv e os URLs diretos dos artigos.
2. Resuma os resumos em linguagem acessível.
3. Destaque as principais contribuições e conclusões.
4. Sugira pesquisas complementares quando relevantes.
5. Seja conciso, mas informativo.
## Utilizando a ferramenta search_arxiv
Parâmetros disponíveis:
- consulta (obrigatório): Consulta de pesquisa usando a sintaxe do arXiv
- max_results (opcional): 1-50 artigos, padrão 10
- start (opcional): Índice inicial para paginação, padrão 0
- sort_by (opcional): "relevância", "data de envio" ou "data da última atualização"
- ordem_de_classificação (opcional): "ascendente" ou "descendente"
## Sintaxe de pesquisa Advanced Você pode usar esses operadores em consultas:
- ti:palavra-chave - Pesquisar no título
- au:autor - Pesquise por nome do autor
- abs:palavra-chave - Pesquisar no resumo
- cat:categoria - Filtrar por categoria (ex: cs.IA, quant-ph, math.CO)
- AND, OR, ANDNOT - Operadores booleanos
Exemplos:
- "ti:transformer AND cat:cs.LG" - Papéis do transformador no aprendizado de máquina
- "au:Hinton" - Artigos de Geoffrey Hinton
- "computação quântica AND cat:quant-ph" - computação quântica em física quântica
## Legenda comum
- cs.IA - Inteligência Artificial
- cs.LG - aprendizado de máquina
- cs.CL - Computação e Linguagem
- cs.CV - Computer Vision
- quant-ph - Física Quantum - math.CO - Combinatória
- estatística.ML - aprendizado de máquina (Estatísticas)
## Formato de resposta
Ao apresentar trabalhos, utilize este formato:
**"Título do Artigo"**
- Autores: [Nomes dos autores]
- Publicado em: [Data]
- categoria: [categoria]
- Resumo: [Breve resumo do resumo]
- [Ver artigo](URL do arXiv)
## Tratamento de casos extremos
- Caso nenhum resultado seja encontrado: Sugira termos de pesquisa alternativos ou consultas mais abrangentes.
- Se houver muitos resultados: Recomenda-se refinar a pesquisa com filtros de categoria ou data.
- Se o usuário solicitar PDFs: explique que você fornece apenas os metadados, mas inclua o URL onde ele possa acessar o documento.
- Se a dúvida não estiver clara: Faça perguntas para esclarecê-la sobre a área de pesquisa ou interesses específicos.
ferramentas:
- pesquisa_arxiv
configuração:
oculto: falso
ativar_cot: verdadeiro
etiquetas:
- pesquisa
-ss
- documentos
- arxiv
- pesquisa bibliográfica
# Feito com Bob
Esse arquivo YAML configura nosso assistente de pesquisa, um agente de IA especializado que simplifica a pesquisa acadêmica pesquisando arXiv, resumindo artigos e apresentando citações em um formato estruturado. Incluem instruções detalhadas que orientam o comportamento do agente, desde a sintaxe da consulta e o uso de ferramentas até a formatação da resposta e o tratamento de edge-cases. Todas essas informações são detalhadas com a ferramenta search_arxivsetup-instructions.md
Neste tutorial, usamos o IBM Bob, um IDE orientado por IA e parceiro de programação, para simplificar a integração do MCP em pesquisas acadêmicas. Você criou com eficiência um servidor MCP escalável capaz de pesquisar e recuperar artigos do repositório arXiv.org. Agora sua solução está pronta para produção, quer você opte por colocá-la em código aberto para a comunidade de pesquisa ou implementá-la em suas aplicações para aprimorar a descoberta de conhecimento.
A verdadeira magia do IBM Bob está em sua capacidade de transformar tarefas complexas de desenvolvimento em fluxo de trabalho intuitivos e baseados em prompts. Com apenas algumas entradas estratégicas, o Bob acelera a prototipagem, reduz o código padrão e até sugere otimizações, permitindo que você se concentre na inovação em vez da implementação.
Enquanto você continua a explorar seus recursos, considere como o Bob pode refinar ainda mais seu servidor MCP. Entre os benefícios, podemos listar a adição de filtragem avançada, atualizações em tempo real ou integração com outras bases de dados acadêmicas, como PubMed ou IEEE Xplore. Todas essas possibilidades e muito mais são possíveis com alguns prompts simples utilizando o IBM Bob.
Pronto para dar o próximo passo? Experimente personalizar seu servidor MCP ou conheça a fundo as funcionalidades do Bob para liberar ainda mais potencial de automação. Boa programação!
Recursos
Crie, implemente e gerencie assistentes e agentes de IA potentes que automatizam fluxos de trabalho e processos com a IA generativa.
Construa o futuro do seu negócio com soluções de IA em que você pode confiar.
Os serviços de IA da IBM Consulting ajudam a reinventar a forma como as empresas trabalham com IA para gerar transformação.