Como criamos a plataforma de trading mais poderosa com Machine Learning: a crônica da evolução do MQL e do MetaTrader com base em arquivos, fóruns e releases

Dos primeiros EAs ao AI Assistant baseado em agentes, MCP e OpenBLAS: a evolução do ecossistema MQL.

A história do MQL é a trajetória de uma linguagem simples para estratégias de trading até um ambiente completo de desenvolvimento e análise com MetaEditor, MQL5, Python, ONNX, AI Assistant baseado em agentes, MCP (Model Context Protocol), OpenBLAS e a infraestrutura Git do Algo Forge.

De uma linguagem para EAs a um ambiente de desenvolvimento

Hoje, já é difícil enxergar o MetaEditor apenas como um editor de código. Ele inclui documentação, compilador, depuração, profiling, projetos, integração com o MQL5.COM, repositório centralizado de código-fonte, integração com Python, suporte a ONNX, AI Assistant, acesso a bancos de dados SQLite e arquivos CSV como tabelas editáveis. Mas tudo isso não surgiu de uma hora para outra.

Desde as primeiras gerações da plataforma, a MetaQuotes seguiu uma direção clara: oferecer ao trader não apenas um gráfico e um botão para executar operações, mas também a possibilidade de expressar uma ideia de trading por meio de um programa, testá-la com dados históricos e colocá-la em operação sem intervenção humana. A história do MQL é a história de como uma linguagem simples para EAs evoluiu gradualmente até se tornar um ambiente completo de engenharia.

A internet não preservou tudo. Algumas páginas antigas desapareceram, outras sobreviveram apenas no Internet Archive Wayback Machine, e parte do material continua disponível em arquivos de fóruns e notícias antigas. Ainda assim, há registros suficientes para identificar a principal linha de evolução:

Fx Charts → MetaQuotes → MetaTrader → MetaTrader 4 → MetaTrader 5

Essa ressalva é importante. Nos arquivos, é possível encontrar diferentes números de build, designações internas e nomes de tópicos antigos dos fóruns, mas a história pública das plataformas é melhor compreendida como uma sequência de produtos e ideias, e não como uma cadeia mecânica de números. O ponto central dessa história não é o número da versão, mas a transformação gradual de um terminal de trading em um ambiente de trabalho para o desenvolvedor.

Os EAs surgiram antes da linguagem

A primeira menção ao site da MetaQuotes no arquivo da web data de fevereiro de 2001. A MetaQuotes Software Corp foi oficialmente registrada em 27 de novembro de 2000, mas as discussões sobre a futura plataforma e a automação do trading começaram ainda antes. O arquivo conserva uma publicação no fórum datada de 23 de novembro de 2000, quatro dias antes do registro da empresa.

O mais interessante nesse registro tão antigo não é a aparência do site nem os detalhes técnicos. O ponto importante é outro: a linguagem MQL ainda não existia, mas a ideia dos Expert Advisors já estava presente. Desde o início, a proposta não se limitava a gráficos e cotações, mas incluía a programação de sistemas de trading.

Isso define o tom de toda a evolução que viria depois. Desde o início, a MetaQuotes enxergava o terminal não como uma janela passiva para acompanhar o mercado, mas como um ambiente em que o usuário pudesse traduzir uma estratégia em regras algorítmicas e delegar sua execução à máquina.

MetaQuotes e o primeiro MQL

A primeira menção pública relevante ao MQL data de novembro de 2001. Na época, foi lançada a versão 1.78 do MetaQuotes, que passou a permitir a criação de estratégias de trading próprias, os Expert Advisors, usando a linguagem interna MetaQuotes Language.

A notícia publicada na época já delineava todo o programa de desenvolvimento que viria a seguir: os EAs deveriam implementar a lógica de trading, ser testados com dados históricos, executar operações automaticamente na conta e controlar posições abertas sem intervenção humana.

Pelos padrões atuais, o primeiro MQL era extremamente modesto. Sua documentação cabia em uma única página HTML curta. A linguagem não tinha laços, arrays nem a estrutura convencional de um programa completo. Os cálculos eram feitos com um pequeno conjunto de variáveis predefinidas de ponto flutuante.

Mas seria um erro avaliar essa etapa apenas pela sintaxe. O principal avanço não estava na riqueza da linguagem, e sim no nível de integração. O programa Expert Advisor era executado diretamente no terminal cliente gratuito, tinha acesso a séries temporais e indicadores técnicos, podia analisar o mercado e enviar ordens de trading ao servidor.

É justamente aqui que surge um princípio que mais tarde se tornaria padrão em todo o ecossistema MQL: uma estratégia de trading não é um sinal externo que precisa ser transferido manualmente para o terminal, mas um programa executável dentro da própria plataforma de trading.

MetaTrader: uma nova plataforma e um novo patamar

Em maio de 2002, começou o teste aberto do novo sistema MetaTrader. Não se tratava de uma atualização meramente cosmética, mas de uma reescrita substancial dos componentes de servidor e de gerenciamento. Os anúncios mencionavam suporte a centenas de instrumentos, aos mercados Forex, CFD, Futures e Stocks, novos protocolos de comunicação e capacidade para atender milhares de usuários online.

Para a história do MQL, essa etapa é importante por dois motivos.

Primeiro, o terminal passou a fazer parte de um sistema mais amplo. O trading automatizado já não deveria funcionar em uma sandbox meramente experimental, mas em uma infraestrutura com servidor, ferramentas de gerenciamento, grande número de usuários e diferentes classes de instrumentos financeiros.

Segundo, ficou claro que a linguagem antiga já não era suficiente. Se o usuário deveria não apenas ativar um EA pronto, mas realmente descrever sua própria lógica de trading, a linguagem precisava se aproximar cada vez mais da programação convencional.

MQL II: a linguagem começa a se parecer com uma linguagem de programação

No outono de 2002, a versão 2.03 do MetaTrader trouxe uma nova variante da linguagem, o MQL II.

Ela já não podia ser vista como um simples conjunto de fórmulas para um EA. A documentação do MQL II era aproximadamente três vezes maior que a do primeiro MQL, embora ainda coubesse em uma única página HTML. O MQL II passou a oferecer variáveis dos tipos ponto flutuante, string e booleano, arrays, laços for e while, além de um conjunto ampliado de funções incorporadas. Entre elas estavam as funções matemáticas Abs, Ceil, Cos, Exp, Floor, Log, Mod, Pow, Round, Sin, Sqrt e Tan.

Esse foi um avanço importante. O usuário ainda escrevia programas dentro de limites bastante rígidos: um único arquivo-fonte descrevia, na prática, uma única função executável, acionada a cada novo tick do instrumento. Ainda assim, dentro dessa estrutura já era possível desenvolver uma lógica mais complexa, usar condições, laços, arrays e cálculos matemáticos.

Mais tarde, tornou-se possível chamar um arquivo externo já compilado, o que resolvia parcialmente a ausência de funções definidas pelo usuário dentro de um único arquivo-fonte. A implementação interna ainda estava muito distante do que viria a ser o MQL4 e o MQL5: o código era executado por uma máquina de pilha baseada em notação polonesa reversa. Para o usuário, porém, esse não era o aspecto principal. O mais importante era que a estratégia de trading estava deixando de ser apenas um conjunto de condições e se transformando gradualmente em um programa completo.

Em termos de sintaxe, o MQL II lembrava Pascal. Isso também não era por acaso. Durante muito tempo, Pascal foi considerado uma linguagem adequada ao ensino de programação, e a filosofia da MetaQuotes naquela época buscava ser o mais acessível possível: todo usuário do terminal deveria ter a possibilidade de programar sua própria estratégia de trading.

Indicadores personalizados: o MQL vai além dos EAs

Na primavera de 2003, o desenvolvimento do MQL deu outro passo importante. Em março, novos indicadores incorporados e funções para manipulação de arquivos foram adicionados ao terminal: FileOpen, FileClose, FileDelete, FileSize, FileTell, FileSeek, FileWrite, FileReadNumber, FileReadString e outras.

Mas a principal mudança veio em abril de 2003: a versão 3.10 do MetaTrader passou a permitir o uso de indicadores e funções personalizados em MQL.

Isso ampliou o papel da linguagem. Até então, o MQL estava associado principalmente aos EAs: o usuário descrevia uma estratégia de trading e o terminal a executava a cada tick. Os indicadores personalizados introduziram outro cenário: o trader passou a poder programar não apenas decisões de trading, mas também suas próprias ferramentas de análise do mercado.

Assim, o MQL começou a abranger duas áreas da atividade do trader: a tomada de decisões de trading e a criação de ferramentas analíticas. Mais tarde, essa combinação se consolidaria como padrão no MetaTrader 4: EAs, indicadores, scripts e bibliotecas passariam a ser vistos como diferentes tipos de programas dentro de um mesmo ambiente.

Etapa de transição: da simplicidade a uma linguagem completa

Em meados de 2003, já estava claro que a próxima grande plataforma não poderia ser apenas uma continuação da arquitetura anterior. Era necessário um novo produto, uma nova linguagem e um novo ambiente de desenvolvimento.

Ao longo do desenvolvimento, houve soluções de transição que deixaram poucos vestígios na internet pública. Ainda assim, a direção das mudanças é bastante clara. Os desenvolvedores decidiram abandonar o modelo "um arquivo-fonte, uma função", a execução baseada em pilha e uma sintaxe excessivamente voltada ao ensino. A futura linguagem deveria se aproximar das linguagens de sintaxe semelhante à de C, oferecer suporte a estruturas de programa mais complexas e permitir o desenvolvimento não apenas de EAs simples, mas também de sistemas de trading de maior porte.

Nesse ponto, a própria filosofia também muda. Na primeira etapa, a ideia poderia ser resumida assim: todo trader pode programar sua própria estratégia. Quando o MQL4 começou a ser preparado, essa ideia ganhou uma formulação mais precisa: todo usuário qualificado pode programar uma estratégia de trading por mais complexa que seja, sem sair do terminal.

Ao mesmo tempo, a simplicidade continuava sendo uma prioridade. Estratégias simples deveriam permanecer simples de implementar. O que precisava aumentar drasticamente era o limite de complexidade que a plataforma podia suportar.

MetaTrader 4 e MQL4: o terminal se transforma em uma IDE

O desenvolvimento do MetaTrader 4 começou no verão de 2003. Nas discussões da época, os desenvolvedores foram revelando gradualmente os recursos previstos: testes mais avançados, acesso a séries temporais de diferentes símbolos e períodos, recursos de trading mais avançados, scripts, indicadores personalizados com mais buffers de indicador e chamadas a funções externas de DLLs. Em 5 de fevereiro de 2004, foi publicado, para demonstração, um exemplo de código-fonte escrito em MQL4.

No início de 2004, já estava claro que não se tratava de uma pequena atualização. O sistema estava sendo praticamente reescrito do zero. O desenvolvimento levou mais tempo do que o previsto, mas foi justamente isso que fez com que o MetaTrader 4 se tornasse, ao final, não apenas um conjunto de melhorias, mas uma nova plataforma.

Em 18 de novembro de 2004, a MetaQuotes anunciou o lançamento iminente da versão beta do MetaTrader 4. O anúncio é importante não apenas pelos recursos de trading e análise. Pela primeira vez, reunia de forma tão clara, em um único produto, o modelo que levaria o trading algorítmico a um público amplo: terminal, linguagem de programação MetaQuotes Language 4, ambiente de desenvolvimento MetaEditor 4, EAs, indicadores personalizados e scripts.

A partir desse momento, o MetaTrader deixou de ser apenas um terminal de trading com recursos de automação. O MetaTrader 4 tornou-se uma plataforma na qual o desenvolvedor passou a contar com um ambiente de trabalho próprio.

No site da MetaQuotes, a documentação do MQL4 parecia bastante compacta: tipos de dados, operações e expressões, operadores, funções, variáveis, pré-processador e, posteriormente, a sintaxe da linguagem. Mas a documentação completa estava integrada ao MetaEditor. Essa foi uma decisão fundamental: o desenvolvedor não precisava sair constantemente do editor para consultar a documentação no navegador. Documentação, código e compilação estavam reunidos no mesmo ambiente.

O MQL4 já era uma linguagem de programação procedural completa. Passou a oferecer funções definidas pelo próprio usuário, uma estrutura de programa mais convencional, scripts de execução única, bibliotecas em arquivos EX4 e a possibilidade de chamar funções de DLLs externas.

O MetaEditor deixou de ser apenas um editor de texto. Ele passou a oferecer navegação pela documentação, destaque de sintaxe, compilação, suporte aos diferentes tipos de programas MQL e documentação integrada. Foi nessa etapa que se consolidou definitivamente a fórmula que transformaria o MetaTrader 4 em uma plataforma amplamente adotada para trading algorítmico:

TERMINAL + LINGUAGEM + EDITOR + DOCUMENTAÇÃO + TESTES + COMUNIDADE

Em 1º de julho de 2005, após um longo período de desenvolvimento, o MetaTrader 4 foi lançado como uma plataforma de trading pronta para uso. A partir daí, a história deixou de ser apenas a da linguagem e passou a ser também a de todo um ecossistema: um site próprio para desenvolvedores, Code Base, artigos, campeonatos de robôs de trading e uma enorme comunidade de usuários do MQL4.

É justamente disso que trata a próxima parte.

MQL4.COM: a linguagem ganha sua própria comunidade

Após o lançamento do MetaTrader 4, ficou claro que apenas a plataforma não era suficiente. Se o usuário podia desenvolver EAs, indicadores, scripts e bibliotecas, também precisava de documentação, exemplos, discussões, artigos e um espaço para compartilhar código.

Em 8 de novembro de 2005, foi lançado o MQL4.COM, um site especializado para desenvolvedores MQL4.

Foi um passo importante: o MQL4 deixou de ser apenas uma linguagem integrada ao terminal e passou a ocupar o centro de um ecossistema próprio de desenvolvimento. O site passou a reunir fórum, documentação, Code Base e artigos. Posteriormente, os materiais começaram a ser publicados não apenas em russo e inglês, mas também em chinês.

O Code Base rapidamente começou a receber programas prontos. Em menos de um mês, já havia mais de 50 EAs, cerca de 200 indicadores, 35 scripts e 17 bibliotecas. EAs, indicadores, scripts e bibliotecas transformavam o MQL4 de uma linguagem voltada a um círculo restrito em uma ferramenta prática de uso amplo. O usuário podia não apenas escrever um programa do zero, mas também estudar o código de outros desenvolvedores, modificar soluções prontas, fazer perguntas aos autores e entrar gradualmente no mundo do desenvolvimento.

É revelador que, já em 2006, uma das primeiras publicações apresentasse um EA que utilizava inteligência artificial, mais especificamente, uma rede neural de uma única camada. Naquela época, isso ainda estava longe de ser mainstream e não vinha acompanhado de todo o entusiasmo atual em torno de AI e Machine Learning, mas a própria ideia já circulava na comunidade: uma estratégia de trading podia ser construída não apenas com regras e indicadores, mas também com um modelo treinável.

Esse episódio ajuda a entender por que a evolução posterior do MQL chegou naturalmente a Python, ONNX, AI Assistant e OpenBLAS. O interesse por Machine Learning não surgiu de repente. Foi preciso apenas esperar até que a plataforma, a linguagem e a capacidade computacional alcançassem o nível necessário.

Automated Trading Championship: os EAs entram em cena

O próximo grande passo foi o Automated Trading Championship. O primeiro campeonato de sistemas de trading desenvolvidos em MQL4 ocorreu no final de 2006. Não se tratava apenas de uma competição por prêmios. O campeonato tornou-se uma demonstração pública da principal ideia do MetaTrader 4: os EAs podiam operar de forma autônoma, e seus resultados podiam ser acompanhados em tempo real.

O campeonato de 2006 reuniu 258 desenvolvedores. A premiação total era de 80 mil dólares, e o período de trading durou 12 semanas. Para a época, foi uma demonstração pública de grande impacto: o trading automatizado deixava de ser um tema restrito a um pequeno grupo de programadores e se transformava em um espetáculo acompanhado por traders, corretoras e desenvolvedores.

Mas os prêmios nem eram o aspecto mais importante. O campeonato também serviu como um teste de carga para toda a infraestrutura. Foram preparados os servidores e executadas várias instâncias do terminal, estabelecidas condições idênticas para o funcionamento dos EAs e oferecida ao público a possibilidade de acompanhar os resultados online.

Dessa experiência surgiram muitas ideias que mais tarde seriam incorporadas ao ecossistema MetaTrader: verificações automáticas de EAs, proteção de programas, hospedagem VPS e um terminal cliente mais leve, terminal web, sinais de trading e o futuro Market de aplicativos.

Em 2007, o número de participantes subiu para 600 e, em 2008, chegou a 705. Já não se tratava de uma iniciativa isolada, mas de um indicativo da dimensão que a comunidade já havia alcançado. As pessoas desenvolviam robôs de trading, discutiam algoritmos, comparavam abordagens, estudavam entrevistas de outros participantes e tentavam entender por que alguns sistemas se sustentavam em condições reais de trading, enquanto outros deixavam de funcionar após as primeiras semanas.

Outro aspecto particularmente interessante é que o tema das redes neurais voltou a aparecer nos campeonatos. O vencedor de 2007, Alexander Topchilo, utilizou uma abordagem baseada em redes neurais em seu EA. Inicialmente, ele desenvolveu e testou o sistema em C++ e depois o portou para MQL4. Entrevista com Alexander Topchilo (Better)

Em 2008, Leonid Velichkovsky apresentou um EA que utilizava uma rede neural treinada no NeuroShell. Entrevista com Leonid Velichkovsky (LeoV)

Esse é um detalhe importante para todo o artigo. A história do MQL não é apenas a história de sua sintaxe. É também a história de como os traders tentaram levar para o terminal ideias cada vez mais complexas: de regras simples baseadas em indicadores a estatística, otimização, redes neurais e Machine Learning.

Em 2009, o campeonato não foi realizado. A MetaQuotes estava concluindo o desenvolvimento de sua próxima grande plataforma, o MetaTrader 5, e da nova linguagem MQL5.

MQL5: a nova plataforma começa pela linguagem

As discussões sobre o futuro MQL5 começaram muito antes do lançamento público do MetaTrader 5. Já em 2007, o fórum do MQL4.COM tinha debates intensos sobre o que os usuários esperavam da nova linguagem. Em outubro de 2007, uma busca pelo termo MQL5 retornava mais de 15 páginas com links para mensagens no fórum do MQL4.COM. Os usuários queriam maior velocidade, uma estrutura mais rigorosa, novos recursos de teste, uma forma mais prática de trabalhar com dados e uma abordagem de programação mais moderna.

Internamente, a abordagem adotada era ainda mais radical. A nova linguagem deveria abandonar a representação intermediária característica do MQL4 e passar a gerar código nativo. Isso significava outro nível de desempenho e, ao mesmo tempo, novas exigências para a arquitetura da linguagem.

A primeira menção ao domínio MQL5.COM no arquivo da web data de novembro de 2007. O simples surgimento de um domínio separado já indicava que não se tratava apenas de uma nova sintaxe, mas de um futuro ecossistema.

Em 31 de março de 2008, a nova linguagem MQL5 foi oficialmente anunciada em uma entrevista sobre os recursos que ela teria. O texto dessa entrevista não foi preservado em fontes publicamente acessíveis, mas a própria data é significativa: antes mesmo do lançamento do MetaTrader 5, os desenvolvedores já começavam a preparar a comunidade para um novo modelo de programação.

No verão de 2009, o site MQL5.COM já anunciava claramente que o lançamento aconteceria em breve.

Em 12 de outubro de 2009, começou o teste beta do MetaTrader 5. Um mês depois, em 18 de novembro de 2009, foi aberta a versão beta da MQL5.community, o novo site destinado aos desenvolvedores MQL5.

MQL5.community: não um fórum, mas uma infraestrutura

Desde o início, a MQL5.community não foi concebida como um fórum convencional. Sua estrutura já incorporava os elementos do futuro ecossistema: documentação, fórum, Code Base, artigos, materiais educacionais e novos serviços que seriam adicionados à medida que a plataforma evoluísse.

Os desenvolvedores procuraram preservar o que já funcionava no MQL4.COM: discussões, base de códigos, artigos e o modelo já consolidado de compartilhamento de conhecimento. Mas o novo site precisava ir além. O MQL5 era mais complexo, o MetaTrader 5 era mais abrangente e, consequentemente, a comunidade precisava de uma infraestrutura mais robusta.

Uma iniciativa importante foi a migração das contas do MQL4.COM. Os usuários não precisavam começar do zero: podiam acessar o novo site com suas credenciais antigas. Isso criava uma ponte entre as duas gerações e deixava claro que o MQL5 não descartava a experiência acumulada com o MQL4, mas dava continuidade a ela em um novo patamar.

Assim surgiu um novo ponto de convergência: linguagem, documentação, artigos, código, fórum e futuros serviços passaram a ficar reunidos em um só lugar. A MQL5.community deixou de ser apenas um complemento do terminal e tornou-se parte integrante da plataforma.

MetaTrader 5 e MQL5: a linguagem se torna uma ferramenta de engenharia

Em 1º de junho de 2010, foi lançada a plataforma de trading MetaTrader 5. Diferentemente da geração anterior, ela foi projetada não apenas para Forex, mas também para operar em mercados de bolsa. Isso exigiu mudanças não só no terminal, mas também na linguagem.

O MQL5 representou um grande avanço em relação ao MQL4. Já era uma linguagem de programação orientada a objetos, próxima de C++. Os programas MQL5 eram compilados em código nativo x86 ou x64, o que proporcionava um nível de desempenho muito superior. Ao mesmo tempo, a ideia central do MQL foi preservada: o usuário deveria ser capaz de desenvolver tanto programas simples quanto sistemas de trading complexos.

O modelo de trading também se tornou mais sofisticado. No MetaTrader 5, ordens, negócios e posições passaram a ser entidades distintas. As operações de trading passaram a refletir melhor o funcionamento da infraestrutura de bolsa, mas isso também significava mais detalhes para o desenvolvedor. Por isso, juntamente com a linguagem, evoluiu a biblioteca padrão, que incluía, entre outros recursos, classes de trading destinadas a simplificar cenários de uso comuns.

No lançamento, o MQL5 contava com cerca de 400 funções incorporadas, aproximadamente o mesmo número disponível no MQL4 daquele período. Mais importante do que a quantidade de funções, porém, era o rumo dado ao desenvolvimento da linguagem. O MQL5 foi concebido como uma linguagem capaz de sustentar sistemas de grande porte, com classes, tratamento de eventos, biblioteca padrão, testes, otimização e futuros serviços integrados ao ecossistema da plataforma.

Para os usuários de MQL4, foi criada uma seção específica da documentação dedicada à migração para o MQL5. Isso era necessário: a nova linguagem era mais poderosa, mas também exigia uma forma diferente de pensar. Se o MQL4 levou o trading algorítmico a um público amplo, o MQL5 deveria torná-lo mais orientado à engenharia.

Campeonatos MQL5: a nova plataforma passa por uma avaliação pública

Em 2010, o Automated Trading Championship voltou, agora como uma competição de EAs desenvolvidos em MQL5. Era um passo natural: a nova plataforma precisava de uma demonstração pública, e os desenvolvedores precisavam ver como o MQL5 se comportava não apenas nos exemplos da documentação, mas em uma competição real de três meses entre robôs de trading.

No campeonato de 2010, foram registrados 314 participantes. Em 2011, foram 395 e, em 2012, 451. Essas competições não apenas deram continuidade à tradição dos campeonatos de MQL4, como também demonstraram as vantagens da nova plataforma: maior desempenho, um novo testador, um modelo de trading mais complexo e recursos para o desenvolvimento de EAs de grande porte.

Mais uma vez, os campeonatos cumpriram vários papéis ao mesmo tempo. Para os traders, eram um espetáculo e uma oportunidade de ver o trading automatizado em funcionamento. Para os desenvolvedores, eram uma oportunidade de aprender testando ideias na prática. Para a MetaQuotes, uma fonte de feedback sobre a linguagem, o terminal, o testador, a infraestrutura e o comportamento dos programas em condições reais. E, naturalmente, também contribuíam para popularizar a linguagem MQL5.

Novo MQL4: a influência do MQL5 no sentido inverso

Após o lançamento do MetaTrader 5, poderia parecer que o desenvolvimento do MQL4 passaria gradualmente para segundo plano. Mas aconteceu o contrário. A enorme base de usuários do MetaTrader 4 e o volume de código acumulado ao longo dos anos exigiam não um congelamento da plataforma, mas uma atualização cuidadosa.

Em julho de 2013, foram anunciadas grandes mudanças no MetaTrader 4 e no MQL4. A ideia era incomum: em vez de obrigar todos a migrar o código do MQL4 para o MQL5, levar ao MQL4 o máximo possível dos recursos da nova base tecnológica.

Foi assim que surgiram um compilador unificado para MQL4 e MQL5, um MetaEditor unificado, suporte a novas ferramentas de desenvolvimento, proteção reforçada dos arquivos EX4/EX5 e a possibilidade de usar o Market de aplicativos no MetaTrader 4.

Essa foi uma decisão importante para todo o ecossistema. O MQL4 não ficou restrito ao papel de "linguagem antiga da geração anterior". Ele passou a contar com classes, estruturas, novos tipos de dados, manipuladores de eventos, um modelo de compilação mais rigoroso, suporte a recursos, novos recursos gráficos e um conjunto de ferramentas compartilhado com o MQL5.

Apenas um mês depois, foi lançada a versão beta da IDE do MetaTrader 4, incluindo o novo compilador MQL4 e o editor. No final de 2013, começou o teste público do MetaTrader 4 atualizado, com o novo MQL4 e o Market de aplicativos. Em 3 de fevereiro de 2014, foi lançado o MetaTrader 4 Client Terminal build 600.

Esse release dividiu, na prática, a história do MQL4 em duas eras. O MQL4 antigo era uma linguagem simples, de sintaxe semelhante à de C, conveniente para desenvolver EAs e indicadores. O novo MQL4 passou a se aproximar muito mais do MQL5, com programação orientada a objetos, um MetaEditor unificado, um novo compilador e a possibilidade de criar aplicativos mais complexos.

Ao mesmo tempo, a principal vantagem do MetaTrader 4 foi preservada: sua enorme base existente de usuários, programas e conhecimento não foi descartada. Pelo contrário, o antigo ecossistema recebeu uma nova base tecnológica.

Assim, MQL4 e MQL5 deixaram de parecer dois universos completamente separados. Uma linguagem cresceu a partir da prática disseminada do trading automatizado; a outra nasceu da tentativa de construir uma plataforma de engenharia mais rigorosa e poderosa. Depois do build 600, surgiu entre elas uma camada comum: MetaEditor, compilador, estilo de desenvolvimento, proteção dos programas e serviços da MQL5.community.

A essa altura, a história do MQL já havia ultrapassado há muito tempo os limites de uma "linguagem para EAs". Em torno dele já existiam terminais, editor, documentação, Code Base, artigos, campeonatos, Market, sinais, VPS e uma enorme comunidade. Mas a etapa seguinte da evolução exigia ainda mais: uso e processamento de dados externos, computação distribuída, Machine Learning, matrizes, redes neurais e recursos avançados de álgebra linear.

É disso que trata a próxima parte.

Evolução do MQL5: a linguagem amadurece

Após o lançamento do MetaTrader 5, o MQL5 passou a evoluir simultaneamente em várias direções. Uma delas dizia respeito à própria linguagem, que se aproximava cada vez mais de C++ e se tornava mais adequada a projetos de grande porte. Outra envolvia o ambiente de execução: os programas MQL5 deixaram de funcionar apenas como EAs e indicadores vinculados a gráficos. A terceira estava relacionada à capacidade computacional: o testador de estratégias, a otimização em nuvem, OpenCL, matrizes, Python e ONNX ampliaram gradualmente os limites do que podia ser feito diretamente na plataforma.

Analisadas isoladamente, essas atualizações parecem apenas uma longa sequência de releases. Em conjunto, porém, revelam uma transformação mais importante: o MQL5 estava deixando de ser uma linguagem voltada a robôs de trading para se tornar um ambiente versátil de desenvolvimento, computação, análise de dados e integração com tecnologias externas.

A linguagem se aproxima de C++

Inicialmente, o MQL5 evoluiu como um sucessor mais rigoroso e rápido do MQL4. Mas, já nos primeiros anos, ficou claro que uma sintaxe orientada a objetos, por si só, não era suficiente. Os desenvolvedores precisavam de ferramentas para projetos maiores: reutilização de código, algoritmos genéricos, herança mais segura, namespaces e suporte a tipos de dados mais sofisticados.

Os recursos foram introduzidos em 19 de janeiro de 2011, no MetaTrader 5 Client Terminal build 384. Com isso, tornou-se possível incorporar imagens, dados e outros arquivos auxiliares diretamente ao programa. Mais tarde surgiram as variáveis de recurso: código OpenCL, dados binários ou texto podiam ser incluídos como parte de um programa MQL5, sem transformar o projeto em um conjunto de dependências externas.

Os templates de funções surgiram em 16 de novembro de 2012, no MetaTrader 5 Trading Terminal build 722.

Os templates de classes foram adicionados em 23 de outubro de 2015, no MetaTrader 5 build 1200: histórico de ticks e pagamento de serviços diretamente pela plataforma. Esses foram passos importantes em direção à programação genérica. O mesmo código passou a poder ser utilizado com diferentes tipos de dados, sem a necessidade de reescrever manualmente.

Em 2016, a linguagem recebeu vários recursos já familiares aos desenvolvedores C++:

As classes abstratas surgiram em 1º de abril de 2016, no MetaTrader 5 build 1295.

O cast dinâmico com dynamic_cast foi adicionada em junho de 2016.

As interfaces foram introduzidas em 15 de agosto de 2016.

Os modificadores final e override foram adicionados em 16 de setembro de 2016. Nova versão da plataforma MetaTrader 5 build 1430: aba Exposure atualizada.

Nenhuma dessas mudanças foi meramente cosmética. Elas permitiram construir hierarquias de classes mais rigorosas e seguras, explicitar as intenções do desenvolvedor e detectar parte dos erros ainda durante a compilação.

Os namespaces foram introduzidos em 5 de outubro de 2019, no MetaTrader 5 build 2170: escopos no MQL5, grande atualização do testador de estratégias e da hospedagem integrada. Para projetos de grande porte e bibliotecas de terceiros, isso é especialmente importante: os nomes de classes, funções e variáveis deixam de entrar em conflito entre si, e o código pode ser estruturado com mais facilidade em módulos.

O tipo de dados complex foi adicionado em 21 de maio de 2021, no MetaTrader 5 build 2940: migração das seções dos serviços MQL5 para a área de trabalho e atualização do design. Já não se tratava de um recurso "para EAs", mas de mais um passo em direção à computação científica e de engenharia. Números complexos são necessários em análise espectral, álgebra linear, processamento de sinais e diversos métodos numéricos.

Os tipos matrix e vector foram adicionados em 28 de janeiro de 2022, no MetaTrader 5 build 3180: vetores e matrizes no MQL5 e melhorias de usabilidade. Com isso, o MQL5 avançou ainda mais em direção à computação científica e de engenharia. Com isso, foram criadas as bases para a integração com ONNX e para o uso posterior da biblioteca OpenBLAS.

Os tipos de dados complexf, vectorcf e matrixcf foram adicionados em 27 de setembro de 2024, no MetaTrader 5 build 4570: melhorias na versão web e integração do OpenBLAS ao MQL5.

Assim, o MQL5 foi adquirindo gradualmente características de uma linguagem na qual é possível desenvolver não apenas lógica de trading, mas também grandes bibliotecas, módulos computacionais, wrappers para modelos e código de infraestrutura.

O testador de estratégias como ambiente computacional

Outra linha de evolução está ligada ao testador de estratégias. No MetaTrader, o testador sempre teve um papel importante: sem testes com dados históricos, o trading automatizado se reduz a uma série de suposições. No MQL5, porém, o testador começou a ultrapassar os limites da simples validação de um EA.

Em 2012, foram introduzidos os manipuladores OnTesterInit, OnTesterDeinit e OnTesterPass, além das funções para trabalhar com frames de dados: FrameAdd, FrameFirst, FrameNext e FrameInputs. Isso permitiu que os agentes de teste enviassem ao terminal não apenas um único resultado final, mas também dados arbitrários.

É fácil subestimar a importância dessa atualização. Na prática, ela transformou a otimização em um processo computacional mais flexível. O EA podia não apenas retornar um critério de otimização, mas também transmitir resultados intermediários, estatísticas, métricas próprias ou dados destinados a análises posteriores.

Em combinação com a MQL5 Cloud Network, isso abriu caminho para a computação distribuída. Formalmente, tudo continuava dentro da infraestrutura do testador de estratégias, mas, na prática, o MQL5 passava a contar com um mecanismo para o processamento paralelo de tarefas que não precisavam se limitar à varredura clássica de parâmetros de um robô de trading.

Esse é mais um exemplo da tendência geral de evolução: ferramentas criadas para o trading algorítmico foram se tornando gradualmente úteis também em cenários computacionais mais amplos.

MQL5 vai além do gráfico

O modelo clássico de um programa MQL estava vinculado ao gráfico: o EA opera em um instrumento, o indicador é exibido em uma janela e o script executa uma ação pontual. O MQL5 expandiu gradualmente esse modelo.

O suporte a OpenCL foi adicionado em 3 de fevereiro de 2012, no MetaTrader 5 Trading Terminal build 581. Isso tornou possível utilizar computação paralela nos dispositivos disponíveis e acelerar tarefas que se prestam bem ao processamento em massa de dados.

As funções para trabalhar com instrumentos financeiros personalizados foram adicionadas em 20 de dezembro de 2017, no MetaTrader 5 build 1730: projetos no MetaEditor e instrumentos sintéticos. O desenvolvedor passou a poder criar seus próprios símbolos, alimentar seus históricos com dados, atualizar ticks e construir instrumentos sintéticos. Isso é importante para pesquisas: as ideias podem ser testadas não apenas com os dados padrão da corretora, mas também com séries próprias, instrumentos agregados e conjuntos específicos de cotações.

O suporte nativo a bibliotecas .NET foi adicionado em 26 de outubro de 2018, no MetaTrader 5 build 1930: janelas flutuantes de gráficos e bibliotecas .NET no MQL5. O MetaEditor passou a assumir parte da importação de funções, oferecendo aos desenvolvedores uma forma mais simples de usar código externo sem precisar escrever manualmente wrappers complexos.

Um novo tipo de programa MQL5, os serviços, foi adicionado em 21 de fevereiro de 2019, no MetaTrader 5 build 2005: calendário econômico, programas MQL5 como serviços e API para a linguagem R. Um serviço pode ser executado em segundo plano, iniciar junto com o terminal e desempenhar tarefas de infraestrutura. Isso muda significativamente a própria ideia de um programa MQL: ele já não precisa ser necessariamente um EA, indicador ou script.

As funções de rede para criar conexões TCP também foram adicionadas em 21 de fevereiro de 2019, na atualização MetaTrader 5 build 2005. Os programas MQL5 passaram a poder trocar dados com sistemas externos por meio de sockets, desde que os endereços fossem explicitamente autorizados nas configurações do terminal. Isso ampliou os cenários de integração: fontes de dados próprias, serviços locais, análise externa e troca de informações entre aplicativos.

O suporte a bancos de dados e a DirectX foi adicionado em 6 de dezembro de 2019, no MetaTrader 5 build 2265: funções DirectX para visualização 3D no MQL5 e configuração de instrumentos no testador de estratégias. Essas atualizações podem parecer muito diferentes entre si, mas apontam para a mesma direção: o MQL5 já não se limita a chamadas de trading e buffers de indicadores. A linguagem passa a oferecer recursos para armazenamento de dados, visualização, integração externa e processamento em segundo plano.

Python: uma ponte para análise de dados e Machine Learning

Em 14 de junho de 2019, foi adicionada ao MetaTrader 5 a integração com Python. Integração com Python, suporte ao Market e aos Sinais no Wine (Linux/MacOS) e otimização avançada do testador de estratégias no MetaTrader 5 build 2085. Essa foi uma das pontes mais importantes entre a plataforma de trading e o ecossistema externo de análise de dados.

Naquela altura, Python já havia se consolidado como uma ferramenta padrão para Machine Learning, estatística, processamento de dados e visualização. O suporte a Python tornou possível obter dados do MetaTrader 5 e utilizá-los em cenários externos de pesquisa: construir modelos, testar hipóteses, preparar datasets, analisar resultados e, depois, levar as ideias de volta para a plataforma de trading.

Aqui, mais uma vez, vemos o mesmo padrão de evolução. O MetaTrader não tenta substituir todo o ecossistema externo. Em vez disso, a plataforma oferece ao desenvolvedor uma ponte: os dados e a infraestrutura de trading permanecem no terminal, enquanto os cenários de pesquisa e Machine Learning podem ser executados em ambientes que já dispõem de um amplo ecossistema de bibliotecas.

ONNX: modelos de Machine Learning chegam ao MQL5

O passo seguinte aproximou ainda mais a plataforma do Machine Learning. Em 10 de março de 2023, o MetaTrader 5 passou a oferecer suporte a ONNX, um formato aberto para intercâmbio de modelos de Machine Learning. MetaTrader 5 build 3620: melhorias no terminal web, suporte a ONNX e multiplicação acelerada de matrizes no MQL5.

O conceito do ONNX se encaixa muito bem em uma plataforma como o MetaTrader. O modelo pode ser treinado fora do terminal, por exemplo, em Python com as bibliotecas habituais, depois exportado para ONNX e utilizado diretamente em um programa MQL5. Isso separa duas tarefas distintas: o treinamento do modelo e sua aplicação na lógica de trading.

Para o desenvolvedor, isso representa uma simplificação importante. Não é mais necessário reescrever manualmente uma rede neural em MQL5 nem montar toda a infraestrutura de treinamento dentro do terminal. As ferramentas externas podem ser usadas para preparar o modelo, enquanto, no MQL5, o desenvolvedor pode se concentrar na integração do modelo a um EA, indicador ou programa de pesquisa.

Assim, o antigo interesse da comunidade MQL por redes neurais ganhou uma forma tecnológica mais madura. Se, entre 2006 e 2008, os EAs com redes neurais eram experimentos isolados de entusiastas, com ONNX os desenvolvedores passaram a contar com um caminho nativo para integrar modelos treinados ao MQL5.

AI Assistant: de sugestão pontual a agente completo

A primeira versão do AI Assistant surgiu no MetaEditor em 14 de junho de 2023. Ela já encurtava o caminho entre uma pergunta e o código: o desenvolvedor podia selecionar um trecho, pedir uma explicação, solicitar uma versão de uma função ou uma correção e, depois, incorporar manualmente o resultado ao programa. Era útil, mas seu funcionamento ainda seguia a lógica de um chat convencional: pergunta, resposta em texto, cópia e verificação.

Em 24 de julho de 2026, com o MetaTrader 5 build 6060, a plataforma passou a adotar outro modelo. O terminal e o MetaEditor receberam suporte integrado ao Model Context Protocol (MCP) e à inteligência artificial baseada em agentes. O AI Assistant deixou de se limitar à geração de texto: agora pode planejar uma sequência de ações e chamar as ferramentas disponibilizadas pela plataforma, como ler dados, localizar e modificar arquivos, fazer o build de projetos, analisar o ambiente de trading e retornar resultados estruturados.

Os desenvolvedores resumiram a diferença de forma direta: em vez do modelo cada vez mais limitado de "pergunta, resposta, copiar", passa a existir um agente completo, capaz de executar tarefas complexas. É uma mudança importante de patamar. O assistente deixa de ser apenas um gerador de trechos de código MQL5 e passa a participar diretamente do fluxo de trabalho do desenvolvedor e do trader.

MCP: uma ponte padronizada entre a AI e o MetaTrader

O Model Context Protocol é um padrão aberto que permite a um agente de AI se conectar aos dados e às funções de aplicativos. Para o MetaTrader, isso significa que o terminal e o MetaEditor não funcionam apenas como janelas com um chat aberto, mas como provedores de ferramentas especializadas. O modelo não recebe uma descrição abstrata da plataforma, e sim uma interface programática controlada para executar operações específicas.

No MetaEditor, o agente pode obter informações sobre o workspace, pesquisar arquivos e trechos de texto, ler e modificar código-fonte, criar novos programas, verificar a sintaxe, compilar arquivos individuais e fazer o build de projetos. No terminal, ele tem acesso a dados de mercado, gráficos abertos, parâmetros da conta, posições, ordens e histórico de trading. Servidores MCP adicionais podem acrescentar fontes externas, como cotações públicas, notícias e outros dados para análise.

Essa arquitetura funciona nos dois sentidos. O AI Assistant integrado utiliza as ferramentas MCP do MetaTrader e do MetaEditor, mas os mesmos servidores também podem ser conectados a sistemas externos baseados em agentes e compatíveis com o protocolo, incluindo OpenAI Codex, Claude Code e outras soluções. Assim, o usuário não fica vinculado a uma única aplicação cliente nem a um único modelo: a plataforma fornece as ferramentas, e o agente pode ser escolhido de acordo com a tarefa.

Há suporte ao uso de chaves de API próprias da OpenAI, Anthropic, Gemini, DeepSeek, Ollama e outros provedores compatíveis. Para usuários conectados com uma conta da MQL5.community, o plano gratuito MQL5 Lite é configurado automaticamente, e as configurações do AI Assistant são sincronizadas entre o terminal e o MetaEditor.

AI Assistant no terminal de trading

O assistente integrado ao MetaTrader 5 trabalha com o contexto do próprio terminal. Ele pode explicar a situação atual de um instrumento, examinar o histórico de cotações, consultar os instrumentos disponíveis no "Observação do Mercado", examinar posições abertas e o histórico de negócios, identificar operações de maior risco e preparar um relatório.

Com ferramentas de rede conectadas, o agente pode combinar os dados internos do terminal com informações externas. No anúncio, foi apresentado um cenário em que o assistente obtém as notícias mais recentes sobre um instrumento, analisa os materiais em sequência e os confronta com as cotações. Já não se trata de uma consulta pontual a material de referência, mas de uma análise em várias etapas, na qual o próprio agente reúne as partes necessárias do contexto.

As operações de trading ficam sujeitas a controles específicos. Nas configurações, é possível bloqueá-las completamente, permiti-las ou exigir confirmação manual. As requisições de rede e as operações de linha de comando também são controladas separadamente. As recomendações do assistente, por sua vez, permanecem informativas: a decisão final e a responsabilidade pelo trading continuam sendo do usuário.

AI Assistant no MetaEditor

No MetaEditor, o agente pode criar um novo programa MQL5 a partir de uma descrição em linguagem natural, analisar um projeto existente, localizar erros, propor correções, realizar refatoração, melhorar a legibilidade do código e explicar um algoritmo complexo. A principal diferença em relação à primeira versão é que o resultado não precisa se limitar a uma resposta em texto no chat: o agente pode criar ou modificar um arquivo, iniciar a compilação e verificar o resultado.

Para bases de código extensas, isso é fundamental. O assistente pode localizar definições e usos de identificadores em vários arquivos, ler módulos include relacionados, considerar a estrutura do projeto e executar uma tarefa por meio de uma sequência de operações. O histórico das solicitações fica armazenado na aba "Chats" do Navegador, assim, a interação com o agente passa a fazer parte do próprio projeto, em vez de se limitar a uma sugestão pontual.

O build 6060 também trouxe melhorias ao próprio editor: foram adicionados o recolhimento de blocos de código e o destaque de todas as ocorrências do identificador selecionado. Esses recursos não estão diretamente relacionados à AI, mas dão suporte ao mesmo tipo de atividade: análise e manutenção de projetos de grande porte.

Da escrita de código ao ciclo "desenvolver, verificar e melhorar"

A linha de evolução mais importante está relacionada ao testador de estratégias. Nas respostas publicadas no tópico de teste aberto, foi descrito o ciclo automatizado pretendido:

1. desenvolver uma estratégia com base na tarefa definida pelo trader;
2. executar testes e otimizar os parâmetros;
3. analisar o relatório, alterar o código ou as configurações e repetir os testes;
4. interromper o ciclo em caso de insucesso ou ao atingir um resultado aceitável;
5. apresentar ao usuário a versão final e o relatório.

Esse cenário não deve ser confundido com a promessa de que "a AI encontrará uma estratégia lucrativa". O agente automatiza o ciclo de engenharia e pode testar um número maior de hipóteses, mas não elimina o sobreajuste, erros nos dados de origem, a instabilidade do mercado nem a necessidade de validação independente. O papel do MCP aqui é outro: testador, compilador, arquivos do projeto e resultados da otimização podem ser integrados em uma única sequência controlada de ações.

Durante o beta-teste, esse fluxo foi sendo ampliado gradualmente: algumas ferramentas de alto nível do testador ainda estavam sendo adicionadas e ajustadas. Portanto, o ciclo totalmente autônomo descrito deve ser entendido como um rumo de evolução do sistema baseado em agentes, e não como garantia de que qualquer tarefa complexa já possa ser executada sem participação do usuário.

Segurança: o agente recebe ferramentas, não acesso irrestrito ao computador

Quanto mais ações o agente consegue executar, mais importantes se tornam os limites de acesso. O controle é baseado em permissões explícitas. A pasta de trabalho MQL5 pode ser acessada para operações com código-fonte, enquanto os diretórios do testador e dos logs podem ficar restritos à leitura, e o acesso ao perfil do usuário é habilitado separadamente. Trading, rede e linha de comando também são controlados por configurações independentes.

Operações por linha de comando, como PowerShell, Python e outros processos externos, são especialmente poderosas e potencialmente perigosas. Por isso, elas são devidamente sinalizadas na interface e permite desativá-las separadamente. Esse modo transforma o assistente em um agente de propósito geral, mas também amplia os riscos potenciais.

Nas discussões com traders no fórum, também foi enfatizada a necessidade de backups e de um sistema de controle de versão. Para o desenvolvimento baseado em agentes, Git não é apenas uma conveniência adicional, mas um mecanismo básico de segurança: as alterações precisam ser visíveis, comparáveis e reversíveis. É nesse ponto que a nova arquitetura de AI se integra naturalmente ao MQL5 Algo Forge.

Instruções do projeto e skills

Não basta que o agente consiga acessar os arquivos: ele também precisa compreender as regras específicas daquela base de código. Para isso, para isso, são usados arquivos de instruções para o MetaEditor e o MetaTrader no diretório MQL5\Profiles\Agents. O usuário pode substituir as instruções padrão por instruções próprias, definindo estilo de código, convenções de nomenclatura, ordem das verificações e outros requisitos permanentes.

Como esses arquivos ficam dentro da estrutura de diretórios do MQL5, eles podem ser armazenados junto com os projetos no Algo Forge. Assim, o repositório passa a conter não apenas o código-fonte e o README, mas também instruções para a AI: como fazer o build do projeto, quais arquivos não devem ser alterados, quais testes precisam ser executados e em que formato o resultado deve ser apresentado.

Nas respostas publicadas no fórum, os desenvolvedores também apresentaram instruções locais específicas de cada projeto e skills, ou seja, procedimentos especializados reutilizáveis pelo agente. Isso mostra o rumo que o sistema está tomando: de um chat genérico para um participante digital configurável do projeto, que conhece tanto as ferramentas da plataforma quanto as regras da equipe responsável pelo código.

Matrizes e vetores: o MQL5 se prepara para álgebra linear avançada

Para Machine Learning, estatística e métodos numéricos, classes, templates e integrações externas não são suficientes. Também é necessário trabalhar de forma prática com vetores, matrizes e operações fundamentais de álgebra linear.

Em 28 de janeiro de 2022, os tipos matrix e vector foram adicionados ao MQL5. Essa foi uma mudança importante não apenas do ponto de vista da sintaxe. Matrizes e vetores foram concebidos não como arrays convencionais, mas como objetos com propriedades e métodos próprios.

O vetor passou a ter um tamanho, a matriz passou a ter número de linhas e colunas, e em torno desses tipos começou a se formar uma seção específica de métodos. O desenvolvedor ganhou uma forma mais natural de escrever código computacional: criar matrizes, transpor, multiplicar, calcular decomposições, resolver sistemas de equações e trabalhar com normas, posto e outras propriedades numéricas.

Nessa etapa, o MQL5 já se diferenciava claramente da linguagem que um dia havia começado com uma lógica simples de EA executada a cada tick. A linguagem passou a oferecer estruturas adequadas a modelos matemáticos, enquanto a plataforma já contava com integração com Python, ONNX, OpenCL e otimização em nuvem.

Mas uma base numérica realmente sólida exige mais do que um tipo matrix conveniente. É necessária uma biblioteca de álgebra linear comprovada, que possa servir de fundamento para a implementação de métodos mais complexos. Foi justamente por isso que a integração com OpenBLAS se tornou o próximo grande passo.

É disso que trata a próxima parte.

Por que OpenBLAS

Quando matrizes, vetores, números complexos, ONNX e cenários de Machine Learning passaram a fazer parte do MQL5, surgiu inevitavelmente a questão seguinte: qual base matemática deveria sustentar a evolução da plataforma?

É possível implementar métodos individualmente. Também é possível adicionar algumas operações rápidas com matrizes ou limitar o conjunto a multiplicação, decomposições e resolução de sistemas de equações. Mas esse caminho rapidamente leva a uma coleção fragmentada de funções, difícil de evoluir, testar e manter.

Para uma plataforma como o MetaTrader 5, não bastava "mais uma biblioteca de alto desempenho". Era necessária uma base padrão de álgebra linear: ampla, consolidada, portável e adequada à expansão gradual dos métodos do MQL5.

Antes da escolha do OpenBLAS, outras alternativas também foram avaliadas: ALGLIB, LIBXSMM, Eigen e oneMKL. Cada biblioteca tem seus pontos fortes, mas as necessidades do MQL5 iam muito além de acelerar uma única operação ou cobrir uma classe específica de algoritmos.

A ALGLIB é interessante como um toolkit numérico de propósito geral, com recursos para otimização, aproximação, álgebra linear, estatística e outros algoritmos. Mas, para atuar como camada básica dentro de uma plataforma, não importam apenas as funções disponíveis. Também entram em consideração o modelo de licenciamento, as diferentes edições da biblioteca, as condições de distribuição, a previsibilidade da integração e a manutenção de longo prazo.

A LIBXSMM se destaca em operações especializadas com matrizes densas e esparsas, especialmente em tarefas envolvendo matrizes pequenas e deep learning primitives. É uma ferramenta útil, mas de escopo mais específico. Funciona muito bem quando o objetivo é extrair o máximo desempenho de determinada classe de operações, porém não substitui uma base ampla orientada a LAPACK para um grande conjunto de métodos de álgebra linear.

Eigen é uma excelente template library em C++ para matrizes, vetores, solucionadores numéricos e algoritmos relacionados. Mas Eigen representa, antes de tudo, uma abordagem própria do C++: biblioteca baseada em headers, templates, expression templates e forte integração com código C++. Para a integração interna no MQL5, o foco precisava ser outro: uma camada computacional estável que pudesse servir de base para a implementação dos métodos de matrix, matrixf, matrixc e matrixcf.

A oneMKL também foi considerada. Trata-se de uma biblioteca matemática poderosa, com uma longa trajetória, alto nível de otimização e um amplo conjunto de recursos. Em uma plataforma como essa, porém, desempenho não é o único fator relevante. Também importam portabilidade, grau de dependência de fornecedor, condições de distribuição, controle sobre a integração e previsibilidade do comportamento nas diferentes configurações dos usuários.

O OpenBLAS mostrou-se o compromisso mais adequado. Trata-se de uma biblioteca BLAS de código aberto e otimizada, que oferece alto desempenho nas operações fundamentais de álgebra linear e serve como base para métodos mais complexos. Para o MQL5, o argumento decisivo foi justamente a cobertura das tarefas de LAPACK: não apenas uma operação rápida, mas uma base ampla para SVD, autovalores, resolução de sistemas de equações lineares, least squares, fatorizações e refinamento de soluções.

Em outras palavras, a escolha do OpenBLAS foi uma decisão de engenharia, não meramente decorativa. Era necessária uma biblioteca que permitisse desenvolver os métodos matemáticos do MQL5 de forma sistemática, partindo das operações matriciais básicas até chegar a algoritmos numéricos cada vez mais complexos.

OpenBLAS no MQL5: das matrizes a uma base numérica completa

Em 27 de setembro de 2024, o MetaTrader 5 build 4570 recebeu integração nativa com OpenBLAS. Ao mesmo tempo, foram adicionados ao MQL5 novos tipos de dados necessários para oferecer suporte a cálculos complexos com dados float:

• complexf, um número complexo com dados do tipo float;
• vectorcf, um vetor contendo elementos do tipo complexf;
• matrixcf, uma matriz contendo elementos do tipo complexf.

À primeira vista, isso pode parecer apenas um detalhe técnico. Na prática, trata-se de uma camada importante para a evolução dos recursos matemáticos do MQL5. A linguagem já contava com matrix, vector, números complexos e métodos para matrizes. Mas o OpenBLAS exigiu um conjunto mais completo de tipos: dados reais e complexos, double e float, além de diferentes variantes de matrizes e vetores.

Assim, o MQL5 não recebe apenas um "método SVD" ou um "método Eigen". Ele passa a contar com uma base sobre a qual podem ser construídas famílias de algoritmos para diferentes tipos de dados e diferentes tarefas numéricas.

Os primeiros métodos baseados em OpenBLAS no MQL5 estavam relacionados à decomposição em valores singulares e ao cálculo de autovalores. É um ponto de partida natural. SVD e problemas de autovalores fundamentam um grande número de algoritmos práticos: da análise de estabilidade e redução de dimensionalidade a Machine Learning, estatística, processamento de sinais e construção de modelos.

Para SVD, foram adicionadas diferentes variantes algorítmicas: divide and conquer, QR, QR with pivoting, bisection, Jacobi high level, Jacobi low level e métodos para matrizes bidiagonais. Isso é importante porque, em métodos numéricos, raramente existe um único algoritmo "melhor" para todos os casos. Uma variante mais rápida pode apresentar menor precisão com dados problemáticos, enquanto outra, mais estável, pode exigir maior custo computacional. A plataforma precisa dar ao desenvolvedor essa possibilidade de escolha.

Os métodos de autovalores resolvem outro conjunto de problemas. Eles são necessários para a análise de matrizes quadradas, matrizes simétricas e hermitianas, estabilidade de sistemas, características espectrais e muitos procedimentos computacionais utilizados em estatística, otimização e modelagem.

Posteriormente, a seção dedicada ao OpenBLAS na documentação do MQL5 começou a se expandir. Esse é um ponto importante: a integração com OpenBLAS não é um release isolado, mas parte de uma linha de evolução. Os métodos de matrizes e vetores passam gradualmente a oferecer cada vez mais recursos aplicáveis a diferentes tipos de matrizes: matrix, matrixf, matrixc e matrixcf.

A próxima camada natural envolve métodos de refinamento de soluções, estimativa de erros, melhoria da estabilidade numérica e fatorizações adicionais. É assim que se desenvolve uma base matemática robusta: não em um salto do "nada" para o "tudo", mas com a cobertura gradual de um número cada vez maior de tarefas padrão de LAPACK.

Por que isso é importante para o desenvolvedor MQL

Para um trader comum, OpenBLAS pode parecer algo distante, uma biblioteca voltada a matemáticos, engenheiros e computação científica. Para o ecossistema MQL, porém, sua introdução tem uma consequência bastante prática.

O desenvolvedor passa a poder construir modelos mais complexos diretamente em MQL5. Não apenas chamar um indicador, comparar dois valores e enviar uma ordem, mas trabalhar com os dados como arrays, vetores e matrizes. Calcular decomposições. Resolver sistemas de equações. Avaliar estabilidade. Utilizar métodos que antes precisavam ser delegados a Python, C++ ou bibliotecas externas.

Isso não substitui Python, ONNX nem outras ferramentas externas. Pelo contrário, essas tecnologias passam a se complementar ainda melhor. Python é conveniente para pesquisa, treinamento de modelos e preparação de dados. ONNX é adequado para levar um modelo treinado para dentro do terminal. OpenBLAS oferece ao MQL5 uma base numérica sólida para os casos em que os cálculos precisam ser executados diretamente na plataforma.

Como resultado, o MetaTrader 5 está se transformando gradualmente em um ambiente no qual é possível não apenas operar e testar EAs, mas também construir uma cadeia computacional completa:

• obter dados de mercado;
• preparar features e matrizes;
• usar um modelo ONNX;
• realizar cálculos numéricos com matrix/vector;
• testar a ideia no testador de estratégias;
• paralelizar a otimização;
• incorporar o resultado a um EA, indicador ou serviço.

É justamente por isso que OpenBLAS não deve ser analisado isoladamente, mas em conjunto com as etapas anteriores: MQL5, MetaEditor, Python, ONNX, matrizes, vetores e AI Assistant.

AI Assistant baseado em agentes, MCP e OpenBLAS: três camadas de um mesmo ambiente de engenharia

À primeira vista, o AI Assistant baseado em agentes, o MCP e o OpenBLAS pertencem a áreas diferentes da plataforma. O AI Assistant interpreta a intenção do usuário, o MCP conecta o modelo às ferramentas, e o OpenBLAS executa os algoritmos numéricos. Juntos, porém, eles formam um fluxo computacional integrado.

O AI Assistant fica responsável por definir e decompor a tarefa: compreender a solicitação, elaborar um plano, escolher as ações e interpretar os resultados. O MCP oferece ao agente acesso controlado ao terminal, MetaEditor, projetos, mercado, histórico de trading e dados externos. OpenBLAS, matrix/vector, ONNX e outras tecnologias fornecem ao programa MQL5 a capacidade computacional necessária para implementar o próprio modelo.

Antes, o desenvolvedor precisava alternar manualmente entre editor, documentação, fórum, testador, notebook Python e bibliotecas externas. Agora, parte dessas etapas pode ser descrita como uma única tarefa: analisar o projeto, alterar o código, fazer o build do programa, preparar os dados, executar a análise e gerar um relatório. O agente não substitui o compilador, o testador nem a biblioteca matemática. Ele conecta todos esses componentes.

É justamente por isso que o MCP é tão importante quanto o próprio modelo de linguagem. Sem ferramentas especializadas, mesmo um modelo avançado continua sendo apenas um interlocutor. Com o MCP, ele passa a poder agir dentro da plataforma, mas sempre dentro das permissões definidas pelo usuário.

Algo Forge: o código se transforma em projeto

Um ambiente de engenharia moderno ainda precisa de outra camada indispensável ao desenvolvimento profissional: controle de versão, histórico de alterações, colaboração e publicação do projeto como um repositório ativo. No ecossistema MQL, o MQL5 Algo Forge passou gradualmente a cumprir esse papel.

O antecessor do Algo Forge foi o MQL5 Storage, um repositório online de código-fonte MQL4/MQL5 integrado ao MetaEditor. Ele já resolvia uma necessidade importante: permitia armazenar o código em um repositório protegido, consultar o histórico de alterações, retornar a versões anteriores e trabalhar com projetos em equipe diretamente no editor.

O armazenamento anterior, porém, era baseado em Subversion e já estava tecnologicamente defasado. Sua lógica funcionava bem para armazenar e sincronizar código-fonte, mas o desenvolvimento moderno exige mais: histórico local, operações rápidas, branches para experimentos, merge de alterações, trabalho offline e colaboração transparente entre vários desenvolvedores no mesmo projeto.

Em 6 de junho de 2025, no MetaTrader 5 build 5100, o repositório de código-fonte foi completamente reformulado: o MQL5 Storage migrou de Subversion para Git e, juntamente com essa mudança, foi lançado um novo portal para gerenciamento online de projetos, o MQL5 Algo Forge.

Foi uma virada importante. Se o Code Base respondia à pergunta "onde encontrar um exemplo pronto?", o Algo Forge responde a outra: "como trabalhar com um projeto que continua evoluindo?". Um EA ou uma biblioteca complexa já não se resume a um único arquivo MQ5. Há arquivos include, configurações de teste, conjuntos de parâmetros, modelos, documentação, README, scripts auxiliares, histórico de experimentos e vários branches de desenvolvimento.

O Git muda a forma de trabalhar com esse tipo de código. O desenvolvedor pode criar um branch separado para uma nova ideia, testá-la no testador, comparar as alterações, retornar a um estado anterior, incorporar um experimento bem-sucedido à versão principal e enviar o resultado para o repositório na nuvem. O histórico do projeto deixa de existir apenas na memória do autor ou em pastas com nomes como "final_new_2". Ele passa a fazer parte do próprio ambiente de desenvolvimento.

O Algo Forge acrescenta a isso uma camada social. Os desenvolvedores podem explorar projetos públicos, seguir autores, criar equipes, fazer forks, clonar repositórios, consultar arquivos, commits e branches, preparar documentação e compartilhar seus projetos na internet. Para o ecossistema MQL, isso representa a transição do compartilhamento de arquivos de código-fonte para uma cultura consolidada de desenvolvimento colaborativo.

Isso é especialmente importante para artigos e materiais educacionais. O código de um artigo não precisa ficar restrito a um arquivo compactado ou a um conjunto de arquivos anexados. Ele pode ser estruturado como um projeto no Algo Forge, com uma estrutura clara, um README.md e um histórico de alterações, oferecendo ao leitor não apenas o texto, mas também um ponto de partida funcional. O artigo explica a ideia, e o repositório mostra como ela funciona na prática.

Assim, o MetaEditor amplia novamente seu papel. No início, era o lugar onde o código era escrito e compilado. Depois, passou a incluir documentação, projetos, depuração, profiling, AI Assistant e integrações. Agora, soma-se a isso um fluxo completo baseado em Git: histórico, branches, commits, sincronização e desenvolvimento colaborativo.

Dentro dessa lógica, o Algo Forge não é um serviço separado "à margem" da plataforma, mas a continuação da mesma linha de evolução. O programa MQL percorreu o caminho de um EA simples executado em um único gráfico até se tornar um projeto de engenharia que pode ter controle de versão, ser discutido, desenvolvido em equipe, publicado e mantido durante anos.

De Expert Advisors a um ambiente de engenharia

Quando observamos toda essa história em conjunto, a trajetória do MQL revela uma continuidade impressionante.

Primeiro vieram os Expert Advisors, antes mesmo de existir uma linguagem completa. Depois surgiu o primeiro MQL: uma pequena página de documentação, algumas variáveis e a possibilidade de executar uma estratégia de trading diretamente no terminal. Em seguida, o MQL II acrescentou laços, arrays, tipos de dados e funções matemáticas. Os indicadores personalizados levaram a linguagem para além dos EAs.

O MetaTrader 4 reuniu tudo isso em um modelo voltado a um público amplo: terminal, MQL4, MetaEditor, documentação, EAs, indicadores, scripts, bibliotecas e testes. O MQL4.COM acrescentou a comunidade, o Code Base e os artigos. Os campeonatos mostraram que o trading automatizado podia ser público, competitivo e amplamente difundido.

O MetaTrader 5 e o MQL5 elevaram o limite de complexidade. Programação orientada a objetos, código nativo, biblioteca padrão, novo modelo de trading, testador ampliado, otimização em nuvem e MQL5.community transformaram a linguagem em uma ferramenta de engenharia mais rigorosa.

Depois, a influência do MQL5 no sentido inverso modernizou o MQL4: compilador unificado, MetaEditor unificado, nova linguagem, proteção dos programas e Market de aplicativos. O produto já amplamente difundido recebeu uma nova base tecnológica.

Em seguida, o MQL5 começou a ultrapassar os limites do EA clássico: OpenCL, símbolos personalizados, .NET, serviços, funções de rede, SQLite, DirectX, Python, ONNX, matrizes e vetores. Tudo isso ampliou gradualmente a própria concepção do que um programa MQL poderia ser.

O AI Assistant baseado em agentes, o MCP e o OpenBLAS não são meros adornos acrescentados por acaso a essa história. Eles representam sua continuação lógica, pois desenvolvem o mesmo princípio que já estava presente em 2001: dar ao usuário cada vez mais autonomia dentro da plataforma.

Naquela época, autonomia significava poder escrever um EA e executar uma operação de trading sem intervenção humana. Hoje, significa muito mais: atribuir uma tarefa ao agente em linguagem natural, conceder a ele acesso controlado às ferramentas por meio do MCP, escrever e fazer o build do código, usar um modelo externo de Machine Learning, executar métodos numéricos de álgebra linear, testar o sistema com dados históricos e colocá-lo em operação na infraestrutura do MetaTrader.

Não é uma história de versões, mas de uma ideia

É fácil transformar a história do MQL em uma longa lista de datas, números de build e nomes de funções. Mas, nesse caso, perde-se o essencial.

Não é a história de como uma sintaxe substituiu outra. Tampouco é a história de como o terminal foi ganhando cada vez mais opções de menu.

É a história de como a plataforma de trading foi incorporando, passo a passo, cada vez mais tarefas do desenvolvedor. Primeiro, a execução do EA. Depois, a linguagem. Em seguida, o editor. Depois vieram documentação, testes, Code Base, artigos, campeonatos, Market, otimização em nuvem, integrações externas, Machine Learning, AI Assistant, álgebra linear numérica e gerenciamento de projetos por meio do Algo Forge.

Nesse sentido, o MetaEditor moderno não é apenas o sucessor daquela antiga janela usada para editar um EA. Ele é o núcleo de integração de todo o ecossistema MQL: linguagem, documentação, projetos, depuração, profiling, modelos, métodos matemáticos, assistência baseada em agentes, ferramentas MCP e infraestrutura Git para desenvolvimento colaborativo.

É justamente por isso que a trajetória dos primeiros Expert Advisors até o AI Assistant baseado em agentes, MCP e OpenBLAS não parece uma sequência de acontecimentos desconectados, mas uma única linha contínua de evolução. Desde o início, a MetaQuotes não estava construindo apenas um terminal para acompanhar o mercado, mas um ambiente no qual uma ideia de trading se transforma em programa, e o programa, em um fluxo de engenharia controlado.

É essa ideia que continua impulsionando o MQL.