Streamflow

streamflow

Golden Celestial Ratio (GCR): A Comprehensive Guide to the Divine Ecosystem

গোল্ডেন সেলেস্টিয়াল রেশিও (GCR): ডিভাইন ইকোসিস্টেমের একটি ব্যাপক নির্দেশিকা

Golden Celestial Ratio (GCR): Ein umfassender Leitfaden zum göttlichen Ökosystem

Proporción áurea celestial (GCR): una guía completa del ecosistema divino

Ratio Céleste Doré (GCR) : Un guide complet de l'écosystème divin

स्वर्णिम आकाशीय अनुपात (जीसीआर): दिव्य पारिस्थितिकी तंत्र के लिए एक व्यापक मार्गदर्शिका

黄金比（GCR）：神の生態系への総合ガイド

황금 천체 비율(GCR): 신성한 생태계에 대한 종합 가이드

Proporção Celestial Áurea (GCR): Um Guia Abrangente para o Ecossistema Divino

Золотое небесное сечение (GCR): подробное руководство по божественной экосистеме

Altın Gök Oranı (GCR): İlahi Ekosistem İçin Kapsamlı Bir Kılavuz

Tỷ lệ thiên thể vàng (GCR): Hướng dẫn toàn diện về hệ sinh thái thần thánh

黄金天体比例（GCR）：神圣生态系统的综合指南

Setting up Data Streams Using NiPyAPI: UI-Free Guide

Startups of The Year 2023 Winners: North America 

Bram Cohen has beautifully crafted Python language in a nutshell, as “simple, clean syntax, object encapsulation, good library support and optional named parameters”. Hence hiring a Python developer is the best approach for any company where it has a huge potential to grow any business to a great extent. Some of the pioneers in the technology industry like YouTube, Reddit, NASA, PayPal, Spotify, Quora etc are the popular projects that are built using Python language. Hire python developers to get benefited from the compelling features of the Python program. Why Python is a preferable language among the companies? In the era of Artificial Intelligence and Machine Learning certain programming languages always have a standard demand in the market irrespective of the evolution of other niche technologies. Python is one such language which never lost its momentum due to its various key features like dynamic data structure which has high-level built-in data, cost-effective language as it is an open-source programming language does not require any license cost. Various Use Cases Python technology helps various industries like web development, software development, desktop GUIs and predictive analysis like weather forecast, games scoring, almost every kind of scientific and numeric data, Desktop GUI and with network programming. Thus, Python web development company has the potential to expand its horizons across various industries that are not only limited to the IT sector but also to education and other business application models. Key Strengths Before you , have a look at these salient features of Python language which justifies that hiring a Python coder is recommended for any businesses to grow. hire a python developer Python is an open-source object-oriented programming language which means it completely eradicates the license cost and millions of users already getting benefited due to its easy availability among the other programming language. Open-Source Platform : To prevent hackers and other unauthorized internet activity, a powerful scripting language is required. Thus, Python is the best-known scripting language which facilitates the cyber-security by creating tools using this powerful scripting language. Security : As of 2019, Python 3X is the latest version which provides a cutting-edge and rich functionality with a simplified syntax, compatibility and thus undoubtedly the future of the Python programming. 
Scripting Language — The basic structure of the Python programming is derived from C, C++ and Java, which makes it an excellent choice of scripting language. Up-To-Date Versions : This powerful scripting language comes with an inbuilt unit testing framework which benefits the users while building an application with these scalable integrated models. Unit Testing : The time taken to deploy a product using Python language is comparatively quick and easy due to the agile nature of the language. The code refactoring can be done from the initial prototype model. Quick Product Delivery : Example of Python Tool Software Implementation Let us see a practical Example of how a Python Tool software is implemented in a Desktop GUI application and predicting scientific calculations like monitoring weather control stations. ODM Tool Python Software Architecture Basically, ODM is the Observation Data Model which was originally created as a standard data model that maintains and describes the observation points. Here observation point includes weather monitoring stations, the quality of the water and the stream flow with adequate metadata that is interpreted by concurrent users. To provide easy data retrieval and querying these ODM is implemented in the relational database software. Later, ODM Tools Python was created by the Python development company as an advanced version of the original ODM Tools software. The Python-based ODM Tool software has several advantages including, * Advanced Graphical User Interface with dockable components, * Supports Cross platforms - Windows, Linux and Mac, * Works with multiple Relational Database Management Systems, * Improvised versions of Plotting and Visualization, * Enabling automatic scripting of the data All these were possible by integrating Python script and edit console into the data model. What are the Technical skills a Python developer should have? Choosing the right resources is the key that ensures that the company heads in the right direction and paves way for huge growth. Hiring the best Python programmer can be a challenge, but with a little research and checking on a few criteria will make the hiring process simple and productive. The Python developer typically understands the object Oriented programming structure and follow the best practices. The developer should be comfortable with a list of a framework like Django to build a robust web development model. Other frameworks like Pyramid, TurboGears, Web2py and other micro-frameworks like Flask and Bottle and lot more are also extensively used in the industry. Frameworks : This is not a must-have qualification but good to have. When hiring a dedicated Python developer is good to ask them where they would like to spend their free time other than social media platform. Some of the top communities like Stack Overflow, CodingForums.com, DevShed, Python.org etc are some of the niche forums where the user can get the latest updates of Python language and stay connected with other Python coders worldwide. Part of Coding community : The Python developer should have expert knowledge in using the Python libraries and middleware which will be helpful for quick project development. Python Libraries and Middleware : Top Python programmers will be well-versed in implementing a real-time application with javascript, especially with NodeJS which gives several advantages to the end product. NodeJS : How to choose the right company? With all that being said about the importance of the Python language, its potential and successful implementation in various industries, hiring a Python developer is the essential step to increase the productivity of any business. Choose the right python development company which has a good reputation among the clients and positive reviews. Analyze the company which provides resources offshore as well, so that by outsourcing, your company could save a lot of money for the overall project’s cost. Conclusion To sum it up, Python language is a cost-effective programming language which can be seamlessly from a simple CGI to a complex web application using some of the mega frameworks in the market like Django, Flask and so on. Famous companies like Google, DropBox, Pinterest are some of the successful business models that have been implementing Python effectively.

How to Hire a Python Developer with the Right Skill Set

Auto-Increment Columns in Databases: A Simple Trick That Makes a Big Difference

This New Data Type Is 8 Times Faster Than JSON: Improve Your Semi-Structured Data Analysis

When it comes to building applications using Retrieval-Augmented Generation (RAG), many full-stack developers assume they need to start by learning Python and its extensive ML and GenAI ecosystem. But Typescript (or Javascript if that’s your thing) is a perfect fit for this type of application. In this post, we’ll look at the defining challenges of writing a RAG application and see how Typescript’s strengths are perfectly aligned with this problem. First of All, You Don’t Need Python Let's get this out of the way: Python is a great language with a rich tool ecosystem, but for the majority of RAG applications Python isn’t necessary. While Python's libraries and frameworks are indeed powerful for models, the reality is that you're more likely to consume existing models than train your own. Leveraging pre-trained models through libraries and APIs is the crux of RAG application development, a domain where TypeScript shines. training Many of the most popular Gen AI libraries (i.e., and ) have recognized this fact and released Typescript implementations of their toolkit. Expect to see the Typescript Gen AI ecosystem continue to grow as Gen AI becomes increasingly mainstream. LangChain LlamaIndex Prompt Engineering Is Where You’ll Spend Your Time At the heart of any retrieval-augmented generation (RAG) application, lies the art and science of prompt engineering—a  process that involves designing and refining the inputs (prompts) given to large language models (LLMs) to make the most accurate, relevant, and contextually appropriate responses. const prompt =
    PromptTemplate.fromTemplate(`Answer the question
    based only on the following context:
    {context}

    Question: {question}`); This process is important because the quality of the output generated by an LLM is directly influenced by how well the prompt is constructed. A well-engineered prompt can dramatically improve the effectiveness of the generative model, making prompt engineering arguably the most critical aspect of building a RAG application. const chain = RunnableSequence.from([
    {
        context: retriever.pipe(formatDocumentsAsString),
        question: new RunnablePassthrough(),
    },
    prompt,
    model,
    new StringOutputParser(),
]);

const stream = await chain.streamLog(question); The TypeScript ecosystem is full of tools and libraries that facilitate rich prompt engineering and inference. Frameworks like LangChain and tools for interacting with APIs from OpenAI or Vertex AI are readily accessible in the JavaScript ecosystem. Moreover, utilities like LangSmith for refining prompts and integrated logging mechanisms ensure that developers have everything they need to craft and optimize interactions with AI models. Orchestrating API Calls Is What Will Make Your App Smart At the heart of RAG apps, lies the ability to fetch, process, and synthesize information from various data sources. The “Retrieval” portion of RAG is what sets your application apart from naive ChatGPT queries. By pulling in knowledge relevant to your users’ needs, you can provide a tailored and superior experience, and this will generally be accomplished by interacting with APIs and knowledge bases. const messages =  [
    ...prompt, 
    [{role: 'user': content: 'Tell me about RAG'}]
]
const res = await openai.chat.completions.create({
    messages,
    model: 'gpt-3.5-turbo',
    temperature: 0.7,
}) TypeScript excels at orchestrating API calls and handling responses, seamlessly consolidating disparate data into cohesive, actionable insights. This ability to efficiently manage asynchronous operations and network requests is inherent to TypeScript, thanks to its event-driven nature and robust support for and syntax. Promises async/await User Experience Is King User experience can make or break a RAG application, where the dynamic and often unpredictable nature of generated content presents unique challenges for user interface (UI) and user experience (UX) design. The stochasticity (unpredictability) inherent in the responses of generative models requires interfaces that can gracefully handle and present varying outputs in a coherent and user-friendly manner. Additionally, the necessity for user feedback loops to gauge and improve the performance of generative models makes it important to design interfaces that actively engage users and encourage interaction. Given these applications' computational requirements, optimizing for streaming and minimizing latency is critical to maintaining a seamless user experience. Ensuring that the application remains responsive and interactive, even as it performs complex back-end operations, is paramount to user satisfaction and overall application success. TypeScript, with its roots deeply embedded in web technologies, is unparalleled in crafting responsive and interactive user interfaces. The ecosystem offers a variety of frameworks and libraries, such as React, Vue, and Angular, which enable you to build applications that not only look great but also perform exceptionally well, even in real-time, latency-sensitive environments. Moreover, TypeScript can run both on the client and server side, making it easier to build amazing applications quickly. Dewy Handles Document Ingestion and Indexing Document ingestion and indexing is an area where Python's mature Gen AI ecosystem has set it apart from Typescript. Until recently, the most commonly used libraries for preparing documents for RAG have been Python-based, and managing this process has been challenging: Libraries like LangChain give you a hundred ways to do the same thing and no guidance on which is best. Orchestrating document processing and vector indexing in a robust, fault-tolerant way is challenging ( ). more on this Querying and ranking extracted information is complex, and it can be difficult to understand why your results aren’t relevant to the context. These challenges are why we created . Dewy const document = await dewy.kb.addDocument({
    collection: 'receipts',
    url: document_url,
}); Dewy is a standalone knowledge base that simplifies the complex process of extracting and querying your documents. Dewy fills in the last piece of the RAG puzzle, allowing you to build applications from start to finish quickly using the tools you’re already familiar with. Conclusion The development landscape for RAG applications is evolving, with TypeScript leading the charge in accessibility, functionality, and efficiency. This ecosystem not only provides a comprehensive suite of tools for interacting with advanced AI models but also excels in the critical areas of API integration, user interface development, and data processing. If you're embarking on the journey of creating a RAG application, TypeScript offers a compelling, versatile, and powerful toolkit that aligns perfectly with the demands of modern app development. Also published here

Typescript: Why It's a Perfect Fit for Your RAG App

In this tutorial, we're focusing on how to build a question-answering CLI tool using Dewy and LangChain.js. Dewy is an open-source knowledge base that helps developers organize and retrieve information efficiently. LangChain.js is a framework that simplifies the integration of large language models (LLMs) into applications. By combining Dewy's capabilities for managing knowledge with LangChain.js's LLM integration, you can create tools that answer complex queries with precise and relevant information. This guide walks you through setting up your environment, loading documents into Dewy, and using an LLM through LangChain.js to answer questions based on the stored data. It's designed for engineers looking to enhance their projects with advanced question-answering functionalities. Why Dewy and LangChain.js? is an OSS knowledge base designed to streamline the way developers store, organize, and retrieve information. Its flexibility and ease of use make it an excellent choice for developers aiming to build knowledge-driven applications. Dewy , on the other hand, is a powerful framework that enables developers to integrate LLMs into their applications seamlessly. By combining Dewy's structured knowledge management with LangChain.js's LLM capabilities, developers can create sophisticated question-answering systems that can understand and process complex queries, offering precise and contextually relevant answers. LangChain.js The Goal Our aim is to build a simple yet powerful question-answering CLI script. This script will allow users to load documents into the Dewy knowledge base and then use an LLM, through LangChain.js, to answer questions based on the information stored in Dewy. This tutorial will guide you through the process, from setting up your environment to implementing the CLI script. You'll learn how to use LangChain to build a simple question-answering applicaiton, and how to integrate Dewy as a source of knowledge, allowing your applicaiton to answer questions based on specific documents you provide it. Prerequisites Before diving into the tutorial, ensure you have the following prerequisites covered: Basic knowledge of Typescript programming Familiarity with CLI tools development A copy of Dewy running on your local machine (see Dewy's if you need help here). installation instructions Step 1: Set Up Your Project The final code for this example is available if you'd like to jump ahead. in the Dewy repo First, create a directory for the TypeScript CLI project and change into the directory mkdir dewy_qa
cd dewy_qa With the directory set up, you can install TypeScript and initialize the project: npm init -y
npm i typescript --save-dev
npx tsc --init Depending on your environment, you may need to make some changes to your TypeScript config. Make sure that your looks something like the following: tsconfig.json {
  "compilerOptions": {
    "target": "ES6",
    "module": "CommonJS", 
    "moduleResolution": "node", 
    "declaration": true,
    "outDir": "./dist",
    "esModuleInterop": true,
    "strict": true,
} Now you're ready to create the CLI application. To keep the code from getting too messy, organize it into several directories, with the following layout dewy_qa/
├── commands/
│   └── ...
├── utils/
│   └── ...
├── index.ts
├── package.json
└── tsconfig.ts Each command will be implemented in the directory, and shared code will go in the directory. The entrypoint to the CLI application is the file . commands utils index.ts Start with a simple "hello world" version of - you'll start filling it out in the next section index.ts #!/usr/bin/env ts-node-script

console.log("hello world"); To verify the environment is setup correctly, try running the following command - you should see "hello world" printed in the console: npx ts-node index.ts Rather than typing out this very long command every time, let's create an entry in for the command. This will help us remember how to invoke the CLI, and make it easier to install as a command: package.json {
  ...
  "bin": {
    "dewy_qa": "./index.ts"
  }
  ...
} Now you can run your script with or the package and run it as just npm exec dewy_qa npm link dewy_qa Step 2: Implement document loading Load documents by setting up the Dewy client. The first step is to add some dependencies to the project. The first is , the client library for Dewy. The second is , which will help us build a CLI application with argument parsing, subcommands, and more. Finally, to makes the prompts more colorful. dewy-ts commander chalk npm install dewy-ts commander chalk Next, implement the load command's logic. You'll do this in a separate file named . This file implements a function named , which expects a URL and some additional options - this will be wired up with the CLI in a later section. commands/load.ts load Dewy makes document loading super simple - just setup the client and call with the URL of the file you'd like to load. Dewy takes care of extracting the PDF's contents, splitting them into chunks just the right size for sending to an LLM and indexing them for semantic search. addDocument import { Dewy } from 'dewy-ts'; 

import { success, error } from '../utils/colors';

export async function load(url: string, options: { collection: string, dewy_endpoint: string }): Promise<void> {
  console.log(success(`Loading ${url} into collection: ${options.collection}`));

  try {
    const dewy = new Dewy({
        BASE: options.dewy_endpoint
    })

    const result = await dewy.kb.addDocument({ collection: options.collection, url });

    console.log(success(`File loaded successfully`));
    console.log(JSON.stringify(result, null, 2));

  } catch (err: any) {
    console.error(error(`Failed to load file: ${err.message}`));
  }
} You may have noticed that some functions were imported from . This file just sets up some helpers for coloring console output - put it in so it can be used elsewhere: ../utils/colors utils import chalk from 'chalk';

export const success = (message: string) => chalk.green(message);
export const info = (message: string) => chalk.blue(message);
export const error = (message: string) => chalk.red(message); Step 3: Implement question-answering With the ability to load documents into Dewy, it's time to integrate LangChain.js to utilize LLMs for answering questions. This step involves setting up LangChain.js to query the Dewy knowledge base and process the results using an LLM to generate answers. To start, install some additional pacakges - and to use the OpenAI API as LLM: langchain openai npm install dewy-langchain langchain @langchain/openai openai This command is sort of long, so we'll walk through several pieces of it before combining them in the end Create Clients for OpenAI and Dewy The first thing to setup is Dewy (as before) and an LLM. One difference from before is that is used to build a : this is a special type used by LangChain for retrieving information as part of a chain. You'll see how the retriever is used in a just a minute. dewy DewyRetriever const model = new ChatOpenAI({
    openAIApiKey: options.openai_api_key,
});
const dewy = new Dewy({
    BASE: options.dewy_endpoint
})

const retriever = new DewyRetriever({ dewy, collection }); Create a LangChain Prompt This is a string template that instructs the LLM how it should behave, with placeholders for additional context which will be provided when the "chain" is created. In this case, the LLM is instructed to answer the question, but only using the information it's provided. This reduces the model's tendency to "hallucinate", or make up an answer that's plausible but wrong.  The values of and are provided in the next step: context question const prompt =
PromptTemplate.fromTemplate(`Answer the question 
based only on the following context:

{context}

Question: {question}`); Build the Chain LangChain works by building up "chains" of behavior that control how to query the LLM and other data sources. This example uses , which provides a more flexible programming experience than some of LangChain's original interfaces. LCEL Use a to create an LCEL chain. This chain describes how to generate the and values: the context is generated using the retriever created earlier, and the question is generated by passing through the step's input. The results Dewy retrieves are formatted as a string by piping them to the function. RunnableSequence context question formatDocumentsAsString This chain does the following: It retrieves documents using the and assigns them to and assigns the chain's input value to . DewyRetriever context question It formats the prompt string using the and variables. context question It passes the formatted prompt to the LLM to generate a response. It formats the LLM's response as a string. const chain = RunnableSequence.from([
    {
        context: retriever.pipe(formatDocumentsAsString),
        question: new RunnablePassthrough(),
    },
    prompt,
    model,
    new StringOutputParser(),
]); Execute the chain Now that the chain has been constructed, execute it and output the results to the console. As you'll see, is an input argument provided by the caller of the function. question Executing the chain using allows you to see each response chunk as it's returned from the LLM. The stream handler loop is sort of ugly, but it's just filtering to appropriate stream results and writing them to (using it would have added newlines after each chunk). chain.streamLog() STDOUT console.log const stream = await chain.streamLog(question);

// Write chunks of the response to STDOUT as they're received
console.log("Answer:");
for await (const chunk of stream) {
    if (chunk.ops?.length > 0 && chunk.ops[0].op === "add") {
        const addOp = chunk.ops[0];
        if (
        addOp.path.startsWith("/logs/ChatOpenAI") &&
        typeof addOp.value === "string" &&
        addOp.value.length
        ) {
        process.stdout.write(addOp.value);
        }
    }
} Pull it all together as a command Now that you've seen all the pieces, you're ready to create the command. This should look similar to the command from before, with some additional imports. query load import { StringOutputParser } from "@langchain/core/output_parsers";
import { PromptTemplate } from "@langchain/core/prompts";
import { formatDocumentsAsString } from "langchain/util/document";
import { RunnablePassthrough, RunnableSequence } from "@langchain/core/runnables";
import { ChatOpenAI } from "@langchain/openai";

import { Dewy } from 'dewy-ts'; 
import { DewyRetriever } from 'dewy-langchain';

import { success, error } from '../utils/colors';

export async function query(question: string, options: { collection: string, dewy_endpoint: string, openai_api_key: string }): Promise<void> {
  console.log(success(`Querying ${options.collection} collection for: "${question}"`));

  try {
    const model = new ChatOpenAI({
        openAIApiKey: options.openai_api_key,
    });
    const dewy = new Dewy({
        BASE: options.dewy_endpoint
    })

    const retriever = new DewyRetriever({ dewy, collection: options.collection });

    const prompt =
    PromptTemplate.fromTemplate(`Answer the question based only on the following context:
    {context}

    Question: {question}`);

    const chain = RunnableSequence.from([
        {
            context: retriever.pipe(formatDocumentsAsString),
            question: new RunnablePassthrough(),
        },
        prompt,
        model,
        new StringOutputParser(),
    ]);

    const stream = await chain.streamLog(question);

    // Write chunks of the response to STDOUT as they're received
    console.log("Answer:");
    for await (const chunk of stream) {
        if (chunk.ops?.length > 0 && chunk.ops[0].op === "add") {
          const addOp = chunk.ops[0];
          if (
            addOp.path.startsWith("/logs/ChatOpenAI") &&
            typeof addOp.value === "string" &&
            addOp.value.length
          ) {
            process.stdout.write(addOp.value);
          }
        }
    }

  } catch (err: any) {
    console.error(error(`Failed to query: ${err.message}`));
  }
} Step 4: Building the CLI With Dewy and LangChain.js integrated, the next step is to build the CLI interface. Use a library like to create a user-friendly command-line interface that supports commands for loading documents into Dewy and querying the knowledge base using LangChain.js. commander First, rewrite to create the subcommands and . The argument determines which Dewy collection the document should be loaded into (Dewy lets you organize documents into different collections, similar to file folders). The argument lets you specify how to connect to Dewy - by default an instance running locally on port is assumed. Finally, the argument (which defaults to an environment variable) configures the OpenAI API: index.ts load query --collection --dewy-endpoint 8000 --openai_api_key #!/usr/bin/env ts-node-script

import { Command } from 'commander';
import { load } from './commands/load';
import { query } from './commands/query';

const program = new Command();

program.name('dewy-qa').description('CLI tool for interacting with a knowledge base API').version('1.0.0');

const defaultOpenAIKey = process.env.OPENAI_API_KEY;

program
  .command('load')
  .description("Load documents into Dewy from a URL")
  .option('--collection <collection>', 'Specify the collection name', 'main')
  .option('--dewy-endpoint <endpoint>', 'Specify the collection name',  'http://localhost:8000')
  .argument('<url>', 'URL to load into the knowledge base')
  .action(load);

program
  .command('query')
  .description('Ask questions using an LLM and the loaded documents for answers')
  .option('--collection <collection>', 'Specify the collection name', 'main')
  .option('--dewy-endpoint <endpoint>', 'Specify the collection name',  'http://localhost:8000')
  .option('--openai-api-key <key>', 'Specify the collection name', defaultOpenAIKey)
  .argument('<question>', 'Question to ask the knowledge base')
  .action(query);

program.parse(process.argv); OK, all done - wasn't that easy? You can try it out by running the command: dewy_qa load https://arxiv.org/pdf/2009.08553.pdf You should see something like Loading https://arxiv.org/pdf/2009.08553.pdf into collection: main
File loaded successfully
{
  "id": 18,
  "collection": "main",
  "extracted_text": null,
  "url": "https://arxiv.org/pdf/2009.08553.pdf",
  "ingest_state": "pending",
  "ingest_error": null
} Extracting the content of a large PDF can take a minute or two, so you'll often see when you first load a new document. "ingest_state": "pending" Next, try asking some questions: dewy_qa query "tell me about RAG You should see something like Querying main collection for: "tell me about RAG"
Answer:
Based on the given context, RAG refers to the RAG proteins, 
which are involved in DNA binding and V(D)J recombination. 
The RAG1 and RAG2 proteins work together to bind specific 
DNA sequences known as RSS (recombination signal sequences) 
and facilitate the cutting and rearrangement of DNA segments 
during the process of V(D)J recombination... Conclusion By following this guide, you've learned how to create a CLI that uses Dewy to manage knowledge and LangChain.js to process questions and generate answers. This tool demonstrates the practical application of combining a structured knowledge base with the analytical power of LLMs, enabling developers to build more intelligent and responsive applications. Further Reading and Resources Dewy GitHub repository: https://github.com/Dewy Dewy TypeScript client repository: https://github.com/DewyKB/dewy-ts Dewy LangChain integration repository: https://github.com/DewyKB/dewy_langchainjs LangChain.js documentation: https://js.langchain.com OpenAI documentation: https://platform.opnai.com

Creating a Question-Answering CLI with Dewy and LangChain.js

Dewy এবং LangChain.js এর সাথে একটি প্রশ্ন-উত্তরকারী CLI তৈরি করা

Erstellen einer Frage-Antwort-CLI mit Dewy und LangChain.js

Creación de una CLI de respuesta a preguntas con Dewy y LangChain.js

Création d'une CLI de questions-réponses avec Dewy et LangChain.js

डेवी और लैंगचेन.जेएस के साथ एक प्रश्न-उत्तर सीएलआई बनाना

Dewy と LangChain.js を使用した質問応答 CLI の作成

Dewy 및 LangChain.js를 사용하여 질문 답변 CLI 생성

Criando uma CLI de resposta a perguntas com Dewy e LangChain.js

Создание CLI, отвечающего на вопросы, с помощью Dewy и LangChain.js

Dewy ve LangChain.js ile Soru Yanıtlayan CLI Oluşturma

Tạo CLI trả lời câu hỏi bằng Dewy và LangChain.js

使用 Dewy 和 LangChain.js 创建问答 CLI

Who is this article for? The material is designed for developers with little experience with , and the main reason is to refresh their knowledge. Java Table of Contents: Variables and types It will be better to use these Switch and case. Try, catch, and finally. Lambdas, streams, optional? Record class Variables and types. Let’s start with the general and important things that you really should have learned earlier. Java, like many languages, has two types of variables: Primitives: Non-Primitive: Classes and arrays! Usually, we need to compare variables, but what methods should we use? “equals” or “== “ ? Let’s look at all the comparison methods available to us: ==      equal to
!=      not equal to
>       greater than
>=      greater than or equal to
<       less than
<=      less than or equal to This tricky question was asked in the interview. We can use it with classes, but: // Integer != int
int a = 1, b = 1;
System.out.println(a == b); // true

int c = 1, j = c;
System.out.println(c == j); // true

Integer ai = Integer.valueOf(1), bi = Integer.valueOf(1);
System.out.println(ai == bi); // true 

Integer ci = Integer.valueOf(128), ji = Integer.valueOf(128);
System.out.println(ci == ji); // false
/* You can always count on the fact that 
*  for values between -128 and 127, 
*  you get the identical Integer objects after autoboxing, 
*  and on some implementations you might get identical objects
*  even for higher values.
*/ It’s important to learn that the Integer class is not a primitive value because it is a regular class. Class is the root of the class hierarchy. Every class has as a superclass. All objects, including arrays, implement the methods of this class. Object Object The “==” operator compares the values of two object references to see if they refer to the same thing. For an object, we should use “equals”: // Indicates whether some other object is "equal to" this one.
public boolean equals(Object obj) Or interface for natural ordering (if you need to sort your collection with your own type of object): Comparable public class HugePoint implements Comparable<HugePoint> {

    // same as before

    @Override
    public int compareTo(HugePoint otherHugePoint) {
        return Integer.compare(getSize(), otherHugePoint.getSize());
    }

} The interface defines a method: Comparator compare(arg1, arg2) public class HugePointComparator implements Comparator<HugePoint> {

    @Override
    public int compare(HugePoint firstPoint, HugePoint secondPoint) {
       return Integer.compare(firstPoint.getSize(), secondPoint.getSize());
    }

} It’s easy to use Java 8+ this way: Comparator<Person> byAge = Comparator.comparing(Person::getAge);

Comparator byAge = (Person person1, Person person2) -> 
    Integer.compare(person1.getAge(), person2.getAge()); Which one do you need to use and when? I would recommend using “Comparable” interface for ordering (if you have a sorting method, etc.), and “Comparator” if you need to compare objects by a special field. It will be better to use these Date and time Why? For the current timestamp, just use . We don’t need to convert to milliseconds. Instant.now() // Instant class, one of the main classes of the Date-Time API, encapsulates a point on the timeline.
Instant.now();
Instant now = Instant.parse("2021-02-09T11:19:42.12Z");
Instant before = now.minus(Duration.ofDays(1)); For the local date format use the following: // LocalDateTime is an immutable date-time object 
// that represents a date-time, often viewed 
// as year-month-day-hour-minute-second. 
LocalDateTime.now();
LocalDateTime.of(2001, Month.FEBRUARY, 10, 03, 01); UUID // uuid
UUID uuid = UUID.randomUUID();
UUID uuid = new UUID(mostSignificant64Bits, leastSignificant64Bits); Random // random for int
int randomWithMathRandom = (int) ((Math.random() * (max - min)) + min);

// or easy way
Random random = new Random();
int randomWithNextInt = random.nextInt(); Switch and case. Try, catch, and finally When we have too many conditions, and they are all tied to the same type of variable in “if-then-else,” it is worth using a switch-case. // case 
int expression = 9;
switch(expression) {
  case 2:
    System.out.println("Small Size");
    break;

  case 3:
    System.out.println("Large Size");
    break;
        
  // default case
  default:
    System.out.println("Unknown Size");
} Also, up Java to version 19 or more, and we can use the expression: Day day = Day.WEDNESDAY;
var resultDay = switch (day) {
        case MONDAY, FRIDAY, SUNDAY -> 6;
        case TUESDAY                -> 7;
        case THURSDAY, SATURDAY     -> 8;
        case WEDNESDAY              -> 9;
        default -> throw new IllegalStateException("Invalid day: " + day);
    } 

System.out.println(resultDay); Don’t forget to use try/catch with methods that can throw exceptions. Try/catch and try with resources: // old
public int find(String playerFile) {
    try {
        Scanner contents = new Scanner(new File(playerFile));
        return Integer.parseInt(contents.nextLine());
    } catch (FileNotFoundException noFile) {
        throw new IllegalArgumentException("Couldn't find the file");
    }
}

// with resources
public int find(String playerFile) {
    try (Scanner contents = new Scanner(new File(playerFile))) {
      return Integer.parseInt(contents.nextLine());
    } catch (FileNotFoundException e ) {
      logger.warn("Couldn't find the file");
      return 0;
    }
}

// don't do it!
public int find(String playerFile) {
    try {
        // action
    } catch (Exception e) {} // <== catch and swallow
    return 0;
} Use , especially with channels: finally // close it!
public int find(String playerFile) throws FileNotFoundException {
    Scanner contents = null;

    try {
        contents = new Scanner(new File(playerFile));
        return Integer.parseInt(contents.nextLine());
    } finally {
        if (contents != null) {
            contents.close();
        }
    }
}

// Always close it!
public int find(String playerFile){
    MessageChannel channel = buildChannel(port);
    try {
      // do some action with channel
    } finally {
      channel.close(); // close!
    }
} Lambdas, streams, optional? The main reason for switching to Java 8 and higher is to be able to work with threads, streams, and functional interfaces. In this article, we will cover only working with streams, and we will deal with threads on the next page. First point — collections: Also, it would be good to go through the algorithms’ complexity table. I strongly recommend using this link: or the full article . gist here Let’s analyze the two approaches and see the difference. // old way: 
List<String> old = new ArrayList<>();
old.add("one");

// new way:
List<String> list = Arrays.asList("one", "two");
List<String> list = List.of("one", "two", "three");
Set<String> set = Set.of("one", "two", "three"); We can simplify working with the map. // old:
HashMap<Integer, String> hm = new HashMap<Integer, String>();
hm.put(1, "foo");

// new:
Map<String, String> map = Map.of("foo", "one", "bar", "two"); As you know, we have only two types of operations: and operations. intermediate terminal // Intermediate Operations
var stream = ...;
stream.filter();
stream.map();
stream.flatMap();
stream.distinct();
stream.sorted();
stream.peek();
stream.limit();
stream.skip();


// Terminal
stream.reduce();
stream.forEach();
stream.min();
stream.max();
stream.anyMatch();
stream.allMatch();
stream.noneMatch();
stream.findAny();
stream.findFirst();
stream.toArray();
stream.collect();
stream.count();
stream.forEachOrdered(); Just code: // Java 7 way
ArrayList results = new ArrayList(); 
for (Score score: scores) { 
  if (score.getVal() > 10) { 
      results.add(score.getVal()); 
   } 
} 
System.out.println(results);

// Java 8+ way
ArrayList results = scores.stream()
      .filter(score -> score.getVal() > 10)
      .collect(Collectors.toList()); 

System.out.println(results); If you have a duplicate code, just use functional interfaces: // Functional 
Consumer<Integer> consumer = (n) -> { System.out.println(n); };
numbers.forEach(consumer); Throwing exceptions every time an object is not found is not a good idea; you should use the “Optional” class for this: var empty = Optional.empty();
empty.isPresent(); // false

var notEmpty = Optional.of(name);
notEmpty.isPresent(); // true

String name = null;
Optional<String> opt = Optional.ofNullable(name);
opt.isPresent(); // false

String name = null;
String result = Optional.ofNullable(nullName).orElse("Default");

// get result
var name = Optional.of("Name");
name.get(); And if you really need to throw an exception, you should use “orElseThrow”: String name = Optional.ofNullable(name)
    .orElseThrow(IllegalArgumentException::new);

// throw NoSuchElementException.class
Optional.ofNullable(name).orElseThrow(); Record classes A typical situation: API had been written with “none thread safe” methods, and we didn’t know about the magic inside the library. What exactly do I mean? Any variables are mutable by default, which means we can change the value they hold. We don’t have read-only methods for classes inside; we can change them inside any threads: public class TestObject {
  private String string;
  // public contructor 
  // getters and setters
} In action: // create new object
ExecutorService executor = Executors.newFixedThreadPool(10);
var testObject = new UsefulObject();

executor.submit(() -> testObject.setTestString("test_1"));
executor.submit(() -> testObject.setTestString("test_2"));
executor.submit(() -> testObject.setTestString("test_3"));
executor.submit(() -> testObject.setTestString("test_4")); And what about the result? // the result might be anything!
// test_1 or test_2
// or test_3
System.out.println(testObject.getTestString()); . They are immutable classes and are implicitly classes, which means they can’t be extended. Just use a record class instead of a class: Record classes are special classes that act as transparent carriers for immutable data final record MainObject(int x) { } The compiler implicitly provides the constructor, getters, & , and . equals hashCode toString public final class MainObject {

  private final int x;

  public Rectangle(int x) {
        this.x = x;
  }

  double x() { return this.x; }
  // Implementation of equals() and hashCode(), which specify
  // that two record objects are equal if they
  // are of the same type and contain equal field values.
  public boolean equals...
  public int hashCode...
  // An implementation of toString() that returns a string
  // representation of all the record class's fields,
  // including their names.
  public String toString() {...}
} If we need to share the class now, we can do it without synchronization. That’s it for the first part! Thank you, and good luck! Notes Java primitives https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html Class object https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html How we can work with collections after Java 7: https://docs.oracle.com/javase/8/docs/technotes/guides/collections/overview.html Java intermediate and terminal operation: https://javaconceptoftheday.com/java-8-stream-intermediate-and-terminal-operations/

Java Essentials: A Quick Guide for Refreshing Developers' Knowledge

As Staff Engineer on Lob’s team, I was recently tasked with standing up an endpoint for customers that supplied them with all the data we had stored for a particular zip code. We use pretty heavily to store our data so this boiled down to querying ES by zip code and writing the data to Amazon S3. But both services have subtle limitations on how you read/write them: ES caps your result set to 10,000 records, and Amazon S3 insists that you write to your buckets in chunks of at least 4 Megabytes. This turned out to be a perfect use case for Elixir streams! Address Verification Elasticsearch Elixir Streams Before we dive into the nitty gritty of Elasticsearch and AWS S3, let’s first do a brief refresher on Elixir Streams. What is a Stream? . This is typically accomplished by maintaining a little bit of state that describes where you currently are in your enumerable and a method of computing the next item. A trivial example would be a Stream of natural numbers: A Stream is a composable enumerable that is computed lazily Stream.iterate(0, fn x -> x + 1 end) The gory details of how this is implemented under the hood is the topic for another day. You rarely need to get that low level — the Stream library has a wealth of functions similar to that you can use as building blocks to construct your own Streams. And several Elixir library functions natively return streams: will turn a file (or other source) into a Stream allowing you to process very large files without having to read them into memory first in their entirety. The lazy aspect of Streams means that the minimum amount of the Stream is computed that’s needed to generate your answer. Enum IO.stream Imagine we want to find the 100th natural number that is palindromic and also divisible by 3: 1 
|> Stream.iterate(fn n -> n + 1 end) 
|> Stream.filter(fn n -> s = Integer.to_string(n); s == String.reverse(s) end)
|> Stream.filter(fn n -> rem(n, 3) == 0 end)
|> Enum.at(99) What I find elegant (and efficient) about this solution, is that no number beyond the answer, 20202, will be computed. Neat! If you’d like to dive in deeper, there’s a great Getting Started section on on the Elixir language website. The is also chock full of instructive examples. Enumerables and Streams Elixir API documentation Elasticsearch Now onto . The first thing to know is that After scrutinizing the documentation, it became clear that the original method that popped up on my Stack Overflow ( ) had been deprecated and the new approved method was to use . The process is: Elasticsearch ES caps the size of the result set at 10k items. Scroll API PointInTime IDs PIT IDs essentially give you a snapshot of your index at one point in time so that you get a consistent view of your search results across multiple queries. acquire a PIT for your index perform your queries using the PIT (without the index — it’s now implicit in the PID) delete the PIT That last step is crucial — PITs are extremely resource hungry so it is vital that you delete them as soon as you’re done. I borked our staging ES in my early experiments with PITs because I wasn’t deleting them and the expiration parameter seemed to have no effect. The other thing we’d like to do is abstract away the underlying PIT and paging mechanism for the end user so we provide an interface that just takes an ES query and generates a Stream of hits. Let’s start by creating and deleting the PID. is just a matter of requesting a PID associated with the index that we’re interested in running queries against. Creating the PID @spec create(ES.index_t()) :: {:ok, pit_t()} | {:error, ES.response_t()}
def create(index) do
  :post
  |> HTTP.request(url(index), HTTP.no_payload(), HTTP.json_encoding())
  |> HTTP.on_200(& &1["id"])
end is a simple HTTP delete except that the PIDs are huge so you need to supply them in the body and not as URL params. Some HTTP libraries won’t let you do this. The HTTP spec is a little muddy on the matter and last I checked on Stack Overflow there was a healthy debate on the subject. This is why we use HTTPoison — it allows payloads on DELETE requests. Deleting a PID @spec delete(pit_t()) :: :ok | {:error, HTTPoison.AsyncResponse | HTTPoison.MaybeRedirect | HTTPoison.Response}
def delete(pit) do
  url = HTTP.generate_url("_pit", ES.no_index(), HTTP.no_options())

  with {:ok, payload} <- Poison.encode(%{"id" => pit}),
        %HTTPoison.Response{status_code: 200} <-
          HTTPoison.request!(:delete, url, payload, HTTP.headers(HTTP.json_encoding())) do
    :ok
  else
    error -> {:error, error}
  end
end Our basic query is enhanced with three extra parameters: Now that the PIDs are sorted out, our next order of business is figuring out how to leverage them in our queries. size of 10,000 (the maximum allowed by elastic search) pit, a hash that contains %{id: <id>, keep_alive: “1m”} sort, a hash that contains %{_shard_doc: “desc”} (For sort, you need to provide something and is baked into every Elastic search index so that’s nice and portable.) _shard_doc @spec initial(PIT.pit_t(), ES.query_t()) :: ES.query_t()
def initial(pit, query) do
  %{
    query: query,
    pit: %{id: pit, keep_alive: PIT.expiration()},
    size: ES.max_results(),
    sort: %{"_shard_doc" => "desc"}
  }
end The trick here is that we feed into the next query the value of our sort field from the last hit of the previous result, like so: With our basic query down, we can focus on how to generate the sequence of queries that will extract all the items that satisfy our search criteria. @spec update(ES.query_t(), ES.response_t()) :: ES.query_t()
def update(query, %Req.Response{body: %{"hits" => %{"hits" => hits}}, status: 200}) do
  Map.put(query, :search_after, List.last(hits)["sort"])
end Armed with these two query-generating functions, we can code up that will pull all the results out of our desired index: Stream.iterator @spec streamer(ES.query_t()) :: {:ok, Enumerable.t()} | {:error, any}
def streamer(initial) do
  {:ok,
    initial
    |> search()
    |> Stream.iterate(fn previous -> search(Query.update(initial, previous)) end)
   }
rescue
  error -> {:error, error}
end We need a high-level function that takes the results from this function and produces a Stream of hits. But there’s a wrinkle — we have to delete the PIT when we are done with the Stream. But how will we know? The solution is to pass in a consumer that consumes the Stream and then we delete the PIT afterward, like so: @spec stream_many(ES.query_t(), ES.index_t(), ES.consumer_t(), non_neg_integer()) :: {:error, any()} | {:ok, Enumerable.t()}
def stream_many(query, index, consumer, count) do
  case PIT.create(index) do
    {:ok, pit_id} ->
      try do
        case pit_id |> Query.initial(query) |> streamer() do
          {:ok, stream} ->
            stream
            |> Stream.flat_map(& &1.body["hits"]["hits"])
            |> Stream.take(count)
            |> then(consumer)
          error -> error
        end
      after
        PIT.delete(pit_id)
      end
    error -> error
  end
rescue
  error -> {:error, error}
end But if our query returns less than 10k results, we don’t need the whole PID/sort/search_after machinery — one query will do the trick. @spec stream_one(ES.query_t(), ES.index_t(), ES.consumer_t()) :: {:ok, any()} | {:error, any()}
def stream_one(query, index, consumer) do
  query
  |> search(index)
  |> HTTP.on_200(fn body -> consumer.(body["hits"]["hits"]) end)
end Now we need a top-level function that query the size of the result and chooses between or depending on the value, like so: stream_one stream_many @spec stream(ES.query_t(), ES.index_t(), ES.consumer_t()) :: {:ok, any()} | {:error, any()}
def stream(query, index, consumer) do
  case count(query, index) do
    {:ok, count} ->
      if count > ES.max_results() do
        stream_many(query, index, consumer, count)
      else
        stream_one(query, index, consumer)
      end
    error ->
      error
  end
end AWS S3 The library we use to access is It handles all the low-level details for us but it does have one requirement: . Amazon S3 ex_aws_s3. the input data stream must be chunks of at least 4 Mbytes To accomplish this, we use the Stream function . This takes four inputs: chunk_while the enumerable to be chunked the initial value of the accumulator the step function a finalizer function Our first decision is, what should the accumulator look like that gets passed forward by the step function? It obviously should contain the list of the items in the current chunk. But more subtly, it should also contain the size of the current chunk so we don’t waste resources recomputing it each time. So that gives us a two-element tuple containing a list and an integer. Next, we turn our attention to the function. It should check if the current size is greater than or equal to the desired chunk size. If it is, we should take the list of items from the accumulator and convert them into a chunk using ; if not, we should add it to the current chunk (and update the size) using step convert add_chunk. What should do? Just push the item onto the front of a list and increase the value of by the current chunk’s size. add_chunk size The behaviour of depends on whether we care about the order of the items in the chunk being preserved in the output because the items in the list will be in reverse order so need to be reversed. But if we don’t care, we can skip that transformation. Putting this all together gives us: convert @spec chunker(Enumerable.t(), non_neg_integer(), boolean(), (any() -> non_neg_integer()), (Enumerable.t() -> any())) :: Enumerable.t()
def chunker(
        chunks,
        chunk_size,
        ordered \\ true,
        sizer \\ &String.length/1,
        joiner \\ &Enum.join/1
      ) do
  zero = {0, []}
  convert =
    if ordered do
      fn chunks -> chunks |> Enum.reverse() |> then(joiner) end
    else
      joiner
    end

  final = fn {_, chunks} -> {:cont, convert.(chunks), zero} end
  add_chunk = fn {size, chunks}, chunk -> {size + sizer.(chunk), [chunk | chunks]} end

  step = fn chunk, accum = {size, chunks} ->
    if size >= chunk_size do
      {:cont, convert.(chunks), add_chunk.(zero, chunk)}
    else
      {:cont, add_chunk.(accum, chunk)}
    end
  end

  Stream.chunk_while(chunks, zero, step, final)
end We can now combine all the components we have written to produce a simple controller action that requests an output stream of hits from our Elasticsearch section into 4M chunks that will satisfy the requirement of the ExAWS.S3 module: defmodule Controller do
  @four_megabytes 4*1024*1024

  def find_all(params) do
    query(params) |> ElasticSearch.stream(params.index, &consumer(params, &1))
  end
  
  def query(params) do
    %{term: %{params.query_term => params.query_value}}
  end
  
  def consumer(params, stream) do
    stream
    |> Stream.map(&Poison.encode!(&1["_source"]))
    |> chunker(@four_megabytes, false)
    |> S3.upload(params.bucket, params.filename)
    |> ExAws.request()
  end
end And that wraps up our exploration of Elixir streams, Elasticsearch, and AWS S3. I hope you enjoyed it! By Lob Staff Engineer, Guy Argo.

A Look at Using Elixir Streams, Elasticsearch & AWS S3

Stories, News & Mentions about STREAMFLOW

Streamflow’s Stories on HackerNoon