Documentation – AI-powered Features

Java: AI Models Supported by Aspose.Words

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Words now leverages advanced AI models to enhance document processing and analysis. With the Aspose.Words.AI namespace, developers can access AI-powered features such as document summarization and analysis, document translation, and grammar checking by integrating generative language models from industry leaders.

Supported Model Types

Aspose.Words library currently supports integration with:

OpenAI,
Google,
and Claude models' families.

These models bring powerful capabilities for working with documents. By enabling seamless interaction with these AI tools, Aspose.Words simplifies complex tasks and enhances productivity for developers.

The full list of supported model types is listed in the AiModelType enumeration.

You can create a model instance using the Create method of the AiModel class.

The following code example shows how to create a new instance of AiModel class:

public static AiModel create(int modelType)

For more information, check the Java API documentation.

Using Self-hosted LLM Implementations

With Aspose.Words, developers can also integrate self-hosted LLMs (Large Language Models), providing an alternative to OpenAI/Anthropic/Google’s hosted services.

The following code example shows how to create a self-hosted LLM based on OpenAI’s generative language model:

public void selfHostedModel() throws Exception
{
    Document doc = new Document(getMyDir() + "Big document.docx");

    String apiKey = System.getenv("API_KEY");
    // Use OpenAI generative language models.
    AiModel model = new CustomAiModel().withApiKey(apiKey);

    Document translatedDoc = model.translate(doc, Language.RUSSIAN);
    translatedDoc.save(getArtifactsDir() + "AI.SelfHostedModel.docx");
    }

// Custom self-hosted AI model.
static class CustomAiModel extends OpenAiModel
{
    protected String getUrl()
    {
        return "https://localhost/";
    }

    protected String getName()
    {
        return "my-model-24b";
    }
}

FAQ

Q: Which AI model families are supported by Aspose.Words for Java?
A: Aspose.Words for Java supports models from OpenAI, Google (Gemini), and Anthropic’s Claude families. The supported models are listed in the AiModelType enumeration.
Q: How do I create an AiModel instance for a specific model type?
A: Use the static AiModel.create(int modelType) method, passing the integer value from the AiModelType enum that corresponds to the desired model (e.g., AiModelType.GPT_4O). The method returns an AiModel object ready for translation, summarization, etc.
Q: Can I use a self‑hosted LLM with Aspose.Words?
A: Yes. Derive a class from the appropriate base model (e.g., OpenAiModel) and override getUrl() and getName() to point to your self‑hosted endpoint. Instantiate your custom class and use it like any other AiModel.
Q: Do I need a separate license to use AI features in Aspose.Words?
A: No additional license is required. AI capabilities are included with a regular Aspose.Words for Java license. Ensure your license file is loaded correctly using License license = new License(); license.setLicense("Aspose.Words.Java.lic");.
Q: How can I find the integer value for a specific AiModelType enumeration member?
A: In Java, you can call AiModelType.GPT_4O.getValue() (or simply refer to the constant’s name) to obtain its underlying integer value, which you then pass to AiModel.create. This value is also documented in the API reference.

Java: Summarize a Document

Mon, 01 Jan 0001 00:00:00 +0000

Summarizing documents is a valuable tool for content review, quick insights, or preparing abstracts. Aspose.Words supports document summarization using AI-powered models, making it easier to process long text. This feature, available in the AI-based Aspose.Words functionality, integrates advanced generative language models from OpenAI and Google, as well as Claude’s anthropic generative language models. The list of supported models is available in the AiModelType enumeration.

You can specify various options for summarizing document content. Use the Summarize method to generate a summary of your document. You can also set summary length using the SummaryLength property.

With Aspose.Words, implementing document summarization is straightforward. The following code example shows how to summarize a document using GPT-4o model:

Document firstDoc = new Document(getMyDir() + "Big document.docx");
 Document secondDoc = new Document(getMyDir() + "Document.docx");

 String apiKey = System.getenv("API_KEY");
 // Use OpenAI or Google generative language models.
 IAiModelText model = (IAiModelText)AiModel.create(AiModelType.GPT_4_O_MINI).withApiKey(apiKey);

 Document oneDocumentSummary = model.summarize(firstDoc, new SummarizeOptions(); { oneDocumentSummary.setSummaryLength(SummaryLength.SHORT); });
 oneDocumentSummary.save(getArtifactsDir() + "AI.AiSummarize.One.docx");

 Document multiDocumentSummary = model.summarize(new Document[] { firstDoc, secondDoc }, new SummarizeOptions(); { multiDocumentSummary.setSummaryLength(SummaryLength.LONG); });
 multiDocumentSummary.save(getArtifactsDir() + "AI.AiSummarize.Multi.docx");

Summarizing documents with Aspose.Words saves time and helps you focus on essential information. For more information, check the Java API documentation.

Java: Translate a Document

Mon, 01 Jan 0001 00:00:00 +0000

Document translation is a frequently needed option in the age of high digitalization. Aspose.Words supports document translation using Google generative language models, which allows developers to translate texts content into more than 300 languages.

Use the Translate method to translate your documents into any language represented in the Language enumeration. Note that if the source document contains several languages, the Google AI-based model will be able to translate all supported languages. If the model cannot recognize the language in some text fragments, then you will be returned a document with these untranslated fragments and with the rest of the text translated.

The following code example shows how to use the Gemini 1.5 Flash model in Aspose.Words to translate a document into Arabic:

Document doc = new Document("Document.docx");

String apiKey = System.getenv("API_KEY");
 IAiModelText model = (IAiModelText)AiModel.create(AiModelType.GEMINI_15_FLASH).withApiKey(apiKey);

Document translatedDoc = model.translate(doc, Language.ARABIC);
translatedDoc.save("AI.AiTranslate.docx");

Translating documents with Aspose.Words saves time and makes it easy to integrate translation functionality into your projects. For more information, check the Java API documentation.

FAQ

Q: Do I need a Google API key to use the translation feature?
A: Yes. The translation functionality relies on Google generative models, so you must provide a valid API key when creating the AiModel instance.
Q: Which languages can I translate to?
A: Any language listed in the Language enumeration (over 300 languages) is supported. Use Language.<LANGUAGE> to specify the target language.
Q: Can I translate only a part of a document, such as a single section?
A: The translate method works on the whole Document object. To translate a specific part, extract that part into a separate Document, translate it, and then replace the original content.
Q: What happens if the source document contains multiple languages?
A: The model attempts to detect and translate each language it recognizes. Segments in unsupported or unrecognizable languages remain unchanged in the output document.
Q: Can I choose a different AI model for translation?
A: Yes. When creating the model, use AiModel.create(AiModelType.<MODEL>) with any supported model type (e.g., GEMINI_15_FLASH, GEMINI_1_0_PRO). The chosen model determines translation quality and speed.

Java: AI Grammar Checking

Mon, 01 Jan 0001 00:00:00 +0000

Checking grammar in documents is important to ensure clarity, professionalism, and accuracy. Well-written documents leave a positive impression and avoid misunderstandings. Grammar checks help identify and correct errors quickly, saving time and improving quality.

Aspose.Words allows users to check grammar and detect errors in documents using the OpenAI, Google, and Claude models' families listed in the AiModelType enumeration. Use the CheckGrammar method to analyze the text in a document and highlights grammatical problems.

The following code example shows how to use the GPT-4o mini model in Aspose.Words to check grammar:

 Document doc = new Document("Big document.docx");

 String apiKey = System.getenv("API_KEY");
 // Use OpenAI generative language models.
 IAiModelText model = (OpenAiModel)AiModel.create(AiModelType.GPT_4_O_MINI).withApiKey(apiKey);

 CheckGrammarOptions grammarOptions = new CheckGrammarOptions();
 grammarOptions.setImproveStylistics(true);

 Document proofedDoc = model.checkGrammar(doc, grammarOptions);
 proofedDoc.save("AI.AiGrammar.docx");

Checking grammar with Aspose.Words improves the quality of your work and makes it easy to integrate proofreading into your projects. For more information, check the Java API documentation.

FAQ

Q: Which AI models can I use for grammar checking with Aspose.Words for Java?
A: The AiModelType enumeration lists all supported families, including OpenAI (e.g., GPT_4_O_MINI, GPT_4_TURBO), Google (e.g., GEMINI_PRO), and Anthropic Claude models. Choose the model that fits your accuracy and cost requirements.
Q: How do I provide the API key for the selected AI model?
A: Create the model instance with AiModel.create(...).withApiKey(yourKey). The key can be read from an environment variable, configuration file, or any secure store. Example:
```
String apiKey = System.getenv("API_KEY");
IAiModelText model = (OpenAiModel)AiModel.create(AiModelType.GPT_4_O_MINI).withApiKey(apiKey);
```
Q: Can I run checkGrammar on a document that is loaded from a stream instead of a file path?
A: Yes. Load the document from any InputStream using new Document(inputStream), then pass the Document object to model.checkGrammar. The API works the same regardless of how the document was created.
Q: Does the checkGrammar method modify the original Document instance?
A: No. checkGrammar returns a new Document containing the proofed content, leaving the original document unchanged. Save the returned document to persist the corrections.
Q: What licensing is required to use the AI grammar‑checking feature?
A: You need a valid Aspose.Words for Java license for the core library and a separate subscription or API key for the chosen AI service (OpenAI, Google, or Claude). The AI models are billed by the provider, not by Aspose. Ensure both licenses are active before invoking checkGrammar.