Getting Started With MongoDB and C

Introdução ao MongoDB e C

Neste artigo, instalaremos o driverdoMongoDB C no macOS e usaremos esse driver para escrever alguns exemplos de aplicativos de console que podem interagir com seus dados do MongoDB executando operações CRUD básicas. Usaremos o Visual Studio Code para digitar o código e a linha de comando para compilar e executar nossos programas. Se você quiser experimentar agora, todo o código-fonte está no repositório GitHub.

Sumário

Pré-requisitos
Instalação: VS Code, extensões C, Xcode
Instalando o driver C
Olá, MongoDB!
Configurando o cliente e enviando ping para o MongoDB Atlas
Compilando e executando nosso código
Conectando ao banco de dados e listando todas as coleções
Criando um objeto JSON em C
CRUD no MongoDB usando o driver C
Query de dados
Inserindo um novo documento
Excluindo um documento
Atualizando um documento
Encerrando

Pré-requisitos

Uma conta do MongoDB Atlas com um cluster criado.
O conjunto de dados de amostra carregado no Atlas cluster (ou você pode modificar o código de amostra para utilizar seu próprio banco de dados e collection).
O endereço IP da sua máquina está na lista de permissões. Nota: Você pode adicionar 0.0.0.0/0 como o endereço IP, que deve permitir o acesso de qualquer máquina. Essa configuração não é recomendada para uso em produção.

VS Code, extensões C, Xcode

Usaremos o Visual Studio Code, disponível no macOS, Windows e Linux, porque ele tem suporte oficial para código C. Basta baixar e instalar a versão apropriada.
Precisamos das extensões C, que serão sugeridas quando você abrir um arquivo C pela primeira vez. Você também pode abrir extensões e procurar por "C/C++" e instalá-las. Isso instalará várias extensões: C/C++, C/C++ Themes e CMake.
A última etapa é garantir que tenhamos um compilador C. Para isso,instale o Xcode da Mac App Store ou execute em um terminal:

Trecho de código

Embora possamos usar oCMake para criar nossos aplicativos C (e você tenha instruções detalhadas sobre como fazer isso), usaremos o VS Code para digitar nosso código e o terminal para criar e executar nossos programas.

Instalando o driver C

No macOS, se tivermos o gerenciador de pacotes homebrew instalado (o que você deve fazer), basta abrir um terminal e digitar:

Trecho de código

Você também pode baixar o código-fonte e construir o driver, mas usar brew é muito mais conveniente.

Configurando extensões do VS Code

Para fazer o preenchimento automático funcionar no VS Code, precisamos alterar a configuração da extensão para garantir que ela "veja" essas novas bibliotecas instaladas. Queremos alterar nosso INCLUDE_PATH para permitir que o IntelliSense verifique nosso código enquanto o digita e possa criar nosso aplicativo a partir do VS Code.

Para fazer isso, no VS Code, abra a pasta oculta.vscodee clique em c_cpp_properties.json e adicione estas linhas:

Trecho de código

Agora, abra tarefas.json e adicione estas linhas à matriz args:

Trecho de código

Com eles, estamos informando ao VS Code onde encontrar as bibliotecas C do MongoDB para que ele possa compilar e verificar nosso código à medida que digitamos.

Olá, MongoDB!

O código-fonte está disponível no GitHub.

Configurando o cliente e enviando ping para o MongoDB Atlas

Vamos começar com um programa simples que se conecta ao MongoDB Atlas cluster e faz pings no servidor. Para isso, precisamos obter a cadeia de conexão (URI) para o MongoDB Atlas cluster e adicioná-la em nosso código. A melhor maneira é criar uma nova variável de ambiente com a chave "MONGODB_URI " e valorizar a connection string (URI). É uma boa prática manter a string de conexão dissociada do código, mas, neste exemplo, para simplificar, teremos nossa string de conexão codificada.

Incluímos o driver MongoDB e enviamos um comando "echo" de nossa funçãomain. Este exemplo mostra como inicializar o cliente MongoDB C, como criar um comando, manipular JSON (neste caso, BCON, Notação de objetoBSON C), enviar um comando, processar a resposta e o erro e liberar qualquer memória usada.

Trecho de código

// hello_mongo.c
#include <mongoc/mongoc.h>

int main(int argc, char const *argv[]) {
 // your MongoDB URI connection string
 const char *uri_string = "mongodb+srv://<connection string>";
 // MongoDB URI created from above string
 mongoc_uri_t *uri;
 // MongoDB Client, used to connect to the DB
 mongoc_client_t *client;
 // Command to be sent, and reply
 bson_t *command, reply;
 // Error management
 bson_error_t error;
 // Misc
 char *str;
 bool retval;

/*
  * Required to initialize libmongoc's internals
  */
 mongoc_init();

/*
  * Optionally get MongoDB URI from command line
  */
 if (argc > 1) {
   uri_string = argv[1];
 }

/*
  * Safely create a MongoDB URI object from the given string
  */
 uri = mongoc_uri_new_with_error(uri_string, &error);
 if (!uri) {
   fprintf(stderr,
           "failed to parse URI: %s\n"
           "error message:       %s\n",
           uri_string, error.message);
   return EXIT_FAILURE;
 }

/*
  * Create a new client instance, here we use the uri we just built
  */
 client = mongoc_client_new_from_uri(uri);
 if (!client) {
   return EXIT_FAILURE;
 }

/*
  * Register the application name so we can track it in the profile logs
  * on the server. This can also be done from the URI (see other examples).
  */
 mongoc_client_set_appname(client, "connect-example");

/*
  * Do work. This example pings the database and prints the result as JSON
  * BCON == BSON C Object Notation
  */
 command = BCON_NEW("ping", BCON_INT32(1));

// we run above command on our DB, using the client. We get reply and error
 // (if any)
 retval = mongoc_client_command_simple(client, "admin", command, NULL, &reply,
                                       &error);

// mongoc_client_command_simple returns false and sets error if there are
 // invalid arguments or a server or network error.
 if (!retval) {
   fprintf(stderr, "%s\n", error.message);
   return EXIT_FAILURE;
 }

// if we're here, there's a JSON response
 str = bson_as_json(&reply, NULL);
 printf("%s\n", str);

/*
  * Clean up memory
  */
 bson_destroy(&reply);
 bson_destroy(command);
 bson_free(str);

/*
  * Release our handles and clean up libmongoc
  */

mongoc_uri_destroy(uri);
 mongoc_client_destroy(client);
 mongoc_cleanup();

return EXIT_SUCCESS;
}

Compilando e executando nosso código

Embora possamos usar métodos muito mais sofisticados para compilar e executar nosso código, como este é apenas um arquivo de código-fonte C e estamos usando apenas algumas dependências, vou compilar a partir da linha de comando usando o bom e velho gcc:

Trecho de código

Para executar o código, basta chamar o binário construído:

Trecho de código

No repositório que acompanha esta postagem, você encontrará um shell script que cria e executa todos os exemplosde uma só vez.

Conectando ao banco de dados e listando todas as coleções

Agora que temos o esqueleto de um aplicativo C, podemos começar a usar nosso banco de dados. Nesse caso, nos conectaremos ao banco de dados sample_mflixe listaremos todas as coleções lá.

Após conectar ao banco de dados, listamos todas as conexões com um simples loop forapós obter todos os nomes de collection commongoc_database_get_collection_names.

Trecho de código

A amostra completa segue.

Trecho de código

// list_collections.c
#include <mongoc/mongoc.h>

int main(int argc, char const *argv[]) {
  // your MongoDB URI connection string
  const char *uri_string = "mongodb+srv://<connection string>";

// MongoDB URI created from above string
  mongoc_uri_t *uri;
  // MongoDB Client, used to connect to the DB
  mongoc_client_t *client;

// Error management
  bson_error_t error;

mongoc_database_t *database;
  mongoc_collection_t *collection;
  char **collection_names;
  unsigned i;

/*
   * Required to initialize libmongoc's internals
   */
  mongoc_init();

/*
   * Safely create a MongoDB URI object from the given string
   */
  uri = mongoc_uri_new_with_error(uri_string, &error);
  if (!uri) {
    fprintf(stderr,
            "failed to parse URI: %s\n"
            "error message:       %s\n",
            uri_string, error.message);
    return EXIT_FAILURE;
  }

/*
   * Create a new client instance, here we use the uri we just built
   */
  client = mongoc_client_new_from_uri(uri);
  if (!client) {
    return EXIT_FAILURE;
  }

/*
   * Register the application name so we can track it in the profile logs
   * on the server. This can also be done from the URI (see other examples).
   */
  mongoc_client_set_appname(client, "connect-example");

/*
   * Get a handle on the database "db_name" and collection "coll_name"
   */
  database = mongoc_client_get_database(client, "sample_mflix");

// getting all collection names, here we're not passing in any options
  if ((collection_names = mongoc_database_get_collection_names_with_opts(
           database, NULL, &error))) {
  
    for (i = 0; collection_names[i]; i++) {
      printf("%s\n", collection_names[i]);
    }

} else {
    fprintf(stderr, "Error: %s\n", error.message);
    return EXIT_FAILURE;
  }

/*
   * Release our handles and clean up libmongoc
   */

mongoc_uri_destroy(uri);
  mongoc_client_destroy(client);
  mongoc_cleanup();

return EXIT_SUCCESS;
}

Se compilarmos e executarmos, obteremos esta saída:

Trecho de código

Criando um objeto JSON em C

Por ser um banco de dados baseado em documentos, a criação de documentos JSON é crucial para qualquer aplicativo que interaja com o MongoDB. Como este é um código C, não usamos JSON. Em vez disso, usamos BCON (notação de objetoBSON C, como mencionado acima). Para criar um novo documento, chamamos BCON_NEWe, para convertê-lo em uma string C, chamamos bson_as_canonical_extended_json.

Trecho de código

// bcon.c
// https://mongoc.org/libmongoc/current/tutorial.html#using-bcon
#include <mongoc/mongoc.h>

// Creating the JSON doc:
/*
{
   born : ISODate("1906-12-09"),
   died : ISODate("1992-01-01"),
   name : {
      first : "Grace",
      last : "Hopper"
   },
   languages : [ "MATH-MATIC", "FLOW-MATIC", "COBOL" ],
   degrees: [ { degree: "BA", school: "Vassar" },
              { degree: "PhD", school: "Yale" } ]
}
*/

int main(int argc, char *argv[]) {
  struct tm born = {0};
  struct tm died = {0};
  bson_t *document;
  char *str;

born.tm_year = 6;
  born.tm_mon = 11;
  born.tm_mday = 9;

died.tm_year = 92;
  died.tm_mon = 0;
  died.tm_mday = 1;

//   document = BCON_NEW("born", BCON_DATE_TIME(mktime(&born) * 1000),
  //                       "died", BCON_DATE_TIME(mktime(&died) * 1000),
  //                       "name", "{",
  //                         "first", BCON_UTF8("Grace"),
  //                         "last", BCON_UTF8("Hopper"),
  //                       "}",
  //                       "languages", "[",
  //                         BCON_UTF8("MATH-MATIC"),
  //                         BCON_UTF8("FLOW-MATIC"),
  //                         BCON_UTF8("COBOL"),
  //                       "]",
  //                       "degrees", "[",
  //                         "{", "degree", BCON_UTF8("BA"), "school",
  //                         BCON_UTF8("Vassar"), "}",
  //                         "{", "degree", BCON_UTF8("PhD"),"school",
  //                         BCON_UTF8("Yale"), "}",
  //                       "]");

document = BCON_NEW("born", BCON_DATE_TIME(mktime(&born) * 1000), "died",
                      BCON_DATE_TIME(mktime(&died) * 1000), "name", "{",
                      "first", BCON_UTF8("Grace"), "last", BCON_UTF8("Hopper"),
                      "}", "languages", "[", BCON_UTF8("MATH-MATIC"),
                      BCON_UTF8("FLOW-MATIC"), BCON_UTF8("COBOL"), "]",
                      "degrees", "[", "{", "degree", BCON_UTF8("BA"), "school",
                      BCON_UTF8("Vassar"), "}", "{", "degree", BCON_UTF8("PhD"),
                      "school", BCON_UTF8("Yale"), "}", "]");

/*
   * Print the document as a JSON string.
   */
  str = bson_as_canonical_extended_json(document, NULL);
  printf("%s\n", str);
  bson_free(str);

/*
   * Clean up allocated bson documents.
   */
  bson_destroy(document);
  return 0;
}

CRUD no MongoDB usando o driver C

Agora que abordamos os fundamentos da conexão com o MongoDB, vamos dar uma olhada em como manipular dados.

Query de dados

Provavelmente, a função mais usada de qualquer banco de dados é a recuperação rápida de dados. Na maioria dos casos de uso, gastamos muito mais tempo acessando dados do que inserindo ou atualizando esses mesmos dados. Nesse caso, depois de criar nossa conexão com o cliente MongoDB, chamamos mongoc_collection_find_with_opts, que encontrará dados com base em uma consulta que podemos passar. Quando tivermos os resultados, podemos iterar pelo cursor retornado e fazer algo com esses dados:

Trecho de código

A amostra completa segue.

Trecho de código

// find.c
#include "URI.h"
#include <mongoc/mongoc.h>

int main(int argc, char const *argv[]) {
  // your MongoDB URI connection string
  const char *uri_string = MY_MONGODB_URI;
  // MongoDB URI created from above string
  mongoc_uri_t *uri;
  // MongoDB Client, used to connect to the DB
  mongoc_client_t *client;

// Error management
  bson_error_t error;

mongoc_collection_t *collection;
  char **collection_names;
  unsigned i;

// Query object
  bson_t *query;
  mongoc_cursor_t *cursor;

char *str;

/*
   * Required to initialize libmongoc's internals
   */
  mongoc_init();

/*
   * Safely create a MongoDB URI object from the given string
   */
  uri = mongoc_uri_new_with_error(uri_string, &error);
  if (!uri) {
    fprintf(stderr,
            "failed to parse URI: %s\n"
            "error message:       %s\n",
            uri_string, error.message);
    return EXIT_FAILURE;
  }

/*
   * Create a new client instance, here we use the uri we just built
   */
  client = mongoc_client_new_from_uri(uri);
  if (!client) {
    puts("Error connecting!");
    return EXIT_FAILURE;
  }

/*
   * Register the application name so we can track it in the profile logs
   * on the server. This can also be done from the URI (see other examples).
   */
  mongoc_client_set_appname(client, "connect-example");

/*
   * Get a handle on the database "db_name" and collection "coll_name"
   */
  collection = mongoc_client_get_collection(client, "sample_mflix", "movies");

query = bson_new();

// All movies from 1984!
  BSON_APPEND_INT32(query, "year", 1984);
  cursor = mongoc_collection_find_with_opts(collection, query, NULL, NULL);

while (mongoc_cursor_next(cursor, &query)) {
    str = bson_as_canonical_extended_json(query, NULL);
    printf("%s\n", str);
    bson_free(str);
  }

/*
   * Release our handles and clean up libmongoc
   */

bson_destroy(query);

mongoc_collection_destroy(collection);
  mongoc_uri_destroy(uri);
  mongoc_client_destroy(client);
  mongoc_cleanup();

return EXIT_SUCCESS;
}

Inserindo um novo documento

OK, sabemos ler dados, mas que tal inserir dados novos em nosso MongoDB database? É fácil! Acabamos de criar um BSON para ser inserido e chamar mongoc_collection_insert_one.

Trecho de código

A amostra completa segue.

Trecho de código

// insert.c
#include "URI.h"
#include <mongoc/mongoc.h>

int main(int argc, char const *argv[]) {
  // your MongoDB URI connection string
  const char *uri_string = MY_MONGODB_URI;
  // MongoDB URI created from above string
  mongoc_uri_t *uri;
  // MongoDB Client, used to connect to the DB
  mongoc_client_t *client;

// Error management
  bson_error_t error;

mongoc_collection_t *collection;
  char **collection_names;
  unsigned i;

// Object id and BSON doc
  bson_oid_t oid;
  bson_t *doc;

char *str;

/*
   * Required to initialize libmongoc's internals
   */
  mongoc_init();

/*
   * Safely create a MongoDB URI object from the given string
   */
  uri = mongoc_uri_new_with_error(uri_string, &error);
  if (!uri) {
    fprintf(stderr,
            "failed to parse URI: %s\n"
            "error message:       %s\n",
            uri_string, error.message);
    return EXIT_FAILURE;
  }

/*
   * Create a new client instance, here we use the uri we just built
   */
  client = mongoc_client_new_from_uri(uri);
  if (!client) {
    return EXIT_FAILURE;
  }

/*
   * Register the application name so we can track it in the profile logs
   * on the server. This can also be done from the URI (see other examples).
   */
  mongoc_client_set_appname(client, "connect-example");

/*
   * Get a handle on the database "db_name" and collection "coll_name"
   */
  collection = mongoc_client_get_collection(client, "sample_mflix", "movies");

doc = bson_new();
  bson_oid_init(&oid, NULL);
  BSON_APPEND_OID(doc, "_id", &oid);
  BSON_APPEND_UTF8(doc, "name", "My super new picture");

if (!mongoc_collection_insert_one(collection, doc, NULL, NULL, &error)) {
    fprintf(stderr, "%s\n", error.message);
  } else {
    printf("Document inserted!");
    /*
     * Print the document as a JSON string.
     */
    str = bson_as_canonical_extended_json(doc, NULL);
    printf("%s\n", str);
    bson_free(str);
  }

/*
   * Release our handles and clean up libmongoc
   */

mongoc_collection_destroy(collection);
  mongoc_uri_destroy(uri);
  mongoc_client_destroy(client);
  mongoc_cleanup();

return EXIT_SUCCESS;
}

Excluindo um documento

Para excluir um documento, chamamos mongoc_collection_delete_one. Precisamos passar um documento contendo a query para restringir os documentos que queremos localizar e excluir.

Trecho de código

A amostra completa segue.

Trecho de código

// delete.c
#include "URI.h"
#include <mongoc/mongoc.h>

int main(int argc, char const *argv[]) {
  // your MongoDB URI connection string
  const char *uri_string = MY_MONGODB_URI;
  // MongoDB URI created from above string
  mongoc_uri_t *uri;
  // MongoDB Client, used to connect to the DB
  mongoc_client_t *client;

// Error management
  bson_error_t error;

mongoc_collection_t *collection;
  char **collection_names;
  unsigned i;

// Object id and BSON doc
  bson_oid_t oid;
  bson_t *doc;

char *str;

/*
   * Required to initialize libmongoc's internals
   */
  mongoc_init();

/*
   * Safely create a MongoDB URI object from the given string
   */
  uri = mongoc_uri_new_with_error(uri_string, &error);
  if (!uri) {
    fprintf(stderr,
            "failed to parse URI: %s\n"
            "error message:       %s\n",
            uri_string, error.message);
    return EXIT_FAILURE;
  }

/*
   * Create a new client instance, here we use the uri we just built
   */
  client = mongoc_client_new_from_uri(uri);
  if (!client) {
    return EXIT_FAILURE;
  }

/*
   * Register the application name so we can track it in the profile logs
   * on the server. This can also be done from the URI (see other examples).
   */
  mongoc_client_set_appname(client, "connect-example");

/*
   * Get a handle on the database "db_name" and collection "coll_name"
   */
  collection = mongoc_client_get_collection(client, "sample_mflix", "movies");

// Let's insert one document in this collection!
  doc = bson_new();
  bson_oid_init(&oid, NULL);
  BSON_APPEND_OID(doc, "_id", &oid);
  BSON_APPEND_UTF8(doc, "name", "My super new picture");

if (!mongoc_collection_insert_one(collection, doc, NULL, NULL, &error)) {
    fprintf(stderr, "%s\n", error.message);
  } else {
    printf("Document inserted!");
    /*
     * Print the document as a JSON string.
     */
    str = bson_as_canonical_extended_json(doc, NULL);
    printf("%s\n", str);
    bson_free(str);
  }

bson_destroy(doc);

// Delete the inserted document!

doc = bson_new();
  BSON_APPEND_OID(doc, "_id", &oid);

if (!mongoc_collection_delete_one(collection, doc, NULL, NULL, &error)) {
    fprintf(stderr, "Delete failed: %s\n", error.message);
  } else {
    puts("Document deleted!");
  }

/*
   * Release our handles and clean up libmongoc
   */

mongoc_collection_destroy(collection);
  mongoc_uri_destroy(uri);
  mongoc_client_destroy(client);
  mongoc_cleanup();

return EXIT_SUCCESS;
}

Atualizando um documento

Finalmente, para atualizar um documento, precisamos fornecer a consulta para encontrar o documento a ser atualizado e um documento com os campos que queremos alterar.

Trecho de código

A amostra completa segue.

Trecho de código

// update.c
#include "URI.h"
#include <mongoc/mongoc.h>

int main(int argc, char const *argv[]) {
  // your MongoDB URI connection string
  const char *uri_string = MY_MONGODB_URI;
  // MongoDB URI created from above string
  mongoc_uri_t *uri;
  // MongoDB Client, used to connect to the DB
  mongoc_client_t *client;

// Error management
  bson_error_t error;

mongoc_collection_t *collection;
  char **collection_names;
  unsigned i;

// Object id and BSON doc
  bson_oid_t oid;
  bson_t *doc;

// document to update and query to find it
  bson_t *update = NULL;
  bson_t *query = NULL;
  char *str;

/*
   * Required to initialize libmongoc's internals
   */
  mongoc_init();

/*
   * Safely create a MongoDB URI object from the given string
   */
  uri = mongoc_uri_new_with_error(uri_string, &error);
  if (!uri) {
    fprintf(stderr,
            "failed to parse URI: %s\n"
            "error message:       %s\n",
            uri_string, error.message);
    return EXIT_FAILURE;
  }

/*
   * Create a new client instance, here we use the uri we just built
   */
  client = mongoc_client_new_from_uri(uri);
  if (!client) {
    return EXIT_FAILURE;
  }

/*
   * Register the application name so we can track it in the profile logs
   * on the server. This can also be done from the URI (see other examples).
   */
  mongoc_client_set_appname(client, "connect-example");

/*
   * Get a handle on the database "db_name" and collection "coll_name"
   */
  collection = mongoc_client_get_collection(client, "sample_mflix", "movies");

// we create a new BSON Document
  doc = bson_new();
  bson_oid_init(&oid, NULL);
  BSON_APPEND_OID(doc, "_id", &oid);
  BSON_APPEND_UTF8(doc, "name", "My super new movie");

// Then we insert it in the movies collection
  if (!mongoc_collection_insert_one(collection, doc, NULL, NULL, &error)) {
    fprintf(stderr, "%s\n", error.message);
  } else {
    printf("Document inserted!\n");
    /*
     * Print the document as a JSON string.
     */
    str = bson_as_canonical_extended_json(doc, NULL);
    printf("%s\n", str);
    bson_free(str);

// now we search for that document to update it
    query = BCON_NEW("_id", BCON_OID(&oid));
    update =
        BCON_NEW("$set", "{", "name", BCON_UTF8("Super new movie was boring"),
                 "updated", BCON_BOOL(true), "}");

if (!mongoc_collection_update_one(collection, query, update, NULL, NULL,
                                      &error)) {
      fprintf(stderr, "%s\n", error.message);
    } else {
      printf("Document edited!\n");
      str = bson_as_canonical_extended_json(update, NULL);
      printf("%s\n", str);
    }
  }

/*
   * Release our handles and clean up libmongoc
   */

if (doc) {
    bson_destroy(doc);
  }
  if (query) {
    bson_destroy(query);
  }
  if (update) {
    bson_destroy(update);
  }

mongoc_collection_destroy(collection);
  mongoc_uri_destroy(uri);
  mongoc_client_destroy(client);
  mongoc_cleanup();

return EXIT_SUCCESS;
}

Encerrando

Com este artigo, abordamos a instalação do driver MongoDB C, configurando o VS Code como nosso editor e configurando outras ferramentas. Em seguida, criamos alguns aplicativos de console que se conectam ao MongoDB Atlas e executam operações CRUD básicas.

Obtenha mais informações sobre o driver Ce, para experimentar este código, a maneira mais fácil seria registrar-se para uma conta MongoDB gratuita. Nós mal podemos esperar para ver o que você construirá a seguir!

Atlas

Getting Started With MongoDB and C

Introdução ao MongoDB e C

Sumário

Pré-requisitos

VS Code, extensões C, Xcode

Instalando o driver C

Configurando extensões do VS Code

Olá, MongoDB!

Configurando o cliente e enviando ping para o MongoDB Atlas

Compilando e executando nosso código

Conectando ao banco de dados e listando todas as coleções

Criando um objeto JSON em C

CRUD no MongoDB usando o driver C

Query de dados

Inserindo um novo documento

Excluindo um documento

Atualizando um documento

Encerrando

Relacionado

Análise de consultas, parte 2: ajustando o sistema

Como escrever testes de unidade para MongoDB Atlas Functions

Aplicar linguagem natural em consultas do MongoDB com o Google Gemini

Como implementar o Agentic RAG usando o Claude 3.5 Sonnet, LlamaIndex e MongoDB

Sumário