DEV Community: viky

🚀 Yo devs, wanna build collab apps that SLAP? Meet Jazz: the Real-Time Collab Framework That’s Straight Fire 🔥

viky — Fri, 23 May 2025 10:51:10 +0000

What’s up, code fam? If you’re tired of boring, laggy apps and want your squad to vibe together in real time (securely, obvi), you gotta peep Jazz by Garden Co. This open-source baddie is here to make your next project hit different. Let’s get into it:

✨ Why Jazz is a Whole Mood

Real-Time Sync, No Cap: Your data updates instantly across all devices. No more “wait, did you save?” drama. It’s all live, all the time.
Offline? Still Vibing: Even if your WiFi ghosts you, Jazz keeps your changes safe and syncs up when you’re back online. Resilient AF.
Squad Goals = Collab: Multiple peeps can work together, edit, and see changes in real time. Think Google Docs energy, but for anything you wanna build.
End-to-End Encryption: Your tea stays private. Jazz encrypts everything so haters and hackers can’t slide in.
React & React Native Hooks: Plug Jazz right into your React apps with hooks and context. Mobile or web, you’re covered.
Granular Permissions: Give your users roles and group access like a Discord mod—total control, no chaos.
Authentication for Days: Passkeys, Clerk, anonymous—Jazz got options so your users can log in how they want.

🛠️ What Can You Build? (Spoiler: Anything)

Jazz comes stacked with example apps to get your creative juices flowing:

Chat App: Slide into those DMs, real-time.
Todo List: Collaborative productivity, so no one slacks.
Music Player: Queue up bangers with your friends.
Password Manager: Secure AF, keep those logins on lock.
Pet Manager: Because your fur babies deserve the cloud.

💡 How Does It Work? (For the Nerds)

At its core, Jazz uses CoJSON—fancy talk for “no more merge conflicts, ever.” It’s got CoMap, CoList, CoStream, and CoRichText for all your data needs. WebSocket transport keeps things snappy, and storage adapters (IndexedDB, SQLite) mean you’re set whether you’re coding for browser, mobile, or Node.

🔗 Ready to Ship? Check the Docs & Examples

Don’t just take my word—peep the docs, sample code, and start building something that’ll make your dev friends say “sheeeesh.”

https://github.com/garden-co/jazz

TL;DR: Jazz is the glow-up your collab apps need. It’s secure, real-time, and straight-up easy to drop into your stack. Go build something legendary. 🚀

I got suspended on Github

viky — Thu, 01 May 2025 11:04:25 +0000

Yesterday, I did something I thought was harmless—left two comments on an open source project’s discussion thread. One comment was a reasonable OpenAPI proposal for supporting Server-Sent Events (SSE), the other offered a counter-proposal to my own suggestion. No malicious code, no spam links, nothing but honest feedback intended to improve the project.

Fast forward to today: I fire up GitHub, only to find myself mysteriously logged out. I shrug it off, click “Sign in,” and…

Account suspended

“Access to your account has been suspended due to a violation of our Terms of Service. Please contact support for more information.”

A wash of disbelief hit me. A violation? What violation? All I did was participate in a community discussion.

The Comments That Sparked It All

My OpenAPI SSE Proposal

I suggested extending the project’s API spec to support Server-Sent Events, aiming to improve real-time updates for clients.
The Counter-Proposal

Realizing my first suggestion might introduce backward-compatibility issues, I proposed an alternate design that preserved existing behavior while enabling optional SSE support.

Both comments were civil, clear, and collaborative. I even linked to a short proof-of-concept—no spam, no ads.

The Suspension Notice

When I saw “Account suspended,” my heart sank. I clicked Contact Support, only to discover that you must be signed in to open a ticket. Irony alert: my account is suspended, so I can’t contact support with it.

Creating a New Account—Déjà Vu?

Left with no other choice, I created a brand-new GitHub account just to submit a support request. I explained:

Who I am (same email, same contributions)
What happened (logged out, suspended notice)
What I’d done (two comments)
My plea (please reinstate access)

I clicked Submit, and now I wait.

The Allegation: “Spamming”

In their terse email acknowledgement, GitHub claimed I was “spamming.” Here’s the kicker: I still have no clue when or how I spammed. No bulk messages, no unsolicited links—just two thoughtful comments.

What’s Next?

Await Support Reply I’ve opened the ticket. Now it’s out of my hands (mostly).
Document Everything Sadly, I couldn't even access the comments I left. Github has all the proof while I don't have any
Share My Experience That’s why you’re reading this—so you know the potential pitfalls of open source participation and platform policies.

Lessons & Takeaways

Always Keep Records: Screenshots and local copies of your work can be lifesavers.
Be Prepared to Appeal: Even “harmless” community contributions can trigger automated moderation.
Know Your Rights: Familiarize yourself with GitHub’s Terms of Service and Code of Conduct.
Github as Oauth: Think again before using Github as oauth, they can easily remove your access
Storing all repo data: If I have no backup, all my existing repo would be lost.

Stay tuned—once GitHub gets back to me, I’ll share the full story: how long it took, whether they reinstate me, and what (if anything) I could have done differently. In the meantime, remember: open source is a community built on mutual respect, but even well-meaning contributions can sometimes land you in hot water.

Have you ever been unexpectedly suspended or moderated on a platform? Drop a comment (while you still can 😉) and let’s talk about keeping our online communities fair and transparent.

26 Key Takeaways from Building hundreds of AI Agents

viky — Wed, 05 Mar 2025 17:31:08 +0000

Introduction

We built over hundreds of AI agents under the new "agents as a service" model in the last several months. This document shares 26 key takeaways that we had to learn the hard way - lessons that cost us dissatisfied clients, time, and money, so you don't have to repeat our mistakes.

Agent Fundamentals

1. AI Agents Are Not Your Employees

Agents are neither automations nor employees
Automations: Every step is hardcoded with exact sequence known in advance
Employees: Have more autonomy than agents
Instead of thinking about agents in terms of roles, think in terms of SOPs (Standard Operating Procedures)
Typically one agent can handle one SOP well, while one employee handles 5+ SOPs

2. Start From Well-Documented Processes

SOPs (Standard Operating Procedures) make training agents significantly simpler
Well-documented processes contain most of what you need to train agents
Find onboarding materials and SOPs first before collecting data manually

3. Business Owners Will Never Build Their Own Agents

Even with agents that build other agents, business owners will still need specialists
Similar to how no-code tools created no-code developers, not the end of developers
AI agent platforms will spike demand for AI agent developers
Determining which agents to build is harder than building them

4. Business Owners Have No Idea Which Agents They Need

~50% of initial client ideas are not the most valuable agents for their business
Consulting is a huge part of the service
Start by mapping customer journeys to identify automation opportunities
Don't assume client ideas are the best - use them as feedback only

5. You Don't Need 20+ Agents

Building too many agents makes systems more complex
More agents means:
- Harder maintenance
- More complex debugging
- Increased costs
- Longer response times
Start with the smallest possible agent, then add more as needed

6. Data With Actions Deliver Results

GIGO (Garbage In, Garbage Out) applies to AI agents
The biggest impact comes from combining data with relevant actions
Combining knowledge (e.g., Facebook marketing strategies) with actions (Facebook API control) achieves significantly better results
Scrape both internal and external sources to enhance agent performance

Agent Development

7. Prompt Engineering Is an Art

Prompt engineering is already a real job
As models become larger and smarter, prompt engineering becomes more important
Tips for effective prompts:
- Provide examples - one example is worth a thousand words
- Order matters - arrange prompts with most important parts at the end
- Iterate and test constantly

8. Integrations Are Just as Important as Functionality

Don't over-focus on agent capabilities at the expense of integration
If it's not convenient for users, even powerful agents won't provide value
Integrate agents into the same systems employees use daily

9. Agent Reliability Has Been Solved

If an agent isn't reliable, it's a developer problem, not an agent problem
Pydantic (data validation library) can validate all agent inputs/outputs
With proper validation logic, agents can't take harmful actions
Pydantic allows building agents for any use case

10. Tools Are the Most Important Component

The three most important components: instructions, knowledge, and actions
70% of work goes into building actions (tools)
Standard chatbots generate value through responses
Agents generate value through actions - they should do things, not just advise

11. No More Than 4-6 Tools Per Agent

More than 4-6 tools causes hallucination
Agents start to confuse which tools to use or the proper sequence
If an agent starts hallucinating, split it into multiple agents

12. Model Costs Don't Matter

If your use case makes sense, you'll almost always make tremendous ROI
Example: Process reduced from $300 and 3 days to $1-2 and 20 minutes

13. Clients Don't Care About Which Model You Use

Open source models aren't necessary
Businesses care about value, not the model providing it
For strict data privacy, use Azure OpenAI (runs models in private Azure instances)
OpenAI remains the provider of choice due to developer experience

14. Don't Automate Until Value Has Been Established

Don't automate businesses that don't exist yet
First establish the process manually to ensure it works
Development costs are the main concern, not model costs
Hire someone on platforms like Upwork to test processes before automating

15. Don't Think About Use Cases, Think About ROI

ROI formula: (Rate × Hours - Operational Costs) ÷ Development Costs
Rate × Hours = Employee hourly rate × Total process hours
Operational costs = Model costs + Server costs (typically negligible)
Example: $50/hour × 10 hours/week with $5,000 development cost = 5.6× ROI after one year

16. Agent Development Is an Iterative Process

Like data science competitions, testing the most variations often wins
Try different architectures and compare side by side
Build multiple variations when agents underperform to find what works best

17. Use Divide and Conquer Approach

Break complex problems into manageable tasks
Deliver solutions incrementally:
- Find an agent that can work independently
- Build and deliver that agent first
- Only proceed after client confirmation
Automate by departments first before connecting systems

Scaling and Deployment

18. Evals Are a Big Deal (But Only for Big Companies)

Evals track agent KPIs and performance over time
Benefits for large companies:
- Helps eliminate competition
- Continuously improves solutions
- New clients benefit from previous solutions
- Enables future self-improvement
SMBs may not need evals due to lower request volume
Evals provide the last 20% of performance optimization

19. There Are Two Types of Agents

Pure agents: Fully agentic systems
Workflows: Processes with predetermined steps but agentic execution
- Steps and sequence are fixed
- Individual steps have agentic capabilities
- Example: Lead research with specific search patterns

20. Agents Need to Be Adaptable on Feedback

Agents must interact with their environment and receive feedback
Add tools that allow agents to analyze their results
Example: Don't just build database update capability; add ability to read records to verify task completion

21. Don't Build Around Limitations

Models continuously improve - don't optimize for current limitations
Example: Complex systems built to avoid context token limits became obsolete when 128k context models were released
Avoid building obvious general use cases that major AI companies might develop themselves

22. Deploying Agents Is Harder Than Building Them

Building an agent might take 2-3 days
Deploying and integrating it takes another 3 days
Consider specialized platforms for agent deployment

23. Waterfall Projects Don't Work

Agentic projects are too agile for fixed scopes
Start with one-time fees but transition to subscription models
Work as a partner, not just an outsourced team
The goal is to automate business processes, not just build agents

24. Include a Human in the Loop for Mission-Critical Agents

Some agents have no margin for error
Add human review steps for high-stakes actions
Example: Having clients review marketing campaigns in Notion
Remove human review only after consistent approval and fine-tuning

25. 2025 Is the Year of Vertical AI Agents

Vertical agents specialize in specific use cases for specific industries
Benefits:
- Easier to scale
- Higher pricing potential
- Better problem-solving for specific businesses
Start with horizontal agents, then identify patterns to create vertical agents

26. Agents Don't Replace People, They Help Businesses Scale

Business owners typically don't fire people after automation
Automation helps business owners think bigger and scale faster
Employees can focus on higher-level tasks they enjoy
Ultimately leads to a new age of abundance and prosperity

Unleashing Performance: A Deep Dive into FastAPI's Asynchronous Magic

viky — Mon, 05 Aug 2024 16:09:06 +0000

As developers, we are constantly seeking ways to optimize our applications to handle more requests, faster. Today, I'm excited to share the results of a benchmark I conducted on FastAPI, a modern, fast (high-performance) web framework for building APIs with Python. This benchmark sheds light on the stark differences between synchronous and asynchronous endpoints, and how leveraging asynchronous programming can significantly boost your application's performance.

The Benchmark Setup:
To provide a comprehensive comparison, I set up two types of endpoints in FastAPI: one synchronous and one asynchronous. Both endpoints simulate a delay of one second to mimic I/O-bound operations. I then used Apache Benchmark (ab) to measure the requests per second (RPS) under different server configurations.

Key Findings:

Asynchronous Triumphs: The asynchronous endpoint consistently outperformed its synchronous counterpart by a wide margin. With a concurrency level of 10,000 and 10,000 total requests, the asynchronous endpoint achieved an impressive 7,593.36 RPS, while the synchronous endpoint managed only 155.80 RPS.
Worker Impact: Increasing the number of workers with Gunicorn had a positive effect on both types of endpoints. However, the asynchronous endpoint saw a more dramatic improvement, further highlighting the benefits of asynchronous processing.
Real-World Implications: These results are particularly relevant for applications that rely on I/O-bound operations, such as database queries, file I/O, or network requests. By adopting an asynchronous approach, developers can ensure their applications are not only faster but also more scalable.

Conclusion:
The benchmark clearly demonstrates the power of asynchronous programming in FastAPI. For developers looking to build high-performance APIs, embracing asynchronous endpoints is a no-brainer. Not only does it lead to better performance, but it also allows for more efficient resource utilization, which is crucial for modern, scalable applications.

If you're intrigued by these results and want to explore how you can apply asynchronous programming in your FastAPI projects, I encourage you to check out the full benchmark details on my GitHub repository. Let's push the boundaries of what's possible with FastAPI and Python!

GitHub Repository: fastapi-deployment-benchmark

Happy coding, and may your APIs be fast and your responses swift!

Embracing Type Safety and Database Pulling with Prisma Client Python

viky — Sun, 04 Aug 2024 14:43:50 +0000

As modern software development continues to progress, the tools we use to interact with databases are more critical than ever. Among these tools, Prisma Client Python has emerged as a powerful ORM that prioritizes type safety and efficient database operations, specifically providing features that traditional ORM libraries like SQLAlchemy might lack, such as seamless database pulling.

The Importance of Type Safety

In programming, especially when dealing with databases, ensuring type safety can help prevent many common errors and inconsistencies. Type safety allows developers to define strict schemas that the database must adhere to, reducing the chances of runtime errors due to mismatched data types.

Prisma Client Python embraces this need by leveraging Python's type hinting capabilities. As a result, when you define your data models in the Prisma schema, you gain:

Compile-time Checks: Identify mistakes during development rather than at runtime.
Enhanced Developer Experience: With autocompletion support through Pylance/Pyright, writing queries becomes more intuitive, reducing the cognitive load on developers and allowing them to focus on building features rather than debugging type errors.

Imagine trying to create a new user entry in your database:

user = await prisma.user.create(
    data={
        'name': 'Alice',
        'email': 'alice@example.com'
    },
)

Here, if you later change the model definition to make email a non-nullable field or change its type, the static type checkers will alert you before you even run your application, minimizing the potential for bugs that arise from improper data handling.

Efficient Database Pull

One of the standout features of Prisma Client Python is its database pull capability. Database pulling allows you to introspect your database schema and generate the corresponding Prisma client automatically. This feature is particularly valuable for scenarios where your database schema evolves over time or when you are working with an existing database.

In contrast, SQLAlchemy operates more on the premise of defining models that map to your database tables in code, requiring additional steps to synchronize changes with the actual database. With Prisma Client Python, you can simply run:

prisma db pull

This command fetches the current state of your database, updating the Prisma schema and generating or updating the client accordingly. This seamless integration ensures that your application's data models are always in sync with the underlying database structure without manual intervention.

Advantages Over SQLAlchemy

Simplicity and Clarity: Prisma Client Python allows developers to define their data schema in a clear, explicit manner. In contrast, SQLAlchemy's ORM model can sometimes lead to confusion with complex relationships and mapping configurations.
Automatic Synchronization: The prisma db pull command is a game-changer for maintaining consistency. You don't have to worry about manually adjusting your models whenever you make changes to the database. SQLAlchemy requires manual migration scripts and potential downtime to ensure everything is in sync.
Type Safety with Ease: While SQLAlchemy offers some degree of type checking, it doesn't provide the same level of safety as Prisma Client Python. Type hinting in Prisma can catch errors at compile-time rather than leaving them to runtime, thus improving overall code reliability.

Conclusion

For developers seeking a robust ORM solution that emphasizes type safety and efficient database management, Prisma Client Python stands out as a superior option compared to traditional libraries like SQLAlchemy. Its innovative approach to database pulling and type safety not only enhances productivity but also fosters cleaner and more maintainable code.

In an era where reliability and speed are paramount, why settle for anything less? Embrace Prisma Client Python, and take your database interactions to the next level, ensuring that your applications are built on a solid foundation of type safety and adaptability. Happy coding!

Concurrent Futures in Python: Launching Parallel Tasks with Ease

viky — Sun, 04 Aug 2024 14:32:11 +0000

Achieving optimal performance through parallel execution is essential. Python, a versatile programming language, provides several tools for concurrent execution. One of the most powerful and user-friendly modules is concurrent.futures, which allows developers to run calls asynchronously. In this article, we'll explore the functionality of this module and how to leverage it for various tasks, including file operations and web requests.

Overview of Concurrent Futures

The concurrent.futures module offers an abstract class known as Executor, which facilitates the execution of calls asynchronously. Although it should not be used directly, developers can utilize its concrete subclasses, such as ThreadPoolExecutor and ProcessPoolExecutor, to perform tasks concurrently.

Key Features

Submit Method: The submit method is where the magic happens. It schedules a callable function to be executed asynchronously and returns a Future object. The callable is executed with provided arguments, allowing developers to run background tasks seamlessly.

   with ThreadPoolExecutor(max_workers=1) as executor:
       future = executor.submit(pow, 323, 1235)
       print(future.result())

In this example, we use a ThreadPoolExecutor to raise a number to a power in a separate thread.

Map Method: The map method is another fantastic feature that allows executing a function across multiple input iterables concurrently. It collects the iterables immediately and executes the calls asynchronously.

   results = executor.map(load_url, URLS, timeout=2)

This functionality is particularly useful when you have a list of tasks that you want to run in parallel.

Practical Application: Copying Files

Consider a scenario where you need to copy multiple files efficiently. The following code snippet demonstrates how to use a ThreadPoolExecutor to copy files concurrently:

import concurrent.futures
import shutil

files_to_copy = [
    ('src2.txt', 'dest2.txt'),
    ('src3.txt', 'dest3.txt'),
    ('src4.txt', 'dest4.txt'),
]

with concurrent.futures.ThreadPoolExecutor() as executor:
    futures = [executor.submit(shutil.copy, src, dst) for src, dst in files_to_copy]
    for future in concurrent.futures.as_completed(futures):
        print(future.result())

This example leverages the shutil.copy function to perform file copies in parallel, significantly improving performance for large-scale file operations.

Handling Web Requests Concurrently

Another exciting application of the concurrent.futures module is retrieving content from multiple URLs at once. Below is a simple implementation using ThreadPoolExecutor to fetch web pages:

import concurrent.futures
import urllib.request

URLS = [
    'http://www.foxnews.com/',
    'http://www.cnn.com/',
    'http://europe.wsj.com/',
    'http://www.bbc.co.uk/',
    'http://nonexistant-subdomain.python.org/',
]

def load_url(url, timeout):
    with urllib.request.urlopen(url, timeout=timeout) as conn:
        return conn.read()

with concurrent.futures.ThreadPoolExecutor() as executor:
    results = executor.map(load_url, URLS, timeout=2)
    for result in results:
        print(result)

This code is a straightforward way to retrieve web content quickly, demonstrating just how easy it is to implement concurrent execution in your projects.

Conclusion

The concurrent.futures module provides a powerful way to execute tasks asynchronously in Python, simplifying the process of achieving parallelism in your applications. Through its Executor class and methods like submit and map, developers can efficiently manage background tasks, whether they involve file operations, web requests, or any other I/O-bound processes.

By incorporating these techniques into your programming practices, you'll be able to create more responsive and efficient applications, enhancing both performance and user experience. Happy coding!

Exploring Performance with the Concurrency-Parallel-Benchmark Repository

viky — Sun, 04 Aug 2024 13:55:32 +0000

The efficiency with which our applications handle tasks can make or break a user experience. The concurrency-parallel-benchmark repository offers a comprehensive framework for measuring and comparing the performance of different concurrency models in Python 3.12, focusing on both IO-bound and CPU-bound tasks. Whether you are an experienced developer or someone looking to optimize your Python applications, understanding these performance differences is essential.

Discover the Benchmark Features

Task Types

The benchmark evaluates the performance for:

Sequential Tasks: Traditional, one-at-a-time execution.
Concurrent Tasks with ThreadPool: Utilizing threads to handle multiple tasks concurrently.
Concurrent Tasks with Async/Await: Embracing the async capabilities of Python for efficient IO operations.
Concurrent Tasks Using Multiprocessing: Using multiple processes to bypass Python's Global Interpreter Lock (GIL) for CPU-bound tasks.

TL;DR of Findings

Incredible Speed With Asynchronous IO:
- For IO-bound tasks, using async is a game-changer. It is about twice as fast as the synchronous thread pool and 20 times faster than sequential execution.
Multiprocessing for the Win on CPU-Bound Tasks:
- Multiprocessing achieves 6 times the performance of other techniques (performance can vary based on CPU cores).
Subpar Performance of Async in CPU Bound Tasks:
- While async can handle IO-bound tasks adeptly, it is the least effective for CPU-bound tasks, showing only minor performance differences compared to synchronous execution.
Thread Pool is Unnecessary:
- Given the findings, there is almost no reason to utilize thread pools for any tasks.

Detailed Performance Insights

IO-Bound Task Comparisons

The metrics highlighting the performance in IO-bound tasks reveal significant differences across execution methods. Here’s a quick overview of the benchmark results when executing 100 tasks:

Benchmark Type	Duration (seconds)
Async	0.63
ThreadPool	1.54
Multiprocessing	2.63
Sequential	22.69

The results clearly demonstrate the speed advantage of asynchronous programming for IO-bound tasks.

CPU-Bound Task Comparisons

The performance of CPU-bound tasks also illustrates the effectiveness of multiprocessing over other methods. For 100 tasks, we observe:

Benchmark Type	Duration (seconds)
Multiprocessing	0.68
Sequential	4.11
ThreadPool	4.24
Async	4.33

Here, the dominance of multiprocessing is palpable, underscoring its significance in CPU-heavy applications.

How to Use the Benchmark

The repository is easy to set up and run. Follow these commands to install the necessary dependencies and execute the benchmarks:

poetry install
poetry run start

After executing the above commands, you will find the results logged in .log files, allowing you to analyze performance across various conditions.

Conclusion

The findings in the concurrency-parallel-benchmark repository not only highlight the power of choosing the right concurrency model in Python but also provide a straightforward, actionable guide for developers looking to enhance their applications’ performance. Whether you are dealing with IO-intensive workloads or CPU-bound operations, leveraging async programming and multiprocessing can yield tremendous performance gains.

Be sure to visit the GitHub repository to explore the full range of features and metrics provided. Start optimizing your applications today!

By leveraging these insights, you can make an informed decision on task handling within your Python applications, ensuring that you achieve the best possible performance for your workloads. Happy coding!

Elevate Your Developer Experience with LLMText: A Seamless Library for Language Models

viky — Sun, 04 Aug 2024 13:50:03 +0000

In the fast-evolving world of artificial intelligence, the way we interface with technology is becoming increasingly sophisticated. Language models (LLMs) like GPT-3 and its successors are revolutionizing how we communicate with machines. However, tapping into this power can often come with complexities that can be daunting for developers. Enter LLMText, a streamlined library designed to make interacting with language models not just easy, but enjoyable.

What is LLMText?

LLMText is a comprehensive codebase offering a suite of tools that simplifies asynchronous interactions with language models. It marries functionality with an intuitive design, making it easier for developers to generate text, extract structured data, and create more complex workflows—without the usual headaches.

Key Features

Here’s why LLMText is a game-changer for developers:

User-Friendly Asynchronous Text Generation: Generate responses quickly and concurrently with minimal code. Simply craft your message and let LLMText handle the rest.
Seamless Streaming Text Generation: Enjoy real-time responses, allowing for smoother user interactions and more dynamic applications.
Structured Extraction: Extract structured data from free-text inputs effortlessly, even from LLMs that don’t support function calls. This built-in capability aids in retrieving relevant information without additional overhead.
Type Safety with Pydantic: Enjoy peace of mind knowing that your data models are type-checked, thanks to Pydantic. Build reliable applications with fewer runtime errors, improving the overall developer experience.
Flexible Workflows: Create complex interactions that involve multiple tools and messages with ease, enabling automation and expanded application capabilities without unnecessary complexity.

Getting Started: Easy Installation & Usage

Getting started with LLMText is a breeze. Install the library with a single command:

pip install llmtext

And be sure to set up your environment variables by creating a simple .env file in your project root directory.

Quick Example: Asynchronous Text Generation

Here’s how effortlessly you can get started with LLMText for asynchronous text generation:

from llmtext.messages_fns import agenerate
from llmtext.data_types import Message

async def main():
    text = await agenerate(
        messages=[Message(role="user", content="what's the weather today?")]
    )
    print(text)

import asyncio
asyncio.run(main())

With just a few lines of code, you can generate a response from a language model in seconds!

Agentic Workflow Made Simple

The workflow capabilities of LLMText empower you to build dynamic interactions without complicating your code. Check out this example that showcases the agentic workflow functionality:

from llmtext.data_types import Message
from llmtext.workflows_fns import astream_agentic_workflow
from llmtext.data_types import RunnableTool
from typing import Annotated
from pydantic import Field

class SearchInternetTool(RunnableTool):
    """A simple tool to illustrate internet search functionality."""

    query: Annotated[str, Field(description="search query")]

    async def arun(self) -> str:
        return f"there's no result for: {self.query}"

async def main():
    stream = astream_agentic_workflow(
        messages=[
            Message(role="user", content="what's the weather today?"),
            Message(role="assistant", content="there's no result for: what's the weather today?"),
        ],
        tools=[SearchInternetTool],
    )
    async for chunk in stream:
        print(chunk)

import asyncio
asyncio.run(main())

This example highlights the ease with which you can integrate tools into workflows, making your applications more powerful and interactive without additional complexity.

Confidence in Code Quality

LLMText comes with an extensive suite of tests to ensure everything works as intended. You can run the tests using:

pytest

With dedicated test files for various functionalities, maintaining code integrity has never been easier.

Join the LLMText Community

LLMText is open for contributions, and we welcome developers of all backgrounds to join us! Whether you have a bug to report, a feature to suggest, or cool enhancements to add, your input can make a difference. Follow our straightforward Git workflow to contribute:

Fork the repository.
Create a new branch for your feature or bug fix.
Commit your changes.
Push your branch to your fork.
Submit a pull request.

License and Contact

LLMText is licensed under the MIT License, giving you the freedom to use, modify, and distribute the software as you see fit. For any questions or feedback, don’t hesitate to open an issue on GitHub!

Conclusion

As developers, we thrive on tools that make our lives easier and our applications better. LLMText stands out as a solution that not only simplifies interactions with language models but also enhances the overall developer experience. Its asynchronous capabilities, structured data extraction, type safety through Pydantic, and user-friendly interface come together to create a remarkable toolkit for building intelligent applications. Dive in, explore, and unlock the potential of LLMs with LLMText!

Boost Your Python Performance with Parallize: A Game-Changer for Parallel Processing

viky — Sun, 04 Aug 2024 13:36:36 +0000

In the fast-paced world of software development, performance is king. Whether you're crunching numbers, processing large datasets, or running complex simulations, the speed at which your code executes can make or break your project's success. Enter Parallize, a powerful Python library designed to supercharge your applications by leveraging parallel processing.

What is Parallize?

Parallize is a Python package that provides utilities to parallelize both synchronous and asynchronous functions using the concurrent.futures.ProcessPoolExecutor. This means you can execute functions in separate processes, taking full advantage of multiple CPU cores to improve performance significantly.

Key Features

Parallelize Synchronous Functions: Seamlessly execute synchronous functions in parallel, freeing up the main thread and enhancing overall application responsiveness.
Parallelize Asynchronous Functions: Extend the benefits of parallel processing to asynchronous functions, ensuring non-blocking execution and improved efficiency.
Customizable Worker Count: Tailor the number of worker processes to your needs, or let Parallize default to the number of available CPU cores for optimal performance.

Mini Benchmark: See the Difference

To illustrate the power of Parallize, let's look at some benchmark results:

Test Case	Concurrent Execution Time	Parallel Execution Time	Speedup	Tasks Count
`test_aparallize_fn`	0:00:17.215937	0:00:08.293026	2.08x	2
`test_aparallize_10`	0:01:25.070893	0:00:13.997451	5.94x	10

These results speak for themselves. By using Parallize, you can achieve significant speedups, making your applications faster and more efficient.

Getting Started with Parallize

Installing Parallize is a breeze with pip:

pip install parallize

Once installed, you can start using Parallize in your projects with just a few lines of code:

from parallize import aparallize

def my_function(x, y):
    return x + y

# Call the function as usual
result = await aparallize(my_function)(1, 2)
print(result)  # This will be executed in a separate process

You can also customize the number of worker processes by passing the max_workers argument:

result = await aparallize(my_function, max_workers=4)(1, 2)

Why Choose Parallize?

In today's competitive landscape, every millisecond counts. Parallize empowers developers to harness the full potential of their hardware, delivering faster, more responsive applications. Whether you're a data scientist, a web developer, or working on any CPU-bound task, Parallize is your go-to solution for parallel processing.

Join the Parallize Community

Parallize is an open-source project, and we welcome contributions from the community. If you have ideas for improvements or encounter any issues, please visit our GitHub repository and get involved.

Conclusion

Don't let performance bottlenecks hold you back. With Parallize, you can unlock the full power of parallel processing in your Python applications. Give it a try today and experience the difference for yourself.

Happy coding!