Featured Issues

Our Data Engineering Byte Newsletter gives data engineers and practitioners what they often lack today: clear, real-world insights—where every byte tells a story.Subscribe here to stay ahead in data engineeringIntroductionCRUD operations form the backbone of how developers interact with MongoDB databases. Whether you're building a small prototype or scaling a production application, understanding how to create, read, update, and delete data is essential. These four operations allow developers to insert new documents, retrieve existing information, modify stored data, and remove records when they are no longer needed.In MongoDB, CRUD operations can be performed using different tools and programming environments. Developers often begin with mongosh (MongoDB Shell) for direct database interaction and testing queries, while application development typically uses official drivers such as PyMongo for Python. This excerpt introduces the core CRUD concepts and demonstrates how to perform them using both mongosh and the MongoDB Python driver, helping developers understand the fundamental workflows for managing data in MongoDB.MongoDB CRUD operationsCRUD operations are the foundation of interacting with a MongoDB deployment. These operations require you to connect to the MongoDB server before you can query the relevant documents, adjust the specified properties, and subsequently, transmit the data back to the database for updates. Each CRUD operation serves a distinct purpose:The create operation creates and inserts new documents into the databaseThe read operation queries a document or documents in the databaseThe update operation modifies existing documents in the databaseThe delete operation removes documents from the databaseBasic CRUD with mongoshmongosh, also known as the MongoDB Shell, is an environment for hosting MongoDB deployments. It is equivalent to the administration console that relational databases use. You can download mongosh at https://www.mongodb.com/docs/mongodb-shell/install/.This section explains how to connect to your deployment with mongosh, insert a document into a database, query your database for a specified document, update a document, and delete a document. For more in-depth information and examples, you can also refer to the CRUD operations section of the MongoDB database manual at https://www.mongodb.com/docs/manual/crud/.Connecting to MongoDBBefore you can perform CRUD operations, you must connect to your MongoDB deployment. To connect to mongosh, you must specify your deployment connection string as well as any specified parameters.For example, enter a variation of the following code block in your terminal to connect to a MongoDB deployment with mongosh:mongosh "mongodb+srv://mycluster.packt.mongodb.net/myDatabase" --username myUsername --password myPasswordCreating documentsTo create a document in mongosh, you can use the db.collection.insertOne() command. This mongosh command creates a new document and inserts the created document into the specified collection.For example, the following db.collection.insertOne()command creates and inserts a new document into the library collection of the database. The new document has a title field set to Mastering MongoDB 8.0 and an isbn field set to 101:db.library.insertOne( { title: 'Mastering MongoDB 8.0', isbn: '101' } )When you successfully create and insert a document, MongoDB returns a confirmation output that contains the ObjectID value of the new document:{ acknowledged: true, insertedId: ObjectId("652024e7ab44f3bf77788a3d") }You can also use the following mongosh commands to update documents:db.collection.insertMany()db.collection.updateOne() with the upsert: true optiondb.collection.updateMany() with the upsert: true optiondb.collection.findAndModify() with the upsert: true optiondb.collection.findOneAndUpdate() with the upsert: true optiondb.collection.findOneAndReplace() with the upsert: true optionReading documentsRead operations in MongoDB are also called queries. To perform a basic read operation, or query, for a single document, use the db.collection.findOne() method and specify the selection criteria of the document that you want to read.For example, the following operation queries for a document in the library collection that contains the isbn field value of 101:db.library.find( { isbn: '101' } )If the library collection contains a document that matches your specified selection criteria, MongoDB returns an array that contains the document that matches:[ { _id: ObjectId("652024e7ab44f3bf77788a3d"),   title: 'Mastering MongoDB 8.0',   isbn: '101' } ]You can also use the following mongosh commands to read documents:db.collection.findOne()Updating documentsTo update a document, you can use the db.collection.updateOne() command. This command finds a document that matches the specified criteria and updates the found document.For example, the following code finds the document in the library collection that has an isbn field value of 101 and updates that document so that it contains a price field with a value of 30:db.library.updateOne( { isbn: '101' }, { $set: { price: 30 } } )When you successfully update a document, MongoDB returns the following confirmation summary:{ acknowledged: true,   insertedId: null,   matchedCount: 1,   modifiedCount: 1,   upsertedCount: 0 }You can also use the following mongosh commands to update documents:db.collection.updateMany()db.collection.replaceOne()db.collection.findOneAndReplace()db.collection.findOneAndUpdate()db.collection.findAndModify()MongoDB 8.0 also introduces the ability to sort documents within an update operation. If you specify a sort parameter in an operation that uses db.collection.updateOne(), db.collection. replaceOne(), or update, MongoDB sorts documents before updating to be able to select a specific document for the operation when multiple documents match the query.For example, the following update operation sorts all books by price and updates the lowest price book to be on sale for 25% off:db.library.updateOne( { }, [    { $set: { price: { $multiply: ["$price", 0.75] } } } ], { sort: { price: 1 } } )Deleting documentsTo delete a document, you can use the db.collection.deleteOne() command. This command queries for a document that matches specified criteria and deletes the found document.For example, the following operation deletes a document in the library collection that has an isbn field value of 101:db.library.deleteOne( { isbn: '101' } )When you successfully delete a document, MongoDB returns the following output:{    acknowledged: true,   deletedCount: 1 }You can also use the following mongosh commands to delete documents:db.collection.deleteMany()db.collection.remove()db.collection.findOneAndDelete()db.collection.findAndModify()Basic CRUD with the Python driverAs an alternative to mongosh, MongoDB provides official drivers to interact with your MongoDB deployment. For a full list of official MongoDB driver libraries, see https://www.mongodb.com/ docs/drivers/.The following sections walk you through performing CRUD operations with the MongoDB Python driver, PyMongo. PyMongo provides a seamless bridge between the dynamic world of Python programming and the efficient, document-oriented NoSQL database of MongoDB.Installing and connecting to PyMongoYou can use pip to install PyMongo. You must have Python installed prior to installing PyMongo.For example, the following operation installs PyMongo through your terminal:To connect to your MongoDB deployment with PyMongo, you must use your connection string.For example, the following code snippet in a .py file connects to a MongoDB deployment:from pymongo import MongoClient uri = "<connection string>" client = MongoClient(uri) try: client.admin.command('ping') print("Pinged your deployment. You successfully connected to MongoDB!") except Exception as e:     print(e)If you run the preceding code in a .py file and successfully connect to your deployment, MongoDB returns the following confirmation:"Pinged your deployment. You successfully connected to MongoDB!"You can test your connection to your MongoDB deployment on Atlas with the following code block in a .py file. This code block uses the asyncio asynchronous framework:import asyncio from motor.motor_asyncio import AsyncIOMotorClient from pymongo.server_api import ServerApi async def ping_server(): uri = "<connection string>" client = AsyncIOMotorClient(uri, server_api=ServerApi('1')) try: await client.admin.command('ping') print("Pinged your deployment. You successfully connected to MongoDB!") except Exception as e: print(e) asyncio.run(ping_server())If you run the preceding code in a .py file and successfully connect to your deployment, MongoDB returns the following confirmation:"Pinged your deployment. You successfully connected to MongoDB!".Creating documentsTo create and insert documents with PyMongo, use the insert_one command.For example, the code block that follows performs the following operations:Specifies the library collection within the resources databaseDefines a new document that represents a book titled Python and MongoDBInserts the new document into the library databasePrints the ObjectId value of the new documentlibrary = client.resources.library book = {   'isbn': '301', 'name': 'Python and MongoDB', 'meta': {'version': 'MongoDB 8.0'}, 'price': 60 } insert_result = library.insert_one(book) print(insert_result)If you successfully insert a document with this script, MongoDB prints the ObjectId value of the inserted document.Reading documentsYou can read documents from your database with queries.To read a document, specify the condition(s) of the document you want to read with a find_onecommand.For example, the code block that follows performs the following actions:Specifies the library collection in the resources databaseFinds documents with the name value of Python and MongoDB Prints the found documentlibrary = client.resources.library result = library.find_one( {"name": "Python and MongoDB"} ) print (result)Updating documentsTo update a document with PyMongo, use the update_one command. This command finds a document based on specified criteria and updates the found document.For example, the code block that follows performs the following operations:Finds the document where the name field is Advanced MongoDB TechniquesSets the price field of the found document to the value of 75Prints the result of the update_one operation       Prints the updated documentupdate_result = library.update_one(   { "name": "Advanced MongoDB Techniques"}, { "$set": { "price": 75 } } ) print(update_result.raw_result) updated_document = library.find_one(   {"name": "Advanced MongoDB Techniques"} ) print(updated_document)Deleting a documentTo delete a document with PyMongo, use the delete_one command. For example, the code block that follows performs the following operations:Specifies the isbn value of the book to delete as 303Uses the delete_one command to delete a book from the library collection with the desired isbn valuePrints the result of the delete_one operationisbn_to_delete = '303' delete_result = library.delete_one({"isbn": isbn_to_delete}) print(delete_result.raw_result)If the operation successfully deleted the desired document, MongoDB returns the following confirmation:{'n': 1, 'ok': 1.0}The n value indicates the number of documents that MongoDB deleted. In this case, MongoDB deleted one document. The ok value indicates whether the operation caused any errors. The 1.0 value in the preceding confirmation signifies that MongoDB did not encounter an error with this operation.ConclusionCRUD operations are the fundamental building blocks for working with MongoDB. By learning how to connect to a MongoDB deployment and perform create, read, update, and delete operations, developers gain the ability to manage application data efficiently. Tools such as mongosh provide a powerful command-line environment for direct database interaction, while drivers like PyMongo allow seamless integration between MongoDB and programming languages such as Python. Together, these tools enable developers to prototype, test, and build robust data-driven applications.This section provides a practical overview of MongoDB CRUD workflows, illustrating how documents can be inserted, queried, modified, and removed using both the MongoDB Shell and the Python driver.This content is an excerpt from The Official MongoDB Guide, published by Packt and MongoDB, and written by Rachelle Palmer, Jeffrey Allen, Parker Faucher, Alison Huh, Lander Kerbey, Maya Raman, and Lauren Tran.Author BioRachelle Palmer is the Product Leader for Developer Database Experience and Developer Education at MongoDB, overseeing the driver client libraries, documentation, framework integrations, and MongoDB University. She has built sample applications for MongoDB in Java, PHP, Rust, Python, Node.js, and Ruby. Rachelle joined MongoDB in 2013 and was previously the Director of the Technical Services Engineering team, creating and managing the team that provided support and CloudOps to MongoDB Atlas.Jeffery Allen is a Technical Writer at MongoDB, based in the New York City area. He focuses on server documentation and works closely with Product and Engineering teams to develop examples that reflect real-world use cases, especially pertaining to data modeling and the MongoDB query language. Before joining MongoDB, Jeff worked as a full-stack web developer. Jeff also enjoys playing guitar and piano and produces electronic music in his spare time.Parker Faucher is a self-taught Software Engineer with over six years of experience in technical education. He has authored more than 100 educational videos for MongoDB, establishing himself as a knowledgeable resource in database technologies. Currently, Parker focuses on Artificial Intelligence and Search technologies, exploring innovative solutions in these rapidly evolving fields. hen not advancing his technical expertise, Parker enjoys spending quality time with his family and maintains an avid interest in collecting comic books.Lander Kerbey is a Technical Writer at MongoDB, specializing in Atlas Stream Processing. Prior to MongoDB, he worked at InterSystems, documenting various parts of the HealthShare suite, along with their various data analytics tools. His 11 years of experience as an educator informs his approach to documentation, as he strives to create “Aha!” moments for users.Maya Raman is a Technical Writer and sometimes-software engineer at MongoDB. She is passionate about the intersections between the environment, art and literature, technology, and people. She is based in New York City and likes to spend her time hanging out in Prospect Park, even in winter.Lauren Tran is a Technical Writer at MongoDB with a background in Communications and Computer Science. She is on the Server Documentation team and mainly specializes in Information Architecture, Time Series data, and Search. Lauren is passionate about creating accessible and inclusive documentation that caters to diverse audiences. She is based in Chicago following four years in New York City and in her free time, enjoys reading on the beach at Lake Michigan and listening to Taylor Swift music.

And What To Do About ItWe asked 700 network engineers and DevOps folks a simple question: what's your biggest challenge with AI?64% said the same thing. They don't trust AI output for production networks.Not "I don't know how to use it."Not "the tools are confusing."Just: I don't trust it.That number didn't surprise us. But it did confirm something we'd been hearing from practitioners for a while. The problem with AI in networking isn't technical. It's cultural.Issue #1WHY NETWORK ENGINEERS DON'T TRUST AI(AND WHAT TO DO ABOUT IT)READ ON WEBJohn Capobianco is the Head of AI and Developer Relations at Itential. He's been pushing AI and automation in networking longer than most. And he told us something that puts the whole trust debate in perspective.According to the Network Automation Forum's survey last year, only 30% of enterprises have adopted automation. That means 70% are still doing things by hand. This is ten years after automation became a real option."What has slowed that adoption is not the technology," John told us. "It's the people and it's the culture."AI is hitting the same wall. Except now, there's an extra layer of fear on top. The AI might hallucinate. It might push the wrong config. It might take down a link.These are real concerns. Nobody's dismissing them. But John makes a point that's hard to argue with: "How many networks have gone down because the engineer was on the wrong device? The engineer issued the wrong command? The engineer was on the wrong interface? The engineer made a typo?"We've all seen it happen. A fat-finger at 2am on a live router. A copy-paste into the wrong terminal window. A change that looked right but wasn't tested first.The difference? When AI makes a mistake, it's visible. It's in code. You can catch it in review before it touches anything. When a human makes a mistake at 2am under pressure, there's no review step. There's no undo button.THE SKEPTICS ARE LOUDER THAN THE BUILDERSJohn said something in our conversation that stuck with us. He was talking about the engineers who try AI for 15 minutes, call it "slop," and move on."Those people are three years behind," he said. "But they're very vocal and they say it with authority. And they might be a CCIE. So a lot of people tend to take that as their influence."Here's what changed in those three years. RAG lets you ground AI responses in your own documentation, your own runbooks, your own configs. MCP gives AI agents a structured, governed way to interact with your network tools. These aren't lab experiments. Lumen, one of the largest network operators in the world, is running closed-loop AI remediation in production right now. Problems that used to take hours are getting resolved in seconds.But if your only experience with AI was asking ChatGPT to explain OSPF two years ago, you wouldn't know any of this. And you'd be right to be skeptical. You'd just be skeptical about something that no longer exists.OK, SO HOW DO YOU ACTUALLY START TRUSTING IT?We've been talking to people who are actually deploying AI on production networks. Not in theory. In practice. And a pattern keeps showing up. It's not dramatic. It's not a big leap. It's a ramp.Here's how it works.Start with read-only tasks. Don't push config. Don't change anything. Just have AI pull data you already look at, interface health, routing tables, log summaries, and present it to you in plain language. John's example: have an agent run "show ip interface brief" and send you a Slack message with the results. You're not automating anything. You're just getting a faster view of your own network. "That's completely 100% safe," he said. "And it saves us hours of human copy-paste."Keep a human in the loop. Before any action hits the network, build in an approval step. A ServiceNow ticket. A Slack message that needs a thumbs-up. The AI proposes. You decide. John calls this "the best of both worlds." The agent does the work, but a human expert reviews the output before anything gets executed.Test in a digital twin. Tools like ContainerLab and Cisco CML let you build a virtual copy of your network. Let AI agents run wild in there. Let them break things. That's the whole point. You want to see where they fail before you let them near production. This is exactly what practitioners are teaching in workshops right now: spin up a lab, give the AI room to operate, and watch what happens.Find low-risk, high-value cases. The Lumen story is useful here. They didn't start by letting AI redesign their routing architecture. They started with a simple, high-frequency problem: a sub-interface gets accidentally shut down, service goes down, someone has to get paged. Their AI system detects the root cause, runs a "no shut" to restore service, confirms it worked, and logs everything. Low risk. Happens all the time. Saves hours at scale.Graduate slowly. Once read-only operations work and simple fixes are validated in a lab, you expand. But with guardrails. Markdown files that define what the agent can and can't do. Approval gates for anything that writes config. Full audit logs. Then you widen the scope, one use case at a time.This isn't "move fast and break things." That doesn't work for networks. This is: move carefully, prove it works, expand.THE COST OF DOING NOTHINGThe trust debate tends to focus on the risks of using AI. Fair enough. But there's a cost on the other side too, and it doesn't show up in dashboards.John put it in personal terms: "As someone who used to be a senior network architect and was on call, getting a call at 3:00 in the morning and spending two hours troubleshooting, and it turns out to be just a sub-interface that got shut down, that's not a good use of my time. And the morale and the impact on my personal life and my family life."Every manual syslog review is time a senior engineer isn't spending on design and strategy. Every 3am page for a routine issue is a hit to retention. Every change window that takes ten people three days is budget that could go somewhere else.The question isn't whether AI is perfect. It's whether AI with human oversight is better than humans alone, under pressure, in the middle of the night, on the wrong terminal.We think the evidence says yes. And we'll keep bringing you that evidence, from real practitioners, real deployments, and real results, in every issue of this newsletter.Cheers,Shreyans SinghEditor-in-ChiefREAD ON WEB*{box-sizing:border-box}body{margin:0;padding:0}a[x-apple-data-detectors]{color:inherit!important;text-decoration:inherit!important}#MessageViewBody a{color:inherit;text-decoration:none}p{line-height:inherit}.desktop_hide,.desktop_hide table{mso-hide:all;display:none;max-height:0;overflow:hidden}.image_block img+div{display:none}sub,sup{font-size:75%;line-height:0} @media (max-width: 100%;display:block}.mobile_hide{min-height:0;max-height:0;max-width: 100%;overflow:hidden;font-size:0}.desktop_hide,.desktop_hide table{display:table!important;max-height:none!important}}