#asynchronous programming

[la-principessa-nuova]

Product Owner: We just found out the client is still using Internet Explorer, so we’ll need to add ES5 support. Can you get that done by the end of the day?

Developer: Well I can’t make any promises, but I’ll give you a callback this afternoon and let you know how far along it is.

[jcmarchi]

Asynchronous LLM API Calls in Python: A Comprehensive Guide

New Post has been published on https://thedigitalinsider.com/asynchronous-llm-api-calls-in-python-a-comprehensive-guide/

Asynchronous LLM API Calls in Python: A Comprehensive Guide

As developers and dta scientists, we often find ourselves needing to interact with these powerful models through APIs. However, as our applications grow in complexity and scale, the need for efficient and performant API interactions becomes crucial. This is where asynchronous programming shines, allowing us to maximize throughput and minimize latency when working with LLM APIs.

In this comprehensive guide, we’ll explore the world of asynchronous LLM API calls in Python. We’ll cover everything from the basics of asynchronous programming to advanced techniques for handling complex workflows. By the end of this article, you’ll have a solid understanding of how to leverage asynchronous programming to supercharge your LLM-powered applications.

Before we dive into the specifics of async LLM API calls, let’s establish a solid foundation in asynchronous programming concepts.

Asynchronous programming allows multiple operations to be executed concurrently without blocking the main thread of execution. In Python, this is primarily achieved through the asyncio module, which provides a framework for writing concurrent code using coroutines, event loops, and futures.

Key concepts:

Coroutines: Functions defined with async def that can be paused and resumed.

Event Loop: The central execution mechanism that manages and runs asynchronous tasks.

Awaitables: Objects that can be used with the await keyword (coroutines, tasks, futures).

Here’s a simple example to illustrate these concepts:

import asyncio async def greet(name): await asyncio.sleep(1) # Simulate an I/O operation print(f"Hello, name!") async def main(): await asyncio.gather( greet("Alice"), greet("Bob"), greet("Charlie") ) asyncio.run(main())

In this example, we define an asynchronous function greet that simulates an I/O operation with asyncio.sleep(). The main function uses asyncio.gather() to run multiple greetings concurrently. Despite the sleep delay, all three greetings will be printed after approximately 1 second, demonstrating the power of asynchronous execution.

The Need for Async in LLM API Calls

When working with LLM APIs, we often encounter scenarios where we need to make multiple API calls, either in sequence or parallel. Traditional synchronous code can lead to significant performance bottlenecks, especially when dealing with high-latency operations like network requests to LLM services.

Consider a scenario where we need to generate summaries for 100 different articles using an LLM API. With a synchronous approach, each API call would block until it receives a response, potentially taking several minutes to complete all requests. An asynchronous approach, on the other hand, allows us to initiate multiple API calls concurrently, dramatically reducing the overall execution time.

Setting Up Your Environment

To get started with async LLM API calls, you’ll need to set up your Python environment with the necessary libraries. Here’s what you’ll need:

Python 3.7 or higher (for native asyncio support)

aiohttp: An asynchronous HTTP client library

openai: The official OpenAI Python client (if you’re using OpenAI’s GPT models)

langchain: A framework for building applications with LLMs (optional, but recommended for complex workflows)

You can install these dependencies using pip:

pip install aiohttp openai langchain <div class="relative flex flex-col rounded-lg">

Basic Async LLM API Calls with asyncio and aiohttp

Let’s start by making a simple asynchronous call to an LLM API using aiohttp. We’ll use OpenAI’s GPT-3.5 API as an example, but the concepts apply to other LLM APIs as well.

import asyncio import aiohttp from openai import AsyncOpenAI async def generate_text(prompt, client): response = await client.chat.completions.create( model="gpt-3.5-turbo", messages=["role": "user", "content": prompt] ) return response.choices[0].message.content async def main(): prompts = [ "Explain quantum computing in simple terms.", "Write a haiku about artificial intelligence.", "Describe the process of photosynthesis." ] async with AsyncOpenAI() as client: tasks = [generate_text(prompt, client) for prompt in prompts] results = await asyncio.gather(*tasks) for prompt, result in zip(prompts, results): print(f"Prompt: promptnResponse: resultn") asyncio.run(main())

In this example, we define an asynchronous function generate_text that makes a call to the OpenAI API using the AsyncOpenAI client. The main function creates multiple tasks for different prompts and uses asyncio.gather() to run them concurrently.

This approach allows us to send multiple requests to the LLM API simultaneously, significantly reducing the total time required to process all prompts.

Advanced Techniques: Batching and Concurrency Control

While the previous example demonstrates the basics of async LLM API calls, real-world applications often require more sophisticated approaches. Let’s explore two important techniques: batching requests and controlling concurrency.

Batching Requests: When dealing with a large number of prompts, it’s often more efficient to batch them into groups rather than sending individual requests for each prompt. This reduces the overhead of multiple API calls and can lead to better performance.

import asyncio from openai import AsyncOpenAI async def process_batch(batch, client): responses = await asyncio.gather(*[ client.chat.completions.create( model="gpt-3.5-turbo", messages=["role": "user", "content": prompt] ) for prompt in batch ]) return [response.choices[0].message.content for response in responses] async def main(): prompts = [f"Tell me a fact about number i" for i in range(100)] batch_size = 10 async with AsyncOpenAI() as client: results = [] for i in range(0, len(prompts), batch_size): batch = prompts[i:i+batch_size] batch_results = await process_batch(batch, client) results.extend(batch_results) for prompt, result in zip(prompts, results): print(f"Prompt: promptnResponse: resultn") asyncio.run(main())

Concurrency Control: While asynchronous programming allows for concurrent execution, it’s important to control the level of concurrency to avoid overwhelming the API server or exceeding rate limits. We can use asyncio.Semaphore for this purpose.

import asyncio from openai import AsyncOpenAI async def generate_text(prompt, client, semaphore): async with semaphore: response = await client.chat.completions.create( model="gpt-3.5-turbo", messages=["role": "user", "content": prompt] ) return response.choices[0].message.content async def main(): prompts = [f"Tell me a fact about number i" for i in range(100)] max_concurrent_requests = 5 semaphore = asyncio.Semaphore(max_concurrent_requests) async with AsyncOpenAI() as client: tasks = [generate_text(prompt, client, semaphore) for prompt in prompts] results = await asyncio.gather(*tasks) for prompt, result in zip(prompts, results): print(f"Prompt: promptnResponse: resultn") asyncio.run(main())

In this example, we use a semaphore to limit the number of concurrent requests to 5, ensuring we don’t overwhelm the API server.

Error Handling and Retries in Async LLM Calls

When working with external APIs, it’s crucial to implement robust error handling and retry mechanisms. Let’s enhance our code to handle common errors and implement exponential backoff for retries.

import asyncio import random from openai import AsyncOpenAI from tenacity import retry, stop_after_attempt, wait_exponential class APIError(Exception): pass @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10)) async def generate_text_with_retry(prompt, client): try: response = await client.chat.completions.create( model="gpt-3.5-turbo", messages=["role": "user", "content": prompt] ) return response.choices[0].message.content except Exception as e: print(f"Error occurred: e") raise APIError("Failed to generate text") async def process_prompt(prompt, client, semaphore): async with semaphore: try: result = await generate_text_with_retry(prompt, client) return prompt, result except APIError: return prompt, "Failed to generate response after multiple attempts." async def main(): prompts = [f"Tell me a fact about number i" for i in range(20)] max_concurrent_requests = 5 semaphore = asyncio.Semaphore(max_concurrent_requests) async with AsyncOpenAI() as client: tasks = [process_prompt(prompt, client, semaphore) for prompt in prompts] results = await asyncio.gather(*tasks) for prompt, result in results: print(f"Prompt: promptnResponse: resultn") asyncio.run(main())

This enhanced version includes:

A custom APIError exception for API-related errors.

A generate_text_with_retry function decorated with @retry from the tenacity library, implementing exponential backoff.

Error handling in the process_prompt function to catch and report failures.

Optimizing Performance: Streaming Responses

For long-form content generation, streaming responses can significantly improve the perceived performance of your application. Instead of waiting for the entire response, you can process and display chunks of text as they become available.

import asyncio from openai import AsyncOpenAI async def stream_text(prompt, client): stream = await client.chat.completions.create( model="gpt-3.5-turbo", messages=["role": "user", "content": prompt], stream=True ) full_response = "" async for chunk in stream: if chunk.choices[0].delta.content is not None: content = chunk.choices[0].delta.content full_response += content print(content, end='', flush=True) print("n") return full_response async def main(): prompt = "Write a short story about a time-traveling scientist." async with AsyncOpenAI() as client: result = await stream_text(prompt, client) print(f"Full response:nresult") asyncio.run(main())

This example demonstrates how to stream the response from the API, printing each chunk as it arrives. This approach is particularly useful for chat applications or any scenario where you want to provide real-time feedback to the user.

Building Async Workflows with LangChain

For more complex LLM-powered applications, the LangChain framework provides a high-level abstraction that simplifies the process of chaining multiple LLM calls and integrating other tools. Let’s look at an example of using LangChain with async capabilities:

This example shows how LangChain can be used to create more complex workflows with streaming and asynchronous execution. The AsyncCallbackManager and StreamingStdOutCallbackHandler enable real-time streaming of the generated content.

import asyncio from langchain.llms import OpenAI from langchain.prompts import PromptTemplate from langchain.chains import LLMChain from langchain.callbacks.manager import AsyncCallbackManager from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler async def generate_story(topic): llm = OpenAI(temperature=0.7, streaming=True, callback_manager=AsyncCallbackManager([StreamingStdOutCallbackHandler()])) prompt = PromptTemplate( input_variables=["topic"], template="Write a short story about topic." ) chain = LLMChain(llm=llm, prompt=prompt) return await chain.arun(topic=topic) async def main(): topics = ["a magical forest", "a futuristic city", "an underwater civilization"] tasks = [generate_story(topic) for topic in topics] stories = await asyncio.gather(*tasks) for topic, story in zip(topics, stories): print(f"nTopic: topicnStory: storyn'='*50n") asyncio.run(main())

Serving Async LLM Applications with FastAPI

To make your async LLM application available as a web service, FastAPI is an great choice due to its native support for asynchronous operations. Here’s an example of how to create a simple API endpoint for text generation:

from fastapi import FastAPI, BackgroundTasks from pydantic import BaseModel from openai import AsyncOpenAI app = FastAPI() client = AsyncOpenAI() class GenerationRequest(BaseModel): prompt: str class GenerationResponse(BaseModel): generated_text: str @app.post("/generate", response_model=GenerationResponse) async def generate_text(request: GenerationRequest, background_tasks: BackgroundTasks): response = await client.chat.completions.create( model="gpt-3.5-turbo", messages=["role": "user", "content": request.prompt] ) generated_text = response.choices[0].message.content # Simulate some post-processing in the background background_tasks.add_task(log_generation, request.prompt, generated_text) return GenerationResponse(generated_text=generated_text) async def log_generation(prompt: str, generated_text: str): # Simulate logging or additional processing await asyncio.sleep(2) print(f"Logged: Prompt 'prompt' generated text of length len(generated_text)") if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)

This FastAPI application creates an endpoint /generate that accepts a prompt and returns generated text. It also demonstrates how to use background tasks for additional processing without blocking the response.

Best Practices and Common Pitfalls

As you work with async LLM APIs, keep these best practices in mind:

Use connection pooling: When making multiple requests, reuse connections to reduce overhead.

Implement proper error handling: Always account for network issues, API errors, and unexpected responses.

Respect rate limits: Use semaphores or other concurrency control mechanisms to avoid overwhelming the API.

Monitor and log: Implement comprehensive logging to track performance and identify issues.

Use streaming for long-form content: It improves user experience and allows for early processing of partial results.

[robomad]

Building Real-Time Notifications with Django Channels: A Step-by-Step Guide

Introduction:In today’s dynamic web applications, real-time features such as notifications, chat, and live updates have become increasingly important to enhance user engagement and experience. Django Channels extends Django to handle WebSockets, allowing you to build real-time applications. By integrating Django Channels into your project, you can implement real-time notifications that alert…

[justnshalom]

JavaScript: Find Intersection

JavaScript: Find Intersection In JavaScript, finding the intersection of two arrays is a common programming task. The intersection is the set of elements that are present in both arrays. There are several ways to accomplish this in JavaScript, depending on the specific requirements and constraints of your project. Method 1: Using a loop One of the simplest approaches to find the intersection is…

[nerdyqueerr]

Outsourcing academic decisions to tumblr dot com

Further context for each course:

"Weird Fiction" is an English course that will have me reading and annotating tons of short stories. Reading reviews + syllabus online has led me to believe that the prof is strict as hell and not very generous. However if I do ok on the midterm I get to write a short story instead of a final exam. Online synchronous.

"Religon and the body" is a new religion course which is about. Well. Religion and the body, whether that's death rituals, food purity codes, sexuality, etc. Reviews of the prof seem to say she's flexible but the course has also never been taught before so who knows if the content and evaluation format will work for me. Online asynchronous.

[general-george-washington]

only class I am able to take for the summer courses is completely asynchronous

That might as well be an independent study.

[techcronus]

Node.js Development: Everything You Need to Know in 2025

In 2025, Node.js development continues to be a powerful tool for building efficient, scalable, and real-time applications. This backend JavaScript framework has become a go-to technology for backend development, favoured by developers for its speed, flexibility, and vast ecosystem. Here’s everything you need to know about Node.js development trends, advantages, and key considerations in 2025.

Why Node.js Remains Popular in 2025

Node.js has gained a strong foothold in web and app development due to its high performance and ability to handle large volumes of simultaneous requests, making it ideal for data-intensive applications. Its non-blocking, event-driven architecture allows developers to build scalable web applications that can easily support thousands of concurrent users.

Key Node.js Trends to Watch in 2025

Serverless Architecture: Serverless is growing in popularity, and Node.js serverless applications fit perfectly with this trend. In a serverless environment, developers don’t need to manage server infrastructure; they focus instead on writing code. This approach can reduce development costs and improve scalability, making Node.js a key player in the serverless computing market.

Edge Computing: As demand for faster data processing rises, Node.js for edge computing is becoming crucial. By enabling data processing closer to the data source, Node.js helps reduce latency and improve application performance, particularly in real-time applications.

Microservices Architecture: Microservices are essential for large-scale, modular applications. Node.js, with its lightweight nature, is perfect for Node.js microservices architecture, allowing developers to build small, independent services that can be deployed and scaled individually.

Artificial Intelligence (AI) and Machine Learning (ML) Integration: In 2025, integrating AI and ML models into applications is a significant trend. Node.js with AI and ML is compatible with powerful machine-learning libraries, making it an attractive choice for developers looking to create intelligent applications.

Benefits of Using Node.js in 2025

High Performance: Node.js uses the V8 engine, offering impressive speed and efficient execution of JavaScript. This makes it suitable for applications requiring fast response times, such as real-time applications, chat applications, and IoT devices.

Rich Ecosystem: The Node.js ecosystem, including npm (Node Package Manager), gives developers access to a wide range of reusable modules and libraries. This Node.js ecosystem reduces development time and helps accelerate project timelines.

Cross-Platform Compatibility: Node.js Development cross-platform applications work well across different platforms, making it easier for developers to build applications that run seamlessly on various operating systems.

Scalability: The non-blocking, asynchronous architecture of Node.js for scalable applications makes it easy to scale horizontally, supporting increased workloads as businesses grow.

Best Practices for Node.js Development in 2025

Leverage TypeScript: Using TypeScript with Node.js enhances code quality and reduces bugs, making it a valuable addition to any development project.

Prioritize Security: Security is a primary concern for developers, particularly in 2025, as cyber threats grow more sophisticated. Implementing Node.js security best practices, like input validation and rate limiting, is essential for protecting applications.

Adopt CI/CD Pipelines: Continuous integration and continuous deployment (CI/CD) pipelines streamline development and ensure faster, more reliable Node.js deployments.

Conclusion

Node.js continues to be a versatile and high-performance choice for backend development in 2025. Its adaptability to trends like serverless architecture, microservices, and AI integration makes it a prime technology for building future-ready applications. By leveraging the power of Node.js developers, businesses can develop scalable, efficient, and intelligent solutions to stay ahead in the digital landscape.

[mosh2viss]

https://www.futureelectronics.com/p/semiconductors--memory--RAM--static-ram--asynchronous/cy62157ev18ll-55bvxi-infineon-3728565

SRAM memory cell, Types of SRAM, data Memory, memory card reader

CY62157EV18 Series 8 Mb (512 K x 16) 1.65 - 2.25 V 55 ns Static RAM - VFBGA-48

[abr2tello]

https://www.futureelectronics.com/p/semiconductors--memory--RAM--static-ram--asynchronous/cy62167ev30ll-45bvxi-infineon-6042923

Non-Volatile SRAM memory, Non-Volatile SRAM, Non volatile memory

CY62167EV30 Series 16 Mb (1M x 16/2M x 8) 2.2 - 3.6 V 45 ns Static RAM -TSOP-48

[bbob2reaa]

https://www.futureelectronics.com/p/semiconductors--memory--RAM--static-ram--asynchronous/cy62167ev30ll-45bvxit-infineon-1068579

Non Volatile SRAM memory, What is SRAM, SRAM manufacturers, SRAM chip

CY62167EV30 Series 16 Mb (1M x 16 / 2 M x 8) 3 V 45 ns Static RAM - FBGA-48

[robomad]

Mastering Advanced Error Handling Techniques in Node.js Applications

Introduction:Error handling is a critical aspect of building robust Node.js applications. While Node.js provides basic error handling mechanisms, complex applications require more sophisticated techniques to ensure errors are caught, logged, and handled gracefully. Effective error handling not only improves the reliability of your application but also enhances the user experience by providing…

[arg0t]

i hate asynchronous classes so much jesus christ i cannot do another discussion post

[terrorcamp]

Terror Camp is hiring!

We are looking to expand our volunteer staff for this year’s conference.

We have two job listings based on our current needs, but if we receive a lot of great applicants there is the possibility we’ll split up these responsibilities into 3 or even 4 separate positions.

Terror Camp is a fully volunteer, remote, asynchronous workplace (with occasional sync meetings as schedules permit). We communicate over Discord and organize our documentation over Notion and Google Drive.

We are looking for people who can devote up to a few hours a week, depending on the time of year. Commitment increases around the times of Submission Opening (June 1), Submission Closing/Acceptances (September 1-Oct 1) and the conference itself (early December).

Terror Camp looks great on your resume. You can say that you volunteer for a successful community-led online history & heritage conference with an audience in the thousands!

You don’t need to match the job descriptions perfectly in order to apply. If your experience doesn’t match up but you think you’d still be good at the job, please apply anyway!

Here are the positions we're looking to fill:

🎨 Designer 🎨

Terror Camp is seeking a dedicated Designer who will:

Ideate and deliver a new evergreen brand identity for TC that can be revamped and reused each year

Including logo, logotype, color scheme, font families, and other brand assets for use on web, social media, and printed merch

Be an proactive team member with strong communication skills, able to quickly and regularly deliver new graphics for promotional use on social media and in email marketing

Help design an evergreen/permanent collection of merchandise as well as a limited-edition collection for this year’s conference

Assist our Webmaster in revising our website & email marketing templates to fully match new brand identity and meet best practices for UX

Potentially work on print layout for a Terror Camp book or zine (TBD)

This job would be a good fit if you:

Work or have worked professionally or semi-professionally as a graphic designer; or are a hobbyist designer with a standout portfolio

Have experience working with both digital and print assets

Have a working knowledge of web design best practices and HTML/CSS

Have experience with Photoshop, Illustrator, InDesign, Canva (but not ONLY Canva, sorry) and Wix or similar WYSIWYG ESP/site builder

The Designer will report to our Assistant Director/Webmaster, & will also collaborate closely with our Marketing Lead on graphic assets for social media and with our Merch Lead on preparing designs for print.

To apply, please fill out this form.

💬 Communications Coordinator 💬

Terror Camp is seeking an enthusiastic Communications Coordinator who will:

Own Terror Camp’s main email inbox and oversee all direct communication with attendees and interested parties

Respond promptly to inquiries including:

Requests for past recordings

Requests to join the Discord

Questions about schedule, programming, submissions, guests, and other conference topics

Catch inbounds to social media inboxes (Tumblr, X, Bluesky, Insta) & answer or redirect to email as appropriate

Act as coordinator/assistant for Marketing Lead, with responsibilities including:

Scheduling pre-written content

Assisting with ideating and drafting content, proposing content ideas

Cross-posting content to multiple platforms

Consistently and frequently engaging with social audiences (finding content to repost, replying to people, etc)

This job would be a good fit if you:

Work or have worked in any digital customer-facing environment; have experience with support tickets and/or ongoing user communications; have run social media for brands or institutions; are an efficient and clear writer able to work creatively within brand voice guidelines

Have successfully and sustainably moderated Discord servers, Tumblr communities, social media for other fandom projects like fests, zines, and charity events

Can spare the time and attention to respond to inquiries and turn around new social media posts in a timely manner

Are prepared to represent the Terror Camp brand professionally and maturely in digital public spaces

The Communications Coordinator will report directly to our Marketing Lead.

To apply, please fill out this form.

If you have any questions about these positions, please email us at command [at] terror [dot] camp!

[removeload-academy]

C# Asynchronous Programming Examples – Learn with Removeload

Explore C# asynchronous programming examples with easy-to-understand tutorials from Removeload. Learn how to use async and await effectively to write non-blocking, high-performance applications. Start mastering C# asynchronous programming Removeload today!

[youkissedareaderinthedark]

Do it All

Synopsis: You are a Formula 1 driver trying to graduate from college. It’s hard to do it all, but the grid helps you do some of it

young female mercedes driver reader x 2033 F1 grid

(george is at williams with alex, logan is the reserve)

Education has always been something important to you. Your parents raised you to be a good student and that’s what you turned out to be. You were always one of the “smart kids” and didn’t mind going to school day after day, year after year. People usually get confused when you tell them this because you don’t meet many scholarly Formula 1 drivers, but here you are.

Your life was always split between racing and school; You remember doing homework sheets at karting tracks, writing essays between media duties in F2, and rushing through assigned readings in airports. It was stressful, but the work for each always paid off.

You’ve made your way through the Mercedes Junior Program, Formula 3, Formula 2, and was recruited in 2022 by Toto Wolff to race in Formula 1. You were 18 at the time, but too good an opportunity to pass up, so he offered you a three-year racing contract at Mercedes, starting in the 2023 season. You were over-the-moon excited about the opportunity, but it didn’t stop you from wondering about college.

You knew it wasn’t necessary, very few drivers went to university, but that didn’t stop you from wanting to attend. College had been in your vision for ages, you couldn’t just not go. The real problem was that Toto had approached you in August to race for Mercedes, and you had already gotten into your first-choice school and was days away from traveling there to set up your dorm.

You thought about your options. There was no way you could turn down Toto’s offer to join his F1 team, but there was also no way you go away to college and drive for Mercedes. One of your passions had to be pushed aside, and it wasn’t going to be racing.

So instead of traveling to your chosen college to settle into your dorm, you were traveling there to have various meetings about your future at that school.

After talking with the head of the university and a few professors, you compromised with the idea of online education. You would use online textbooks and the resources your professors posted onto the class’s website to complete all your assignments and participate in the lessons. You would be held to all the same expectations as the other students and would get your degree and diploma at the end of all of it, just not traditionally.

You agree that your schedule will be asynchronous (completely independent, you’ll make up your own schedule and do the work on your own time) to match your incoming lifestyle and discuss some other minor details. You leave what would’ve been your campus saddened and already a bit stressed, but nonetheless prepared.

You spent the rest of 2022 getting used to online school again and training on the sim to prepare for the day you leave for England. Because the Mercedes headquarters was in the UK, you were renting an apartment to call “home base” there with one of your friends that was attending a university in England.

You probably should’ve been more nervous on your first day at the office, but you weren’t. You’ve been in the junior program since you were 13, you’ve met Toto multiple times, and Lewis had been named your mentor long ago. Whenever you two were in the same country, he always made an effort to watch your races and help you improve in whatever ways he could.

You also were familiar with a couple of the drivers on the grid already. Despite the age gap, you had raced alongside Lando, George, Alex for years and had encountered Charles, Pierre, and Esteban a few times as well. You were in F2 with Oscar and Logan for a bit and formed a quick friendship with both of them. Because of these connections, by the Spanish Grand Prix, you were quite friendly with almost all 19 drivers.

And by the Spanish Grand Prix, almost all 19 drivers also knew that you were completely stressed about your schoolwork. They all knew you were a college student and had a lot of respect for you for it, especially during exam season. Even though you were majoring in mechanical engineering and were around cars almost every day, you were overwhelmed with anxiety.

It was impossible to ignore; if you walked into the Mercedes hospitality or garage, it wouldn’t be uncommon to see you sitting at a table, on a couch, or sitting in an empty hallway with your laptop in front of you and your focus captured. Your state of mind didn’t majorly affect your racing, you made sure of it, but it did affect your personality, and because they were your friends, the drivers decided to help you as much as possible.

Because Lewis is around you the most, he makes sure you’re taking proper care of yourself. When he finds you studying in your driver’s room or working in the hospitalty in between duties, he makes sure you’ve eaten and have a water bottle by your side. If you haven’t, he’ll run to buy your favorite snack and beverage for you and drop them off with a few words of encouragement.

Lando, George, and Alex make sure you don’t drown yourself with work. If everyone’s at home and they’re aware you’ve been working for a few hours, they’ll text you asking to join them in a video game as a stress reliever. They keep you occupied for a few hours and fill the time with updates about their own lives and their own friendly banter.

They worry about you when they have breaks from racing and don’t hear from you for days at a time, then return with tired eyes and a quiet persona. Sometimes they’ll facetime you and don’t hang up for hours to make sure you cook yourself a fresh meal and fall asleep at a decent time.

Oscar and Logan are the most common visitors to your driver’s room and hotel rooms, and they make sure you actually see the countries you travel to. They’ve showed up to your hotel room randomly a few times and just told you to hurry up and get ready.

These visits always end up with the three of you in a cool, new place where you’re free to talk as much as you want and laugh as loudly as you’d like. They don’t live in the UK with you but the three of you are together so often you barely even notice.

Charles, Pierre, and Esteban make sure you enjoy everything you’re doing. They know how stressful being a young rookie can be, and they can only imagine what you’re going through as a university student, and the three of them don’t want your young adult years to be filled with just work and stress.

They try to help you study; Charles quizzes you on different subjects, if you chose French as your language, Esteban would give you answers, and if you need a distraction, Pierre is by your side trying to make you laugh.

You’re a little more laid-back when you finally submit your exams, but you don’t completely relax until you know your scores. You get good marks on all of your tests and are relieved when you discover all your hard work has pulled off.

Lewis is the first person you tell, and he matches your excitement completely. When you burst into his driver’s room and tell him your results, he brings you into a hug and leaves a kiss on the top of your head. “I knew you could do it, Y/n, I’m so proud of you” Lewis is one of the few Formula 1 drivers that did attend college so he knows first-hand how difficult it can be.

George, Alex, and Lando are almost as relieved as you are when you tell them your grades. The three of them are glad to have their friend back and hope the year until your next final exams comes slowly.

Oscar and Logan take you out to celebrate the night you tell them. You guys walk around town with ice cream as a reward and go to an amusement park with the bright idea for you to “scream out your frustrations from the last few weeks” Surprisingly, it works and by the end of the night, you feel lighter than you have all semester.

The bottom-line is, the drivers care about you and can’t wait to see your smile again after every exam season.

a short little student reader fic because I love the concept, I’m just not too sure how to write it

hope you love it tho 🫶